From 3e4d6542b3653232ef8c8ed7d87831c6d710f246 Mon Sep 17 00:00:00 2001
From: Danielwhyte <danwhy@gmail.com>
Date: Thu, 14 Feb 2019 17:14:12 +0000
Subject: [PATCH 01/35] begins ecto adapter, #38

---
 lib/alog.ex            | 439 ++---------------------------------------
 lib/alog/connection.ex |  16 ++
 mix.exs                |   2 +-
 mix.lock               |   9 +-
 4 files changed, 33 insertions(+), 433 deletions(-)
 create mode 100644 lib/alog/connection.ex

diff --git a/lib/alog.ex b/lib/alog.ex
index c967446..e0fde26 100644
--- a/lib/alog.ex
+++ b/lib/alog.ex
@@ -1,435 +1,18 @@
 defmodule Alog do
-  @moduledoc """
-  Behaviour that defines functions for accessing and inserting data in an
-  Append Only database.
+  use Ecto.Adapters.SQL,
+    driver: :postgrex,
+    migration_lock: "FOR UPDATE"
 
-  ## Usage
-
-  At the top of the schema you wish to use append only functions for, `use` this module:
-
-      use Alog
-
-  The append only functions will then be available to call as part of your schema.
-
-  ## Example
-
-      defmodule MyApp.User do
-        use Ecto.Schema
-        use Alog
-
-        import Ecto.Changeset
-
-        schema "users" do
-          ...
-        end
-
-        def changeset(user, attrs) do
-          ...
-        end
-      end
-
-  You can set the repo you want Alog to use in a config file:
-
-      config :alog, Alog,
-        repo: MyApp.Repo
-
-  If you do not explicitly set a Repo, Alog will try to find it using your application name.
-  So if your app is `MyApp` and your schema is `MyApp.User`, or `MyApp.Accounts.User`, your Repo should be `MyApp.Repo`.
-
-  Any schema that uses Alog must include the fields `:deleted` of type `:boolean` and default false,
-  and `:entry_id` of type `:string`.
-
-        field(:deleted, :boolean, default: false)
-        field(:entry_id, :string)
-  """
-
-  @callback insert(Ecto.Schema.t() | Ecto.Changeset.t()) ::
-              {:ok, Ecto.Schema.t()} | {:error, Ecto.Changeset.t()}
-  @callback get(String.t()) :: Ecto.Schema.t() | nil | no_return()
-  @callback get_by(Keyword.t() | map(), Keyword.t()) :: Ecto.Schema.t() | nil | no_return()
-  @callback update(Ecto.Changeset.t()) :: {:ok, Ecto.Schema.t()} | {:error, Ecto.Changeset.t()}
-  @callback get_history(Ecto.Schema.t()) :: [Ecto.Schema.t()] | no_return()
-  @callback delete(Ecto.Schema.t() | Ecto.Changeset.t()) ::
-              {:ok, Ecto.Schema.t()} | {:error, Ecto.Changeset.t()}
-  @callback preload(Ecto.Schema.t() | list(Ecto.Schema.t()), atom() | list()) ::
-              Ecto.Schema.t() | list(Ecto.Schema.t())
-
-  defmacro __using__(_opts) do
-    quote location: :keep do
-      @behaviour Alog
-      @before_compile unquote(__MODULE__)
-    end
+  @impl true
+  def supports_ddl_transaction? do
+    true
   end
 
-  defmacro __before_compile__(_env) do
-    quote generated: true, location: :keep do
-      import Ecto.Query
-      import Ecto.Query.API, only: [field: 2]
-
-      @repo apply(unquote(__MODULE__), :get_repo, [__MODULE__])
-
-      if not Map.has_key?(%__MODULE__{}, :deleted) || not is_boolean(%__MODULE__{}.deleted) do
-        raise """
-
-        Your Schema must have a key :deleted, with type :boolean and default false.
-
-        Add the following line to your schema:
-
-            field(:deleted, :boolean, default: false)
-        """
-      end
-
-      if not Map.has_key?(%__MODULE__{}, :entry_id) do
-        raise """
-
-        Your Schema must have a key :entry_id, with type :string
-
-        Add the following line to your schema:
-
-            field(:entry_id, :string)
-        """
-      end
-
-      @doc """
-      Inserts a struct made with a schema or a changeset into the database.
-      Adds an entry id to link it to future updates of the item.
-
-      If `cast_assoc` has been used on the changeset before passing it to this function,
-      any nested associations will also be given an `entry_id` before they are
-      inserted into the database.
-
-          %User{name: "username", age: "25"}
-          |> User.insert()
-
-          %User{}
-          |> User.changeset(%{name: "username", age: "25"})
-          |> User.insert()
-      """
-      def insert(struct_or_changeset) do
-        case check_for_unique_index() do
-          :ok ->
-            struct_or_changeset
-            |> insert_entry_id()
-            |> apply_constraints()
-            |> @repo.insert()
-
-          {:error, msg} ->
-            raise msg
-        end
-      end
-
-      @doc """
-      Gets the item from the database that matches the given entry id.
-      Gets the most recently inserted item if it is not marked as deleted.
-
-          User.get("5ds4fg31-a7f1-2hd8-x56a-d4s3g7ded1vv2")
-      """
-      def get(entry_id) do
-        sub =
-          from(
-            m in __MODULE__,
-            where: m.entry_id == ^entry_id,
-            order_by: [desc: :updated_at],
-            limit: 1,
-            select: m
-          )
-
-        query = from(m in subquery(sub), where: not m.deleted, select: m)
-
-        item = @repo.one(query)
-      end
-
-      @doc """
-      Gets an item from the database that matches the given clause.
-
-          User.get_by(username: "admin")
-          User.get_by(first_name: "Charlie", age: 27)
-
-      ## Options
-
-          - :case_insensitive (boolean) - whether your query should be case insensitive. Defaults to `false`.
-
-      If using the `:case_insensitive` option, you should consider adding a lowercase index to your table,
-      as it will significantly increase the query speed. For example:
-
-          `create index("users", ["(lower(first_name))"], first_name: :users_lower_first_name_index)`
-
-      See https://hexdocs.pm/ecto_sql/Ecto.Migration.html#index/3 for more details.
-
-      If passing options, make sure your clauses are wrapped in square brackets, or passed as a map:
-
-          User.get([first_name: "charlie"], case_insensitive: true)
-          User.get(%{first_name: "charlie"}, case_insensitive: true)
-      """
-      def get_by(clauses, opts \\ []) do
-        sub =
-          __MODULE__
-          |> (fn q ->
-                Enum.reduce(clauses, q, fn {key, value}, q ->
-                  case Keyword.get(opts, :case_insensitive) do
-                    true ->
-                      q
-                      |> where(
-                        [m],
-                        fragment("lower(?)", field(m, ^key)) == ^String.downcase(value)
-                      )
+  @behaviour Ecto.Adapter.Storage
 
-                    _ ->
-                      q |> where([m], field(m, ^key) == ^value)
-                  end
-                end)
-              end).()
-          |> order_by([m], desc: m.updated_at)
-          |> distinct([m], m.entry_id)
-          |> select([m], m)
+  @impl true
+  defdelegate storage_up(opts), to: Ecto.Adapters.Postgres
 
-        query = from(m in subquery(sub), where: not m.deleted, select: m)
-
-        query
-        |> @repo.all
-        |> Enum.filter(fn item -> item && __MODULE__.get(item.entry_id) == item end)
-        |> List.last()
-      end
-
-      @doc """
-      Updates an item in the database.
-      Copies the current row, updates the relevant fields and appends
-      it to the database table.
-      Requires a changeset to be given.
-
-          User.get("5ds4fg31-a7f1-2hd8-x56a-d4s3g7ded1vv2")
-          |> User.changeset(%{age: 44})
-          |> User.update()
-      """
-      def update(%Ecto.Changeset{} = changeset) do
-        case check_for_unique_index() do
-          :ok ->
-            data =
-              changeset
-              |> Map.get(:data)
-              |> @repo.preload(__MODULE__.__schema__(:associations))
-              |> Map.put(:id, nil)
-              |> Map.put(:updated_at, nil)
-
-            changeset
-            |> apply_constraints()
-            |> Map.put(:data, data)
-            |> @repo.insert()
-
-          {:error, msg} ->
-            raise msg
-        end
-      end
-
-      def update(_) do
-        raise ArgumentError, "The argument provided to update/1 must be an Ecto.Changeset"
-      end
-
-      @doc """
-      Gets the full history of an item in the database.
-
-          User.get("5ds4fg31-a7f1-2hd8-x56a-d4s3g7ded1vv2")
-          |> User.get_history()
-      """
-      def get_history(%__MODULE__{} = item) do
-        query =
-          from(m in __MODULE__,
-            where: m.entry_id == ^item.entry_id,
-            select: m
-          )
-
-        @repo.all(query)
-      end
-
-      @doc """
-      Gets all of the distinct instances of a schema that have not been deleted.
-
-          User.all()
-      """
-      def all do
-        sub =
-          from(m in __MODULE__,
-            distinct: m.entry_id,
-            order_by: [desc: :updated_at],
-            select: m
-          )
-
-        query = from(m in subquery(sub), where: not m.deleted, select: m)
-
-        @repo.all(query)
-      end
-
-      @doc """
-      Marks an item as deleted in the database.
-      Deleted items will not show up in queries.
-
-          User.get("5ds4fg31-a7f1-2hd8-x56a-d4s3g7ded1vv2")
-          |> User.delete()
-
-          User.get("5ds4fg31-a7f1-2hd8-x56a-d4s3g7ded1vv2")
-          |> User.changeset(%{})
-          |> User.delete()
-      """
-      def delete(%Ecto.Changeset{} = changeset) do
-        changeset
-        |> Ecto.Changeset.put_change(:deleted, true)
-        |> update()
-      end
-
-      def delete(%__MODULE__{} = entry) do
-        entry
-        |> Ecto.Changeset.cast(%{deleted: true}, [:deleted])
-        |> update()
-      end
-
-      @doc """
-      Preloads an item's (or list of items') multiple associations.
-      Also preloads any nested associations.
-
-          # Load all of a user's friends and comments
-          User.get("5ds4fg31-a7f1-2hd8-x56a-d4s3g7ded1vv2")
-          |> User.preload([:friends, :comments])
-
-          # Load all of a user's friends, and all of their friends' comments
-          User.get("5ds4fg31-a7f1-2hd8-x56a-d4s3g7ded1vv2")
-          |> User.preload([friends: [:comments]])
-      """
-      def preload(item, assocs) when is_list(assocs) do
-        @repo.preload(
-          item,
-          Enum.map(assocs, fn a ->
-            preload_map(a, __MODULE__)
-          end)
-        )
-      end
-
-      @doc """
-      Preloads an item's (or list of items') association.
-
-          User.get("5ds4fg31-a7f1-2hd8-x56a-d4s3g7ded1vv2")
-          |> User.preload(:friends)
-      """
-      def preload(item, assoc) do
-        @repo.preload(item, [{assoc, preload_query(assoc)}])
-      end
-
-      defp apply_constraints(%Ecto.Changeset{} = changeset) do
-        changeset
-        |> Map.get(:constraints)
-        |> Enum.reduce(changeset, fn con, acc ->
-          with :unique <- con.type,
-               change when not is_nil(change) <- Map.get(changeset.changes, con.field),
-               existing when not is_nil(existing) <- __MODULE__.get_by([{con.field, change}]) do
-            Ecto.Changeset.add_error(acc, con.field, Map.get(con, :error) |> elem(0))
-          else
-            _ -> acc
-          end
-        end)
-      end
-
-      defp apply_constraints(struct), do: struct
-
-      defp preload_map(assoc, owner) do
-        case assoc do
-          {k, v} ->
-            assoc_module = owner.__schema__(:association, k).queryable
-            {k, {preload_query(k, owner), Enum.map(v, fn a -> preload_map(a, assoc_module) end)}}
-
-          k ->
-            {k, preload_query(k, owner)}
-        end
-      end
-
-      @doc false
-      def preload_query(assoc, module \\ __MODULE__) do
-        sub =
-          from(mod in Map.get(module.__schema__(:association, assoc), :queryable),
-            distinct: mod.entry_id,
-            order_by: [desc: :updated_at],
-            select: mod
-          )
-
-        from(m in subquery(sub), where: not m.deleted, select: m)
-      end
-
-      defp insert_entry_id(%Ecto.Changeset{} = entry) do
-        with {:ok, nil} <- Map.fetch(entry.data, :entry_id),
-             nil <- get_change(entry, :entry_id) do
-          entry
-          |> put_change(:entry_id, Ecto.UUID.generate())
-          |> insert_nested_entry_ids()
-        else
-          _ ->
-            entry
-        end
-      end
-
-      defp insert_entry_id(%__MODULE__{} = entry) do
-        case Map.fetch(entry, :entry_id) do
-          {:ok, nil} -> %{entry | entry_id: Ecto.UUID.generate()}
-          _ -> entry
-        end
-      end
-
-      defp insert_nested_entry_ids(changeset) do
-        assocs = changeset.data.__struct__.__schema__(:associations)
-
-        Enum.reduce(changeset.changes, changeset, fn {k, v}, acc ->
-          if k in assocs do
-            assoc =
-              case v do
-                l when is_list(l) -> Enum.map(l, &insert_entry_id/1)
-                item -> insert_entry_id(item)
-              end
-
-            Ecto.Changeset.put_change(acc, k, assoc)
-          else
-            acc
-          end
-        end)
-      end
-
-      defp check_for_unique_index() do
-        table = __MODULE__.__schema__(:source)
-        "Elixir." <> module_name = unquote(__MODULE__) |> to_string()
-
-        case @repo.query(
-               "SELECT * FROM pg_indexes WHERE tablename = $1 and indexname NOT LIKE '%_pkey' AND indexdef LIKE 'CREATE UNIQUE INDEX%';",
-               [table]
-             ) do
-          {:ok, %Postgrex.Result{columns: columns, rows: rows}} when rows != [] ->
-            unique_index =
-              rows
-              |> List.first()
-              |> Enum.zip(columns)
-              |> Enum.find(fn {_r, c} -> c == "indexname" end)
-              |> elem(0)
-
-            {:error,
-             """
-               Unique index '#{unique_index}' found on table '#{table}'.
-               #{module_name} is not compatible with tables that have a unique index.
-               Please remove this index if you want to use #{module_name}.
-             """}
-
-          _ ->
-            :ok
-        end
-      end
-
-      defoverridable Alog
-    end
-  end
-
-  def get_repo(module) do
-    with config when not is_nil(config) <- Application.get_env(:alog, Alog),
-         repo when not is_nil(repo) <- Keyword.get(config, :repo) do
-    else
-      _ ->
-        module
-        |> Module.split()
-        |> List.first()
-        |> Module.concat("Repo")
-    end
-  end
+  @impl true
+  defdelegate storage_down(opts), to: Ecto.Adapters.Postgres
 end
diff --git a/lib/alog/connection.ex b/lib/alog/connection.ex
new file mode 100644
index 0000000..775cbd2
--- /dev/null
+++ b/lib/alog/connection.ex
@@ -0,0 +1,16 @@
+defmodule Alog.Connection do
+  @behaviour Ecto.Adapters.SQL.Connection
+
+  @impl true
+  defdelegate ddl_logs(result), to: Ecto.Adapter.Postgres
+
+  @impl true
+  defdelegate prepare_execute(connection, name, statement, params, options),
+    to: Ecto.Adapter.Postgres
+
+  @impl true
+  defdelegate query(connection, statement, params, options), to: Ecto.Adapter.Postgres
+
+  @impl true
+  defdelegate stream(connection, statement, params, options), to: Ecto.Adapter.Postgres
+end
diff --git a/mix.exs b/mix.exs
index a6e7b9e..f4f98da 100644
--- a/mix.exs
+++ b/mix.exs
@@ -27,7 +27,7 @@ defmodule Alog.MixProject do
   # Run "mix help deps" to learn about dependencies.
   defp deps do
     [
-      {:ecto, "~> 2.2.10"},
+      {:ecto_sql, "~> 3.0.5"},
       {:postgrex, ">= 0.0.0"}
     ]
   end
diff --git a/mix.lock b/mix.lock
index 7f16fd1..dc26038 100644
--- a/mix.lock
+++ b/mix.lock
@@ -1,8 +1,9 @@
 %{
   "connection": {:hex, :connection, "1.0.4", "a1cae72211f0eef17705aaededacac3eb30e6625b04a6117c1b2db6ace7d5976", [:mix], [], "hexpm"},
-  "db_connection": {:hex, :db_connection, "1.1.3", "89b30ca1ef0a3b469b1c779579590688561d586694a3ce8792985d4d7e575a61", [:mix], [{:connection, "~> 1.0.2", [hex: :connection, repo: "hexpm", optional: false]}, {:poolboy, "~> 1.5", [hex: :poolboy, repo: "hexpm", optional: true]}, {:sbroker, "~> 1.0", [hex: :sbroker, repo: "hexpm", optional: true]}], "hexpm"},
+  "db_connection": {:hex, :db_connection, "2.0.5", "ddb2ba6761a08b2bb9ca0e7d260e8f4dd39067426d835c24491a321b7f92a4da", [:mix], [{:connection, "~> 1.0.2", [hex: :connection, repo: "hexpm", optional: false]}], "hexpm"},
   "decimal": {:hex, :decimal, "1.6.0", "bfd84d90ff966e1f5d4370bdd3943432d8f65f07d3bab48001aebd7030590dcc", [:mix], [], "hexpm"},
-  "ecto": {:hex, :ecto, "2.2.11", "4bb8f11718b72ba97a2696f65d247a379e739a0ecabf6a13ad1face79844791c", [:mix], [{:db_connection, "~> 1.1", [hex: :db_connection, repo: "hexpm", optional: true]}, {:decimal, "~> 1.2", [hex: :decimal, repo: "hexpm", optional: false]}, {:mariaex, "~> 0.8.0", [hex: :mariaex, repo: "hexpm", optional: true]}, {:poison, "~> 2.2 or ~> 3.0", [hex: :poison, repo: "hexpm", optional: true]}, {:poolboy, "~> 1.5", [hex: :poolboy, repo: "hexpm", optional: false]}, {:postgrex, "~> 0.13.0", [hex: :postgrex, repo: "hexpm", optional: true]}, {:sbroker, "~> 1.0", [hex: :sbroker, repo: "hexpm", optional: true]}], "hexpm"},
-  "poolboy": {:hex, :poolboy, "1.5.1", "6b46163901cfd0a1b43d692657ed9d7e599853b3b21b95ae5ae0a777cf9b6ca8", [:rebar], [], "hexpm"},
-  "postgrex": {:hex, :postgrex, "0.13.5", "3d931aba29363e1443da167a4b12f06dcd171103c424de15e5f3fc2ba3e6d9c5", [:mix], [{:connection, "~> 1.0", [hex: :connection, repo: "hexpm", optional: false]}, {:db_connection, "~> 1.1", [hex: :db_connection, repo: "hexpm", optional: false]}, {:decimal, "~> 1.0", [hex: :decimal, repo: "hexpm", optional: false]}], "hexpm"},
+  "ecto": {:hex, :ecto, "3.0.7", "44dda84ac6b17bbbdeb8ac5dfef08b7da253b37a453c34ab1a98de7f7e5fec7f", [:mix], [{:decimal, "~> 1.6", [hex: :decimal, repo: "hexpm", optional: false]}, {:jason, "~> 1.0", [hex: :jason, repo: "hexpm", optional: true]}, {:poison, "~> 2.2 or ~> 3.0", [hex: :poison, repo: "hexpm", optional: true]}], "hexpm"},
+  "ecto_sql": {:hex, :ecto_sql, "3.0.5", "7e44172b4f7aca4469f38d7f6a3da394dbf43a1bcf0ca975e958cb957becd74e", [:mix], [{:db_connection, "~> 2.0", [hex: :db_connection, repo: "hexpm", optional: false]}, {:ecto, "~> 3.0.6", [hex: :ecto, repo: "hexpm", optional: false]}, {:mariaex, "~> 0.9.1", [hex: :mariaex, repo: "hexpm", optional: true]}, {:postgrex, "~> 0.14.0", [hex: :postgrex, repo: "hexpm", optional: true]}, {:telemetry, "~> 0.3.0", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm"},
+  "postgrex": {:hex, :postgrex, "0.14.1", "63247d4a5ad6b9de57a0bac5d807e1c32d41e39c04b8a4156a26c63bcd8a2e49", [:mix], [{:connection, "~> 1.0", [hex: :connection, repo: "hexpm", optional: false]}, {:db_connection, "~> 2.0", [hex: :db_connection, repo: "hexpm", optional: false]}, {:decimal, "~> 1.5", [hex: :decimal, repo: "hexpm", optional: false]}, {:jason, "~> 1.0", [hex: :jason, repo: "hexpm", optional: true]}], "hexpm"},
+  "telemetry": {:hex, :telemetry, "0.3.0", "099a7f3ce31e4780f971b4630a3c22ec66d22208bc090fe33a2a3a6a67754a73", [:rebar3], [], "hexpm"},
 }

From 33f3102b8ca5dd828da51c929acd4d344f78c274 Mon Sep 17 00:00:00 2001
From: Danielwhyte <danwhy@gmail.com>
Date: Fri, 15 Feb 2019 09:14:49 +0000
Subject: [PATCH 02/35] updates test app and repo for adapter, #38

---
 config/test.exs             |  1 -
 test/support/application.ex | 12 ++----------
 test/support/repo.ex        | 12 +++---------
 3 files changed, 5 insertions(+), 20 deletions(-)

diff --git a/config/test.exs b/config/test.exs
index 16720f2..cead70a 100644
--- a/config/test.exs
+++ b/config/test.exs
@@ -1,7 +1,6 @@
 use Mix.Config
 
 config :alog, Alog.Repo,
-  adapter: Ecto.Adapters.Postgres,
   username: "postgres",
   password: "postgres",
   database: "test_app_dev",
diff --git a/test/support/application.ex b/test/support/application.ex
index 5af3f64..91becea 100644
--- a/test/support/application.ex
+++ b/test/support/application.ex
@@ -5,16 +5,8 @@ defmodule Alog.TestApp.Application do
   def start(_type, _args) do
     import Supervisor.Spec
 
-    children =
-      case Code.ensure_compiled(Alog.TestApp) do
-        {:error, _} ->
-          []
-
-        {:module, Alog.TestApp} ->
-          [supervisor(Alog.Repo, [])]
-      end
-
     opts = [strategy: :one_for_one, name: Alog.TestApp.Supervisor]
-    Supervisor.start_link(children, opts)
+
+    Supervisor.start_link([Alog.Repo], opts)
   end
 end
diff --git a/test/support/repo.ex b/test/support/repo.ex
index 41237c3..179466a 100644
--- a/test/support/repo.ex
+++ b/test/support/repo.ex
@@ -1,11 +1,5 @@
 defmodule Alog.Repo do
-  use Ecto.Repo, otp_app: :alog
-
-  @doc """
-  Dynamically loads the repository url from the
-  DATABASE_URL environment variable.
-  """
-  def init(_, opts) do
-    {:ok, Keyword.put(opts, :url, System.get_env("DATABASE_URL"))}
-  end
+  use Ecto.Repo,
+    otp_app: :alog,
+    adapter: Alog
 end

From 403bb1ac3e63238267eca6aeb28194661eec034a Mon Sep 17 00:00:00 2001
From: Danielwhyte <danwhy@gmail.com>
Date: Mon, 18 Feb 2019 11:45:21 +0000
Subject: [PATCH 03/35] adds create execute_ddl function clause, #44

---
 lib/alog/connection.ex | 42 ++++++++++++++++++++++++++++++++++++++----
 1 file changed, 38 insertions(+), 4 deletions(-)

diff --git a/lib/alog/connection.ex b/lib/alog/connection.ex
index 775cbd2..03aa313 100644
--- a/lib/alog/connection.ex
+++ b/lib/alog/connection.ex
@@ -2,15 +2,49 @@ defmodule Alog.Connection do
   @behaviour Ecto.Adapters.SQL.Connection
 
   @impl true
-  defdelegate ddl_logs(result), to: Ecto.Adapter.Postgres
+  defdelegate child_spec(opts), to: Ecto.Adapters.Postgres.Connection
+
+  @impl true
+  defdelegate ddl_logs(result), to: Ecto.Adapter.Postgres.Connection
 
   @impl true
   defdelegate prepare_execute(connection, name, statement, params, options),
-    to: Ecto.Adapter.Postgres
+    to: Ecto.Adapter.Postgres.Connection
 
   @impl true
-  defdelegate query(connection, statement, params, options), to: Ecto.Adapter.Postgres
+  defdelegate query(connection, statement, params, options), to: Ecto.Adapter.Postgres.Connection
 
   @impl true
-  defdelegate stream(connection, statement, params, options), to: Ecto.Adapter.Postgres
+  defdelegate stream(connection, statement, params, options), to: Ecto.Adapter.Postgres.Connection
+
+  @impl true
+  def execute_ddl({c, %Ecto.Migration.Table{} = table, columns} = command)
+      when c in [:create, :create_if_not_exists] do
+    case Enum.any?(
+           columns,
+           fn
+             {:add, field, type, [primary_key: true]} -> true
+             _ -> false
+           end
+         ) do
+      true ->
+        raise ArgumentError, "you cannot add a primary key"
+
+      false ->
+        Ecto.Adapter.Postgres.Connection.execute_ddl(
+          {c, table, subcommand ++ [{:add, :cid, "varchar", [primary_key: true]}]}
+        )
+    end
+  end
+
+  def execute_ddl({:alter, %Ecto.Migration.Table{}, changes} = command) do
+  end
+
+  def execute_ddl({:create, %Ecto.Migration.Index{}} = command) do
+  end
+
+  def execute_ddl({:create_if_not_exists, %Ecto.Migration.Index{}} = command) do
+  end
+
+  defdelegate execute_ddl(command), to: Ecto.Adapter.Postgres.Connection
 end

From 8be05cb2492c8c376305c4690d23515d75f02b91 Mon Sep 17 00:00:00 2001
From: Danielwhyte <danwhy@gmail.com>
Date: Mon, 18 Feb 2019 12:19:23 +0000
Subject: [PATCH 04/35] adds execute_ddl alter function clause, #44

---
 lib/alog/connection.ex | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)

diff --git a/lib/alog/connection.ex b/lib/alog/connection.ex
index 03aa313..9f848fb 100644
--- a/lib/alog/connection.ex
+++ b/lib/alog/connection.ex
@@ -38,6 +38,22 @@ defmodule Alog.Connection do
   end
 
   def execute_ddl({:alter, %Ecto.Migration.Table{}, changes} = command) do
+    with :ok <-
+           Enum.each(
+             changes,
+             fn
+               {:remove, :cid, _, _} ->
+                 raise ArgumentError, "you cannot remove cid"
+
+               {_, _, _, [primary_key: true]} ->
+                 raise ArgumentError, "you cannot add a primary key"
+
+               _ ->
+                 nil
+             end
+           ) do
+      Ecto.Adapter.Postgres.Connection.execute_ddl(command)
+    end
   end
 
   def execute_ddl({:create, %Ecto.Migration.Index{}} = command) do

From ae010d8a7ffb52c7251796585e8abb1f02f902f1 Mon Sep 17 00:00:00 2001
From: Danielwhyte <danwhy@gmail.com>
Date: Mon, 18 Feb 2019 12:24:58 +0000
Subject: [PATCH 05/35] adds execute_ddl create index function clause, #44

---
 lib/alog/connection.ex | 7 +++----
 1 file changed, 3 insertions(+), 4 deletions(-)

diff --git a/lib/alog/connection.ex b/lib/alog/connection.ex
index 9f848fb..c2a8216 100644
--- a/lib/alog/connection.ex
+++ b/lib/alog/connection.ex
@@ -56,10 +56,9 @@ defmodule Alog.Connection do
     end
   end
 
-  def execute_ddl({:create, %Ecto.Migration.Index{}} = command) do
-  end
-
-  def execute_ddl({:create_if_not_exists, %Ecto.Migration.Index{}} = command) do
+  def execute_ddl({c, %Ecto.Migration.Index{unique: true}})
+      when c in [:create, :create_if_not_exists] do
+    raise ArgumentError, "you cannot create a unique index"
   end
 
   defdelegate execute_ddl(command), to: Ecto.Adapter.Postgres.Connection

From 54187b84df788978530e05bc4b3430f874adafc0 Mon Sep 17 00:00:00 2001
From: Danielwhyte <danwhy@gmail.com>
Date: Mon, 18 Feb 2019 14:35:18 +0000
Subject: [PATCH 06/35] accounts for schema_migration table in create clause,
 #44

---
 lib/alog/connection.ex | 43 ++++++++++++++++++++++++------------------
 1 file changed, 25 insertions(+), 18 deletions(-)

diff --git a/lib/alog/connection.ex b/lib/alog/connection.ex
index c2a8216..10ef205 100644
--- a/lib/alog/connection.ex
+++ b/lib/alog/connection.ex
@@ -5,34 +5,41 @@ defmodule Alog.Connection do
   defdelegate child_spec(opts), to: Ecto.Adapters.Postgres.Connection
 
   @impl true
-  defdelegate ddl_logs(result), to: Ecto.Adapter.Postgres.Connection
+  defdelegate ddl_logs(result), to: Ecto.Adapters.Postgres.Connection
 
   @impl true
   defdelegate prepare_execute(connection, name, statement, params, options),
-    to: Ecto.Adapter.Postgres.Connection
+    to: Ecto.Adapters.Postgres.Connection
 
   @impl true
-  defdelegate query(connection, statement, params, options), to: Ecto.Adapter.Postgres.Connection
+  defdelegate query(connection, statement, params, options), to: Ecto.Adapters.Postgres.Connection
 
   @impl true
-  defdelegate stream(connection, statement, params, options), to: Ecto.Adapter.Postgres.Connection
+  defdelegate stream(connection, statement, params, options),
+    to: Ecto.Adapters.Postgres.Connection
 
   @impl true
   def execute_ddl({c, %Ecto.Migration.Table{} = table, columns} = command)
       when c in [:create, :create_if_not_exists] do
-    case Enum.any?(
-           columns,
-           fn
-             {:add, field, type, [primary_key: true]} -> true
-             _ -> false
-           end
-         ) do
-      true ->
-        raise ArgumentError, "you cannot add a primary key"
+    # TODO: need to determine if migration_source has been set in config
+    # else name is :schema_migrations
+    with name when name != :schema_migrations <- Map.get(table, :name),
+         true <-
+           Enum.any?(
+             columns,
+             fn
+               {:add, field, type, [primary_key: true]} -> true
+               _ -> false
+             end
+           ) do
+      raise ArgumentError, "you cannot add a primary key"
+    else
+      :schema_migrations ->
+        Ecto.Adapters.Postgres.Connection.execute_ddl({c, table, columns})
 
-      false ->
-        Ecto.Adapter.Postgres.Connection.execute_ddl(
-          {c, table, subcommand ++ [{:add, :cid, "varchar", [primary_key: true]}]}
+      _ ->
+        Ecto.Adapters.Postgres.Connection.execute_ddl(
+          {c, table, columns ++ [{:add, :cid, :varchar, [primary_key: true]}]}
         )
     end
   end
@@ -52,7 +59,7 @@ defmodule Alog.Connection do
                  nil
              end
            ) do
-      Ecto.Adapter.Postgres.Connection.execute_ddl(command)
+      Ecto.Adapters.Postgres.Connection.execute_ddl(command)
     end
   end
 
@@ -61,5 +68,5 @@ defmodule Alog.Connection do
     raise ArgumentError, "you cannot create a unique index"
   end
 
-  defdelegate execute_ddl(command), to: Ecto.Adapter.Postgres.Connection
+  defdelegate execute_ddl(command), to: Ecto.Adapters.Postgres.Connection
 end

From c0dadca2c8eb80dfc0af48fdd3cb3f98bd8c72b1 Mon Sep 17 00:00:00 2001
From: Danielwhyte <danwhy@gmail.com>
Date: Tue, 19 Feb 2019 15:24:09 +0000
Subject: [PATCH 07/35] adds all required colmns, only if they are missing, #44

---
 lib/alog/connection.ex | 21 ++++++++++++++++++---
 1 file changed, 18 insertions(+), 3 deletions(-)

diff --git a/lib/alog/connection.ex b/lib/alog/connection.ex
index 10ef205..ded3d88 100644
--- a/lib/alog/connection.ex
+++ b/lib/alog/connection.ex
@@ -38,9 +38,7 @@ defmodule Alog.Connection do
         Ecto.Adapters.Postgres.Connection.execute_ddl({c, table, columns})
 
       _ ->
-        Ecto.Adapters.Postgres.Connection.execute_ddl(
-          {c, table, columns ++ [{:add, :cid, :varchar, [primary_key: true]}]}
-        )
+        Ecto.Adapters.Postgres.Connection.execute_ddl({c, table, update_columns(columns)})
     end
   end
 
@@ -69,4 +67,21 @@ defmodule Alog.Connection do
   end
 
   defdelegate execute_ddl(command), to: Ecto.Adapters.Postgres.Connection
+
+  # Add required columns if they are missing
+  defp update_columns(columns) do
+    [
+      {:add, :cid, :string, [primary_key: true]},
+      {:add, :entry_id, :string, []},
+      {:add, :deleted, :boolean, []},
+      {:add, :inserted_at, :naive_datetime_usec, []},
+      {:add, :updated_at, :naive_datetime_usec, []}
+    ]
+    |> Enum.reduce(columns, fn {_, c, _, _} = col, acc ->
+      case Enum.find(acc, fn {_, a, _, _} -> a == c end) do
+        nil -> acc ++ [col]
+        _ -> acc
+      end
+    end)
+  end
 end

From 85aa257a6d9d52104cd5587812ba9e6f9c3b372b Mon Sep 17 00:00:00 2001
From: Danielwhyte <danwhy@gmail.com>
Date: Wed, 20 Feb 2019 11:11:45 +0000
Subject: [PATCH 08/35] adds tests for migrations, #44

---
 lib/alog/connection.ex  |  22 ++++-
 test/migration_test.exs | 179 ++++++++++++++++++++++++++++++++++++++++
 2 files changed, 197 insertions(+), 4 deletions(-)
 create mode 100644 test/migration_test.exs

diff --git a/lib/alog/connection.ex b/lib/alog/connection.ex
index ded3d88..d02c5b9 100644
--- a/lib/alog/connection.ex
+++ b/lib/alog/connection.ex
@@ -72,10 +72,10 @@ defmodule Alog.Connection do
   defp update_columns(columns) do
     [
       {:add, :cid, :string, [primary_key: true]},
-      {:add, :entry_id, :string, []},
-      {:add, :deleted, :boolean, []},
-      {:add, :inserted_at, :naive_datetime_usec, []},
-      {:add, :updated_at, :naive_datetime_usec, []}
+      {:add, :entry_id, :string, [null: false]},
+      {:add, :deleted, :boolean, [default: false]},
+      {:add, :inserted_at, :naive_datetime_usec, [null: false]},
+      {:add, :updated_at, :naive_datetime_usec, [null: false]}
     ]
     |> Enum.reduce(columns, fn {_, c, _, _} = col, acc ->
       case Enum.find(acc, fn {_, a, _, _} -> a == c end) do
@@ -84,4 +84,18 @@ defmodule Alog.Connection do
       end
     end)
   end
+
+  # Temporary delegate functions to make tests work
+
+  @impl true
+  defdelegate all(a), to: Ecto.Adapters.Postgres.Connection
+
+  @impl true
+  defdelegate insert(a, b, c, d, e, f), to: Ecto.Adapters.Postgres.Connection
+
+  @impl true
+  defdelegate execute(a, b, c, d), to: Ecto.Adapters.Postgres.Connection
+
+  @impl true
+  defdelegate delete_all(a), to: Ecto.Adapters.Postgres.Connection
 end
diff --git a/test/migration_test.exs b/test/migration_test.exs
new file mode 100644
index 0000000..71e9962
--- /dev/null
+++ b/test/migration_test.exs
@@ -0,0 +1,179 @@
+defmodule AlogTest.MigrationTest do
+  use ExUnit.Case, async: true
+
+  alias Alog.Repo
+
+  # Avoid migration out of order warnings
+  @moduletag :capture_log
+  @base_migration 3_000_000
+
+  setup do
+    {:ok, migration_number: System.unique_integer([:positive]) + @base_migration}
+  end
+
+  defmodule AddColumnIfNotExistsMigration do
+    use Ecto.Migration
+
+    def up do
+      create(table(:add_col_if_not_exists_migration, primary_key: false))
+
+      alter table(:add_col_if_not_exists_migration) do
+        add_if_not_exists(:value, :integer)
+        add_if_not_exists(:to_be_added, :integer)
+      end
+
+      execute(
+        "INSERT INTO add_col_if_not_exists_migration (value, to_be_added, cid, entry_id, inserted_at, updated_at) VALUES (1, 2, 'a', 'a', '2019-02-10 10:04:30', '2019-02-10 10:04:30')"
+      )
+    end
+
+    def down do
+      drop(table(:add_col_if_not_exists_migration))
+    end
+  end
+
+  defmodule DropColumnIfExistsMigration do
+    use Ecto.Migration
+
+    def up do
+      create table(:drop_col_if_exists_migration, primary_key: false) do
+        add(:value, :integer)
+        add(:to_be_removed, :integer)
+      end
+
+      execute(
+        "INSERT INTO drop_col_if_exists_migration (value, to_be_removed, cid, entry_id, inserted_at, updated_at) VALUES (1, 2, 'a', 'a', '2019-02-10 10:04:30', '2019-02-10 10:04:30')"
+      )
+
+      alter table(:drop_col_if_exists_migration) do
+        remove_if_exists(:to_be_removed, :integer)
+      end
+    end
+
+    def down do
+      drop(table(:drop_col_if_exists_migration))
+    end
+  end
+
+  defmodule DuplicateTableMigration do
+    use Ecto.Migration
+
+    def change do
+      create_if_not_exists(table(:duplicate_table, primary_key: false))
+      create_if_not_exists(table(:duplicate_table, primary_key: false))
+    end
+  end
+
+  defmodule NoErrorOnConditionalColumnMigration do
+    use Ecto.Migration
+
+    def up do
+      create(table(:no_error_on_conditional_column_migration, primary_key: false))
+
+      alter table(:no_error_on_conditional_column_migration) do
+        add_if_not_exists(:value, :integer)
+        add_if_not_exists(:value, :integer)
+
+        remove_if_exists(:value, :integer)
+        remove_if_exists(:value, :integer)
+      end
+    end
+
+    def down do
+      drop(table(:no_error_on_conditional_column_migration))
+    end
+  end
+
+  defmodule DefaultMigration do
+    use Ecto.Migration
+
+    def up do
+      create table(:default_migration, primary_key: false) do
+        add(:name, :string)
+      end
+
+      execute(
+        "INSERT INTO default_migration (name, cid, entry_id, inserted_at, updated_at) VALUES ('a', 'b', 'a', '2019-02-10 10:04:30', '2019-02-10 10:04:30')"
+      )
+    end
+
+    def down do
+      drop(table(:default_migration))
+    end
+  end
+
+  defmodule ExistingDefaultMigration do
+    use Ecto.Migration
+
+    def change do
+      create table(:existing_default_migration, primary_key: false) do
+        timestamps()
+      end
+    end
+  end
+
+  import Ecto.Query, only: [from: 2]
+  import Ecto.Migrator, only: [up: 4, down: 4]
+
+  test "logs Postgres notice messages" do
+    log =
+      ExUnit.CaptureLog.capture_log(fn ->
+        num = @base_migration + System.unique_integer([:positive])
+        up(Repo, num, DuplicateTableMigration, log: false)
+      end)
+
+    assert log =~ ~s(relation "duplicate_table" already exists, skipping)
+  end
+
+  @tag :no_error_on_conditional_column_migration
+  test "add if not exists and drop if exists does not raise on failure", %{migration_number: num} do
+    assert :ok == up(Repo, num, NoErrorOnConditionalColumnMigration, log: false)
+    assert :ok == down(Repo, num, NoErrorOnConditionalColumnMigration, log: false)
+  end
+
+  @tag :add_column_if_not_exists
+  test "add column if not exists", %{migration_number: num} do
+    assert :ok == up(Repo, num, AddColumnIfNotExistsMigration, log: false)
+
+    assert [2] == Repo.all(from(p in "add_col_if_not_exists_migration", select: p.to_be_added))
+
+    :ok = down(Repo, num, AddColumnIfNotExistsMigration, log: false)
+  end
+
+  @tag :remove_column_if_exists
+  test "remove column when exists", %{migration_number: num} do
+    assert :ok == up(Repo, num, DropColumnIfExistsMigration, log: false)
+
+    assert catch_error(
+             Repo.all(from(p in "drop_col_if_exists_migration", select: p.to_be_removed))
+           )
+
+    :ok = down(Repo, num, DropColumnIfExistsMigration, log: false)
+  end
+
+  test "creates default columns", %{migration_number: num} do
+    assert :ok == up(Repo, num, DefaultMigration, log: false)
+
+    assert [%{name: _, cid: _, entry_id: _, inserted_at: _, updated_at: _, deleted: false}] =
+             Repo.all(
+               from(a in "default_migration",
+                 select: %{
+                   name: a.name,
+                   cid: a.cid,
+                   entry_id: a.entry_id,
+                   inserted_at: a.inserted_at,
+                   updated_at: a.updated_at,
+                   deleted: a.deleted
+                 }
+               )
+             )
+
+    :ok = down(Repo, num, DefaultMigration, log: false)
+  end
+
+  test "existing default columns don't throw errors", %{migration_number: num} do
+    assert :ok == up(Repo, num, ExistingDefaultMigration, log: false)
+
+    :ok = down(Repo, num, ExistingDefaultMigration, log: false)
+  end
+end

From 94808f3794047cb851b74078186e003fe148b056 Mon Sep 17 00:00:00 2001
From: Robert Francis <robertefrancis18@gmail.com>
Date: Thu, 28 Feb 2019 13:13:28 +0000
Subject: [PATCH 09/35] adds remaining defdelgate to required functions #45

---
 lib/alog.ex            | 20 ++++++++++++------
 lib/alog/connection.ex | 46 +++++++++++++++++++++++++++++++++++++-----
 2 files changed, 55 insertions(+), 11 deletions(-)

diff --git a/lib/alog.ex b/lib/alog.ex
index e0fde26..0b15510 100644
--- a/lib/alog.ex
+++ b/lib/alog.ex
@@ -3,16 +3,24 @@ defmodule Alog do
     driver: :postgrex,
     migration_lock: "FOR UPDATE"
 
-  @impl true
-  def supports_ddl_transaction? do
-    true
-  end
+  alias Ecto.Adapters.Postgres, as: EAP
 
   @behaviour Ecto.Adapter.Storage
 
+  # Why did we define our own version of this function?
+  # Sorry if I have missed something that has been explained already.
+  @impl true
+  def supports_ddl_transaction?, do: true
+
+  @impl true
+  defdelegate storage_up(opts), to: EAP
+
+  @impl true
+  defdelegate storage_down(opts), to: EAP
+
   @impl true
-  defdelegate storage_up(opts), to: Ecto.Adapters.Postgres
+  defdelegate structure_dump(default, config), to: EAP
 
   @impl true
-  defdelegate storage_down(opts), to: Ecto.Adapters.Postgres
+  defdelegate structure_load(default, config), to: EAP
 end
diff --git a/lib/alog/connection.ex b/lib/alog/connection.ex
index 775cbd2..9cbc0fe 100644
--- a/lib/alog/connection.ex
+++ b/lib/alog/connection.ex
@@ -1,16 +1,52 @@
 defmodule Alog.Connection do
+  alias Ecto.Adapters.Postgres.Connection, as: EAPC
+
   @behaviour Ecto.Adapters.SQL.Connection
+  @default_port 5432
+
+  @impl true
+  def child_spec(opts) do
+    opts
+    |> Keyword.put_new(:port, @default_port)
+    |> Postgrex.child_spec()
+  end
+
+  @impl true
+  defdelegate ddl_logs(result), to: EAPC
+
+  @impl true
+  defdelegate prepare_execute(conn, name, statement, params, opts), to: EAPC
+
+  @impl true
+  defdelegate query(conn, statement, params, opts), to: EAPC
+
+  @impl true
+  defdelegate stream(conn, statement, params, opts), to: EAPC
+
+  @impl true
+  defdelegate to_constraints(error_struct), to: EAPC
+
+  @impl true
+  defdelegate execute(conn, query, params, opts), to: EAPC
+
+  @impl true
+  defdelegate all(query), to: EAPC
+
+  @impl true
+  defdelegate update_all(query, prefix \\ nil), to: EAPC
+
+  @impl true
+  defdelegate delete_all(query), to: EAPC
 
   @impl true
-  defdelegate ddl_logs(result), to: Ecto.Adapter.Postgres
+  defdelegate insert(prefix, table, header, rows, on_conflict, returning), to: EAPC
 
   @impl true
-  defdelegate prepare_execute(connection, name, statement, params, options),
-    to: Ecto.Adapter.Postgres
+  defdelegate update(prefix, table, fields, filters, returning), to: EAPC
 
   @impl true
-  defdelegate query(connection, statement, params, options), to: Ecto.Adapter.Postgres
+  defdelegate delete(prefix, table, filters, returning), to: EAPC
 
   @impl true
-  defdelegate stream(connection, statement, params, options), to: Ecto.Adapter.Postgres
+  defdelegate execute_ddl(arg), to: EAPC
 end

From e1f11ff59f1d785e5c78430f5df691db48db56a7 Mon Sep 17 00:00:00 2001
From: Robert Francis <robertefrancis18@gmail.com>
Date: Thu, 28 Feb 2019 13:16:08 +0000
Subject: [PATCH 10/35] reorder function definitions to match behavior's order
 #45

---
 lib/alog/connection.ex | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/lib/alog/connection.ex b/lib/alog/connection.ex
index 9cbc0fe..496faa0 100644
--- a/lib/alog/connection.ex
+++ b/lib/alog/connection.ex
@@ -12,10 +12,10 @@ defmodule Alog.Connection do
   end
 
   @impl true
-  defdelegate ddl_logs(result), to: EAPC
+  defdelegate prepare_execute(conn, name, statement, params, opts), to: EAPC
 
   @impl true
-  defdelegate prepare_execute(conn, name, statement, params, opts), to: EAPC
+  defdelegate execute(conn, query, params, opts), to: EAPC
 
   @impl true
   defdelegate query(conn, statement, params, opts), to: EAPC
@@ -26,9 +26,6 @@ defmodule Alog.Connection do
   @impl true
   defdelegate to_constraints(error_struct), to: EAPC
 
-  @impl true
-  defdelegate execute(conn, query, params, opts), to: EAPC
-
   @impl true
   defdelegate all(query), to: EAPC
 
@@ -49,4 +46,7 @@ defmodule Alog.Connection do
 
   @impl true
   defdelegate execute_ddl(arg), to: EAPC
+
+  @impl true
+  defdelegate ddl_logs(result), to: EAPC
 end

From 7735134ce45ab9571e0b7e4cc302d79b68c7f0eb Mon Sep 17 00:00:00 2001
From: Danielwhyte <danwhy@gmail.com>
Date: Thu, 28 Feb 2019 13:32:14 +0000
Subject: [PATCH 11/35] adds update functionality, #46

---
 lib/alog.ex            | 45 ++++++++++++++++++++++++++++++++++++++++++
 lib/alog/connection.ex |  8 +++++++-
 test/update_test.exs   | 35 +++++++++-----------------------
 3 files changed, 61 insertions(+), 27 deletions(-)

diff --git a/lib/alog.ex b/lib/alog.ex
index e0fde26..c0b7ad7 100644
--- a/lib/alog.ex
+++ b/lib/alog.ex
@@ -9,10 +9,55 @@ defmodule Alog do
   end
 
   @behaviour Ecto.Adapter.Storage
+  @behaviour Ecto.Adapter.Schema
 
   @impl true
   defdelegate storage_up(opts), to: Ecto.Adapters.Postgres
 
   @impl true
   defdelegate storage_down(opts), to: Ecto.Adapters.Postgres
+
+  @impl true
+  def update(adapter_meta, %{source: source, prefix: prefix}, fields, params, returning, opts) do
+    cid = Keyword.get(params, :cid)
+    query = "SELECT * FROM #{source} where cid='#{cid}'"
+    {:ok, old} = Ecto.Adapters.SQL.query(adapter_meta, query, [])
+
+    new_params =
+      Enum.with_index(old.columns)
+      |> Enum.map(fn {c, i} ->
+        case Keyword.get(fields, String.to_existing_atom(c)) do
+          _ when c == "cid" ->
+            nil
+
+          nil ->
+            {String.to_existing_atom(c), old.rows |> List.first() |> Enum.at(i)}
+
+          new ->
+            {String.to_existing_atom(c), new}
+        end
+      end)
+      |> Enum.filter(&(not is_nil(&1)))
+      |> Keyword.new()
+
+    insert(
+      adapter_meta,
+      %{source: source, prefix: prefix},
+      new_params,
+      {:raise, [], []},
+      returning,
+      opts
+    )
+  end
+
+  @impl true
+  def autogenerate(:binary_id), do: nil
+
+  @impl true
+  def loaders(:binary_id, type), do: [:binary, type]
+  def loaders(_primitive, type), do: [type]
+
+  @impl true
+  def dumpers(:binary_id, type), do: [:binary, type]
+  def dumpers(_primitive, type), do: [type]
 end
diff --git a/lib/alog/connection.ex b/lib/alog/connection.ex
index d02c5b9..c983d47 100644
--- a/lib/alog/connection.ex
+++ b/lib/alog/connection.ex
@@ -71,7 +71,7 @@ defmodule Alog.Connection do
   # Add required columns if they are missing
   defp update_columns(columns) do
     [
-      {:add, :cid, :string, [primary_key: true]},
+      {:add, :cid, :binary, [primary_key: true]},
       {:add, :entry_id, :string, [null: false]},
       {:add, :deleted, :boolean, [default: false]},
       {:add, :inserted_at, :naive_datetime_usec, [null: false]},
@@ -98,4 +98,10 @@ defmodule Alog.Connection do
 
   @impl true
   defdelegate delete_all(a), to: Ecto.Adapters.Postgres.Connection
+
+  @impl true
+  defdelegate to_constraints(a), to: Ecto.Adapters.Postgres.Connection
+
+  @impl true
+  defdelegate update(a, b, c, d, e), to: Ecto.Adapters.Postgres.Connection
 end
diff --git a/test/update_test.exs b/test/update_test.exs
index 076f639..838368b 100644
--- a/test/update_test.exs
+++ b/test/update_test.exs
@@ -3,36 +3,19 @@ defmodule AlogTest.UpdateTest do
 
   alias Alog.TestApp.{User, Helpers}
 
-  describe "update/2:" do
-    test "succeeds" do
-      {:ok, user} = %User{} |> User.changeset(Helpers.user_1_params()) |> User.insert()
+  test "adds new record" do
+    {:ok, u} = Repo.insert(%User{name: "hi", username: "hi", postcode: "hi"})
 
-      assert {:ok, updated_user} = user |> User.changeset(%{postcode: "W2 3EC"}) |> User.update()
-    end
+    {:ok, _} = Repo.update(User.changeset(u, %{name: "hello"}))
 
-    test "updates" do
-      {:ok, user} = %User{} |> User.changeset(Helpers.user_1_params()) |> User.insert()
-
-      {:ok, updated_user} = user |> User.changeset(%{postcode: "W2 3EC"}) |> User.update()
-
-      assert updated_user.postcode == "W2 3EC"
-    end
-
-    test "'get' returns most recently updated item" do
-      {:ok, user} = %User{} |> User.changeset(Helpers.user_1_params()) |> User.insert()
-
-      {:ok, updated_user} = user |> User.changeset(%{postcode: "W2 3EC"}) |> User.update()
-
-      assert User.get(user.entry_id) |> User.preload(:items) == updated_user
-      assert User.get(user.entry_id).postcode == "W2 3EC"
-    end
+    assert Repo.all(User) |> length == 2
+  end
 
-    test "associations remain after update" do
-      {:ok, user, _item} = Helpers.seed_data()
+  test "return value of update is correct" do
+    {:ok, user} = Repo.insert(%User{name: "hi", username: "hi", postcode: "hi"})
 
-      {:ok, _updated_user} = user |> User.changeset(%{postcode: "W2 3EC"}) |> User.update()
+    {:ok, updated_user} = Repo.update(User.changeset(user, %{name: "hello"}))
 
-      assert User.get(user.entry_id) |> User.preload(:items) |> Map.get(:items) |> length == 1
-    end
+    assert user.cid !== updated_user.cid
   end
 end

From 87a7f9b6ee8ad1110cdcff63b9b0a3f1f06f00a1 Mon Sep 17 00:00:00 2001
From: Robert Francis <robertefrancis18@gmail.com>
Date: Thu, 28 Feb 2019 13:37:54 +0000
Subject: [PATCH 12/35] adds excid as dep #45

---
 mix.exs  | 3 ++-
 mix.lock | 4 ++++
 2 files changed, 6 insertions(+), 1 deletion(-)

diff --git a/mix.exs b/mix.exs
index f4f98da..f0d0dd9 100644
--- a/mix.exs
+++ b/mix.exs
@@ -28,7 +28,8 @@ defmodule Alog.MixProject do
   defp deps do
     [
       {:ecto_sql, "~> 3.0.5"},
-      {:postgrex, ">= 0.0.0"}
+      {:postgrex, ">= 0.0.0"},
+      {:excid, "~> 0.1.0"}
     ]
   end
 end
diff --git a/mix.lock b/mix.lock
index dc26038..5afdc29 100644
--- a/mix.lock
+++ b/mix.lock
@@ -1,9 +1,13 @@
 %{
+  "b58": {:hex, :b58, "0.1.1", "950563b90ad95be214143aa807d16c98d2ac7bab915097cb1461c936128c6b90", [:mix], [], "hexpm"},
   "connection": {:hex, :connection, "1.0.4", "a1cae72211f0eef17705aaededacac3eb30e6625b04a6117c1b2db6ace7d5976", [:mix], [], "hexpm"},
   "db_connection": {:hex, :db_connection, "2.0.5", "ddb2ba6761a08b2bb9ca0e7d260e8f4dd39067426d835c24491a321b7f92a4da", [:mix], [{:connection, "~> 1.0.2", [hex: :connection, repo: "hexpm", optional: false]}], "hexpm"},
   "decimal": {:hex, :decimal, "1.6.0", "bfd84d90ff966e1f5d4370bdd3943432d8f65f07d3bab48001aebd7030590dcc", [:mix], [], "hexpm"},
   "ecto": {:hex, :ecto, "3.0.7", "44dda84ac6b17bbbdeb8ac5dfef08b7da253b37a453c34ab1a98de7f7e5fec7f", [:mix], [{:decimal, "~> 1.6", [hex: :decimal, repo: "hexpm", optional: false]}, {:jason, "~> 1.0", [hex: :jason, repo: "hexpm", optional: true]}, {:poison, "~> 2.2 or ~> 3.0", [hex: :poison, repo: "hexpm", optional: true]}], "hexpm"},
   "ecto_sql": {:hex, :ecto_sql, "3.0.5", "7e44172b4f7aca4469f38d7f6a3da394dbf43a1bcf0ca975e958cb957becd74e", [:mix], [{:db_connection, "~> 2.0", [hex: :db_connection, repo: "hexpm", optional: false]}, {:ecto, "~> 3.0.6", [hex: :ecto, repo: "hexpm", optional: false]}, {:mariaex, "~> 0.9.1", [hex: :mariaex, repo: "hexpm", optional: true]}, {:postgrex, "~> 0.14.0", [hex: :postgrex, repo: "hexpm", optional: true]}, {:telemetry, "~> 0.3.0", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm"},
+  "ex_multihash": {:hex, :ex_multihash, "2.0.0", "7fb36f842a2ec1c6bbba550f28fcd16d3c62981781b9466c9c1975c43d7db43c", [:mix], [], "hexpm"},
+  "excid": {:hex, :excid, "0.1.0", "85fd8ac6466660bc8c4c0b52275e7a255389c683a18f70aaed8cd2ac7735cfab", [:mix], [{:b58, "~> 0.1.1", [hex: :b58, repo: "hexpm", optional: false]}, {:ex_multihash, "~> 2.0", [hex: :ex_multihash, repo: "hexpm", optional: false]}, {:jason, "~> 1.1", [hex: :jason, repo: "hexpm", optional: false]}], "hexpm"},
+  "jason": {:hex, :jason, "1.1.2", "b03dedea67a99223a2eaf9f1264ce37154564de899fd3d8b9a21b1a6fd64afe7", [:mix], [{:decimal, "~> 1.0", [hex: :decimal, repo: "hexpm", optional: true]}], "hexpm"},
   "postgrex": {:hex, :postgrex, "0.14.1", "63247d4a5ad6b9de57a0bac5d807e1c32d41e39c04b8a4156a26c63bcd8a2e49", [:mix], [{:connection, "~> 1.0", [hex: :connection, repo: "hexpm", optional: false]}, {:db_connection, "~> 2.0", [hex: :db_connection, repo: "hexpm", optional: false]}, {:decimal, "~> 1.5", [hex: :decimal, repo: "hexpm", optional: false]}, {:jason, "~> 1.0", [hex: :jason, repo: "hexpm", optional: true]}], "hexpm"},
   "telemetry": {:hex, :telemetry, "0.3.0", "099a7f3ce31e4780f971b4630a3c22ec66d22208bc090fe33a2a3a6a67754a73", [:rebar3], [], "hexpm"},
 }

From 44f96fc14dbbbbe468ddefe156c3131844e49a38 Mon Sep 17 00:00:00 2001
From: Robert Francis <robertefrancis18@gmail.com>
Date: Thu, 28 Feb 2019 13:44:06 +0000
Subject: [PATCH 13/35] creates an insert function which adds cid and entry_id
 to params #45

---
 lib/alog.ex | 53 +++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 53 insertions(+)

diff --git a/lib/alog.ex b/lib/alog.ex
index 0b15510..324f998 100644
--- a/lib/alog.ex
+++ b/lib/alog.ex
@@ -23,4 +23,57 @@ defmodule Alog do
 
   @impl true
   defdelegate structure_load(default, config), to: EAP
+
+  # overrides insert/6 defined in Ecto.Adapters.SQL
+  def insert(adapter_meta, %{source: source, prefix: prefix}, params, on_conflict, returning, opts) do
+    # converts params from a keyword list to a map
+    params_map = Enum.into(params, %{})
+
+    # removes inserted_at and updated_at from map (will not error if keys are not in map)
+    map_for_cid = Map.drop(params_map, [:inserted_at, :updated_at])
+
+    # creates a cid from the map witout the inserted_at and updated_at_values
+    cid = Cid.cid(map_for_cid)
+
+    # creates a unique entry_id for the data based on the CID generated
+    entry_id = create_entry_id(source, adapter_meta, cid, 2)
+
+    # updates params to ensure that timestamps, cid, and entry_id are all added.
+    # then converts the map back into a list for use in existing functionality (original format)
+    params =
+      map_for_cid
+      |> add_timestamps()
+      |> Map.put(:cid, cid) # <==== Should this be Map.put(:id, cid)??????????
+      |> Map.put(:entry_id, entry_id)
+      |> Enum.into([])
+
+    {kind, conflict_params, _} = on_conflict
+    {fields, values} = :lists.unzip(params)
+    sql = @conn.insert(prefix, source, fields, [fields], on_conflict, returning)
+    Ecto.Adapters.SQL.struct(adapter_meta, @conn, sql, :insert, source, [], values ++ conflict_params, kind, returning, opts)
+  end
+
+  # I think that this step need to also make sure that the data is not an exact copy.
+  # if the full cid already exists then this is duplicate data.
+  # Should we insert duplicate data.
+  # i was thinking maybe if it was existing data but not the most recent data we should re-insert the data
+  # e.g. if the comment was hi, edited to hey, and then changed back to hi.
+  defp create_entry_id(source, adapter_meta, cid, n) do
+    entry_id = String.slice(cid, 0..n)
+    entry_id_query = "SELECT * FROM #{source} where entry_id='#{entry_id}'"
+    {:ok, results} = Ecto.Adapters.SQL.query(adapter_meta, entry_id_query, [])
+
+    if results.num_rows == 0 do
+      entry_id
+    else
+      create_entry_id(source, adapter_meta, cid, n+1)
+    end
+  end
+
+  defp add_timestamps(params) do
+    params
+    |> Enum.into(%{})
+    |> Map.put_new(:inserted_at, NaiveDateTime.utc_now())
+    |> Map.put_new(:updated_at, NaiveDateTime.utc_now())
+  end
 end

From 4f9b4ea0764248f1540e80cac36320c769c1aaf0 Mon Sep 17 00:00:00 2001
From: Robert Francis <robertefrancis18@gmail.com>
Date: Fri, 1 Mar 2019 14:15:59 +0000
Subject: [PATCH 14/35] removes previous migration files #45

---
 .../20181015145631_create_users.exs           | 15 ----------
 .../20181026080544_create_items.exs           | 28 -------------------
 .../20181211161000_unique_index.exs           | 15 ----------
 3 files changed, 58 deletions(-)
 delete mode 100644 priv/repo/test_app/migrations/20181015145631_create_users.exs
 delete mode 100644 priv/repo/test_app/migrations/20181026080544_create_items.exs
 delete mode 100644 priv/repo/test_app/migrations/20181211161000_unique_index.exs

diff --git a/priv/repo/test_app/migrations/20181015145631_create_users.exs b/priv/repo/test_app/migrations/20181015145631_create_users.exs
deleted file mode 100644
index 40a7103..0000000
--- a/priv/repo/test_app/migrations/20181015145631_create_users.exs
+++ /dev/null
@@ -1,15 +0,0 @@
-defmodule Alog.Repo.Migrations.CreateUsers do
-  use Ecto.Migration
-
-  def change do
-    create table(:users) do
-      add(:name, :string)
-      add(:username, :string)
-      add(:postcode, :string)
-      add(:entry_id, :string)
-      add(:deleted, :boolean, default: false)
-
-      timestamps()
-    end
-  end
-end
diff --git a/priv/repo/test_app/migrations/20181026080544_create_items.exs b/priv/repo/test_app/migrations/20181026080544_create_items.exs
deleted file mode 100644
index 3bc37ae..0000000
--- a/priv/repo/test_app/migrations/20181026080544_create_items.exs
+++ /dev/null
@@ -1,28 +0,0 @@
-defmodule Alog.Repo.Migrations.CreateItems do
-  use Ecto.Migration
-
-  def change do
-    create table(:items) do
-      add(:name, :string)
-      add(:entry_id, :string)
-      add(:deleted, :boolean, default: false)
-      add(:owner, references(:users))
-
-      timestamps()
-    end
-
-    create table(:item_types) do
-      add(:type, :string)
-      add(:entry_id, :string)
-      add(:deleted, :boolean, default: false)
-
-      timestamps()
-    end
-
-    create table(:items_item_types, primary_key: false) do
-      add(:item_id, references(:items, on_delete: :delete_all, column: :id, type: :id))
-
-      add(:item_type_id, references(:item_types, on_delete: :delete_all, column: :id, type: :id))
-    end
-  end
-end
diff --git a/priv/repo/test_app/migrations/20181211161000_unique_index.exs b/priv/repo/test_app/migrations/20181211161000_unique_index.exs
deleted file mode 100644
index d43eb85..0000000
--- a/priv/repo/test_app/migrations/20181211161000_unique_index.exs
+++ /dev/null
@@ -1,15 +0,0 @@
-defmodule Alog.Repo.Migrations.UniqueIndex do
-  use Ecto.Migration
-
-  def change do
-    create table(:unique) do
-      add(:name, :string)
-      add(:entry_id, :string)
-      add(:deleted, :boolean, default: false)
-
-      timestamps()
-    end
-
-    create(unique_index(:unique, :name))
-  end
-end

From 3818a4e89c9760459028281d128d3752dd893b72 Mon Sep 17 00:00:00 2001
From: Robert Francis <robertefrancis18@gmail.com>
Date: Fri, 1 Mar 2019 14:16:46 +0000
Subject: [PATCH 15/35] Creates migration and schema for comments table

---
 .../20190301105228_create_comments.exs          | 13 +++++++++++++
 test/support/comment.ex                         | 17 +++++++++++++++++
 2 files changed, 30 insertions(+)
 create mode 100644 priv/repo/test_app/migrations/20190301105228_create_comments.exs
 create mode 100644 test/support/comment.ex

diff --git a/priv/repo/test_app/migrations/20190301105228_create_comments.exs b/priv/repo/test_app/migrations/20190301105228_create_comments.exs
new file mode 100644
index 0000000..e0b3ccf
--- /dev/null
+++ b/priv/repo/test_app/migrations/20190301105228_create_comments.exs
@@ -0,0 +1,13 @@
+defmodule Alog.Repo.Migrations.CreateComments do
+  use Ecto.Migration
+
+  def change do
+    create table(:comments, primary_key: false) do
+      # cid & entry_id need to be removed later as they should be handled in execute_ddl I believe
+      add(:cid, :string, primary_key: true)
+      add(:entry_id, :string)
+      add(:comment, :string)
+      add(:deleted, :boolean, default: false)
+    end
+  end
+end
diff --git a/test/support/comment.ex b/test/support/comment.ex
new file mode 100644
index 0000000..f04cc96
--- /dev/null
+++ b/test/support/comment.ex
@@ -0,0 +1,17 @@
+defmodule Alog.TestApp.Comment do
+  use Ecto.Schema
+  import Ecto.Changeset
+
+  # I'd imagine we'll change string as the type but
+  @primary_key {:cid, :string, autogenerate: false}
+  schema "users" do
+    field(:entry_id, :string)
+    field(:comment, :string)
+    field(:deleted, :boolean, default: false)
+  end
+
+  def changeset(comment_struct, attrs \\ %{}) do
+    comment_struct
+    |> cast(attrs, [:cid, :entry_id, :comment, :deleted])
+  end
+end
\ No newline at end of file

From 8a3e176e7a9895198283b0dbf4cb410ff536d80d Mon Sep 17 00:00:00 2001
From: Robert Francis <robertefrancis18@gmail.com>
Date: Fri, 1 Mar 2019 14:17:28 +0000
Subject: [PATCH 16/35] removes previous schema files #45

---
 test/support/item.ex      | 31 -------------------------------
 test/support/item_type.ex | 27 ---------------------------
 test/support/unique.ex    | 20 --------------------
 test/support/user.ex      | 32 --------------------------------
 4 files changed, 110 deletions(-)
 delete mode 100644 test/support/item.ex
 delete mode 100644 test/support/item_type.ex
 delete mode 100644 test/support/unique.ex
 delete mode 100644 test/support/user.ex

diff --git a/test/support/item.ex b/test/support/item.ex
deleted file mode 100644
index 6e2dc22..0000000
--- a/test/support/item.ex
+++ /dev/null
@@ -1,31 +0,0 @@
-defmodule Alog.TestApp.Item do
-  use Ecto.Schema
-  use Alog
-  import Ecto.Changeset
-
-  schema "items" do
-    field(:name, :string)
-    field(:entry_id, :string)
-    field(:deleted, :boolean, default: false)
-
-    belongs_to(:user, Alog.TestApp.User, foreign_key: :owner)
-
-    many_to_many(
-      :item_types,
-      Alog.TestApp.ItemType,
-      join_through: "items_item_types",
-      join_keys: [item_id: :id, item_type_id: :id]
-    )
-
-    timestamps()
-  end
-
-  @doc false
-  def changeset(item, attrs) do
-    item
-    |> cast(attrs, [:name])
-    |> validate_required([:name])
-    |> cast_assoc(:item_types)
-    |> cast_assoc(:user)
-  end
-end
diff --git a/test/support/item_type.ex b/test/support/item_type.ex
deleted file mode 100644
index 31df3ed..0000000
--- a/test/support/item_type.ex
+++ /dev/null
@@ -1,27 +0,0 @@
-defmodule Alog.TestApp.ItemType do
-  use Ecto.Schema
-  use Alog
-  import Ecto.Changeset
-
-  schema "item_types" do
-    field(:type, :string)
-    field(:entry_id, :string)
-    field(:deleted, :boolean, default: false)
-
-    many_to_many(
-      :items,
-      Alog.TestApp.Item,
-      join_through: "items_item_types",
-      join_keys: [item_type_id: :id, item_id: :id]
-    )
-
-    timestamps()
-  end
-
-  @doc false
-  def changeset(address, attrs) do
-    address
-    |> cast(attrs, [:type])
-    |> validate_required([:type])
-  end
-end
diff --git a/test/support/unique.ex b/test/support/unique.ex
deleted file mode 100644
index 197bd23..0000000
--- a/test/support/unique.ex
+++ /dev/null
@@ -1,20 +0,0 @@
-defmodule Alog.TestApp.Unique do
-  use Ecto.Schema
-  use Alog
-  import Ecto.Changeset
-
-  schema "unique" do
-    field(:name, :string)
-    field(:entry_id, :string)
-    field(:deleted, :boolean, default: false)
-
-    timestamps()
-  end
-
-  @doc false
-  def changeset(unique, attrs) do
-    unique
-    |> cast(attrs, [:name])
-    |> validate_required([:name])
-  end
-end
diff --git a/test/support/user.ex b/test/support/user.ex
deleted file mode 100644
index dfc77fe..0000000
--- a/test/support/user.ex
+++ /dev/null
@@ -1,32 +0,0 @@
-defmodule Alog.TestApp.User do
-  use Ecto.Schema
-  use Alog
-  import Ecto.Changeset
-
-  schema "users" do
-    field(:name, :string)
-    field(:username, :string)
-    field(:postcode, :string)
-    field(:entry_id, :string)
-    field(:deleted, :boolean, default: false)
-
-    has_many(:items, Alog.TestApp.Item, foreign_key: :owner)
-
-    timestamps()
-  end
-
-  @doc false
-  def changeset(user, attrs) do
-    user
-    |> cast(attrs, [:name, :username, :postcode, :deleted])
-    |> validate_required([:name, :username, :postcode])
-    |> unique_constraint(:username)
-  end
-
-  def user_and_item_changeset(user, attrs) do
-    user
-    |> cast(attrs, [:name, :username, :postcode, :deleted])
-    |> validate_required([:name, :username, :postcode])
-    |> cast_assoc(:items)
-  end
-end

From f906baff42f7184bec1053d445f426f92f11a04b Mon Sep 17 00:00:00 2001
From: Robert Francis <robertefrancis18@gmail.com>
Date: Fri, 1 Mar 2019 14:18:45 +0000
Subject: [PATCH 17/35] comment out all previous tests #45

did not delete for now as I thought we could use as a base
---
 test/all_test.exs           |  54 ++++-----
 test/alog_test.exs          | 144 +++++++++++-----------
 test/constraint_test.exs    |  62 +++++-----
 test/delete_test.exs        |  90 +++++++-------
 test/get_by_test.exs        | 128 ++++++++++----------
 test/get_history_test.exs   |  24 ++--
 test/insert_test.exs        | 230 ++++++++++++++++++------------------
 test/preload_test.exs       | 110 ++++++++---------
 test/support/application.ex |   2 -
 test/support/helpers.ex     |  92 +++++++--------
 test/update_test.exs        |  72 +++++------
 11 files changed, 503 insertions(+), 505 deletions(-)

diff --git a/test/all_test.exs b/test/all_test.exs
index 64b834a..1184943 100644
--- a/test/all_test.exs
+++ b/test/all_test.exs
@@ -1,31 +1,31 @@
 defmodule AlogTest.AllTest do
   use Alog.TestApp.DataCase
 
-  alias Alog.TestApp.{User, Helpers}
-
-  describe "all/0:" do
-    test "succeeds" do
-      {:ok, _} = %User{} |> User.changeset(Helpers.user_1_params()) |> User.insert()
-      {:ok, _} = %User{} |> User.changeset(Helpers.user_2_params()) |> User.insert()
-
-      assert length(User.all()) == 2
-    end
-
-    test "does not include old items" do
-      {:ok, user} = %User{} |> User.changeset(Helpers.user_1_params()) |> User.insert()
-      {:ok, _} = %User{} |> User.changeset(Helpers.user_2_params()) |> User.insert()
-      {:ok, _} = user |> User.changeset(%{postcode: "W2 3EC"}) |> User.update()
-
-      assert length(User.all()) == 2
-    end
-
-    test "all return inserted_at original value" do
-      {:ok, user} = %User{} |> User.changeset(Helpers.user_3_params()) |> User.insert()
-      {:ok, user_updated} = user |> User.changeset(%{postcode: "W2 3EC"}) |> User.update()
-
-      [user_all] = User.all()
-      assert user_all.inserted_at == user.inserted_at
-      assert user_all.postcode == user_updated.postcode
-    end
-  end
+  # alias Alog.TestApp.{User, Helpers}
+  #
+  # describe "all/0:" do
+  #   test "succeeds" do
+  #     {:ok, _} = %User{} |> User.changeset(Helpers.user_1_params()) |> User.insert()
+  #     {:ok, _} = %User{} |> User.changeset(Helpers.user_2_params()) |> User.insert()
+  #
+  #     assert length(User.all()) == 2
+  #   end
+  #
+  #   test "does not include old items" do
+  #     {:ok, user} = %User{} |> User.changeset(Helpers.user_1_params()) |> User.insert()
+  #     {:ok, _} = %User{} |> User.changeset(Helpers.user_2_params()) |> User.insert()
+  #     {:ok, _} = user |> User.changeset(%{postcode: "W2 3EC"}) |> User.update()
+  #
+  #     assert length(User.all()) == 2
+  #   end
+  #
+  #   test "all return inserted_at original value" do
+  #     {:ok, user} = %User{} |> User.changeset(Helpers.user_3_params()) |> User.insert()
+  #     {:ok, user_updated} = user |> User.changeset(%{postcode: "W2 3EC"}) |> User.update()
+  #
+  #     [user_all] = User.all()
+  #     assert user_all.inserted_at == user.inserted_at
+  #     assert user_all.postcode == user_updated.postcode
+  #   end
+  # end
 end
diff --git a/test/alog_test.exs b/test/alog_test.exs
index 1aa302b..fc14ecb 100644
--- a/test/alog_test.exs
+++ b/test/alog_test.exs
@@ -1,74 +1,74 @@
 defmodule AlogTest do
-  use Alog.TestApp.DataCase
-  doctest Alog
-
-  describe "required fields" do
-    test "schema without delete field raises error" do
-      assert_raise RuntimeError, fn ->
-        defmodule NoDeleteSchema do
-          use Ecto.Schema
-          use Alog
-
-          schema "bad_schema" do
-            field(:entry_id, :string)
-            timestamps()
-          end
-        end
-      end
-    end
-
-    test "schema without entry_id field raises error" do
-      assert_raise RuntimeError, fn ->
-        defmodule NoEntrySchema do
-          use Ecto.Schema
-          use Alog
-
-          schema "bad_schema" do
-            field(:deleted, :boolean, default: false)
-            timestamps()
-          end
-        end
-      end
-    end
-
-    test "schema with deleted field of wrong type raises error" do
-      assert_raise RuntimeError, fn ->
-        defmodule BadDeletedSchema do
-          use Ecto.Schema
-          use Alog
-
-          schema "bad_schema" do
-            field(:entry_id, :string)
-            field(:deleted, :string)
-            timestamps()
-          end
-        end
-      end
-    end
-
-    test "both required fields do not raise error" do
-      assert (fn ->
-                defmodule GoodSchema do
-                  use Ecto.Schema
-                  use Alog
-
-                  schema "bad_schema" do
-                    field(:entry_id, :string)
-                    field(:deleted, :boolean, default: false)
-                    timestamps()
-                  end
-                end
-              end).()
-    end
-  end
-
-  describe "Not compatible with unique index" do
-    test "Throws error if unique index exists" do
-      assert_raise RuntimeError, fn ->
-        %Alog.TestApp.Unique{}
-        |> Alog.TestApp.Unique.changeset(%{name: "unique item"})
-        |> Alog.TestApp.Unique.insert()
-      end
-    end
-  end
+  # use Alog.TestApp.DataCase
+  # doctest Alog
+  #
+  # describe "required fields" do
+  #   test "schema without delete field raises error" do
+  #     assert_raise RuntimeError, fn ->
+  #       defmodule NoDeleteSchema do
+  #         use Ecto.Schema
+  #         use Alog
+  #
+  #         schema "bad_schema" do
+  #           field(:entry_id, :string)
+  #           timestamps()
+  #         end
+  #       end
+  #     end
+  #   end
+  #
+  #   test "schema without entry_id field raises error" do
+  #     assert_raise RuntimeError, fn ->
+  #       defmodule NoEntrySchema do
+  #         use Ecto.Schema
+  #         use Alog
+  #
+  #         schema "bad_schema" do
+  #           field(:deleted, :boolean, default: false)
+  #           timestamps()
+  #         end
+  #       end
+  #     end
+  #   end
+  #
+  #   test "schema with deleted field of wrong type raises error" do
+  #     assert_raise RuntimeError, fn ->
+  #       defmodule BadDeletedSchema do
+  #         use Ecto.Schema
+  #         use Alog
+  #
+  #         schema "bad_schema" do
+  #           field(:entry_id, :string)
+  #           field(:deleted, :string)
+  #           timestamps()
+  #         end
+  #       end
+  #     end
+  #   end
+  #
+  #   test "both required fields do not raise error" do
+  #     assert (fn ->
+  #               defmodule GoodSchema do
+  #                 use Ecto.Schema
+  #                 use Alog
+  #
+  #                 schema "bad_schema" do
+  #                   field(:entry_id, :string)
+  #                   field(:deleted, :boolean, default: false)
+  #                   timestamps()
+  #                 end
+  #               end
+  #             end).()
+  #   end
+  # end
+  #
+  # describe "Not compatible with unique index" do
+  #   test "Throws error if unique index exists" do
+  #     assert_raise RuntimeError, fn ->
+  #       %Alog.TestApp.Unique{}
+  #       |> Alog.TestApp.Unique.changeset(%{name: "unique item"})
+  #       |> Alog.TestApp.Unique.insert()
+  #     end
+  #   end
+  # end
 end
diff --git a/test/constraint_test.exs b/test/constraint_test.exs
index 54f574d..e8ad9d8 100644
--- a/test/constraint_test.exs
+++ b/test/constraint_test.exs
@@ -1,33 +1,33 @@
 defmodule AlogTest.ConstraintTest do
-  use Alog.TestApp.DataCase
-
-  alias Alog.TestApp.{User, Helpers}
-
-  describe "apply_constraints/1:" do
-    test "returns error if not unique on insert" do
-      {:ok, user_1} = %User{} |> User.changeset(Helpers.user_1_params()) |> User.insert()
-
-      assert {:error, user_2} =
-               %User{}
-               |> User.changeset(
-                 Helpers.user_2_params()
-                 |> Map.merge(%{username: user_1.username})
-               )
-               |> User.insert()
-
-      assert user_2.errors == [username: {"has already been taken", []}]
-    end
-
-    test "returns error if not unique on update" do
-      {:ok, user_1} = %User{} |> User.changeset(Helpers.user_1_params()) |> User.insert()
-      {:ok, user_2} = %User{} |> User.changeset(Helpers.user_2_params()) |> User.insert()
-
-      assert {:error, user_2} =
-               user_2
-               |> User.changeset(%{username: user_1.username})
-               |> User.update()
-
-      assert user_2.errors == [username: {"has already been taken", []}]
-    end
-  end
+  # use Alog.TestApp.DataCase
+  #
+  # alias Alog.TestApp.{User, Helpers}
+  #
+  # describe "apply_constraints/1:" do
+  #   test "returns error if not unique on insert" do
+  #     {:ok, user_1} = %User{} |> User.changeset(Helpers.user_1_params()) |> User.insert()
+  #
+  #     assert {:error, user_2} =
+  #              %User{}
+  #              |> User.changeset(
+  #                Helpers.user_2_params()
+  #                |> Map.merge(%{username: user_1.username})
+  #              )
+  #              |> User.insert()
+  #
+  #     assert user_2.errors == [username: {"has already been taken", []}]
+  #   end
+  #
+  #   test "returns error if not unique on update" do
+  #     {:ok, user_1} = %User{} |> User.changeset(Helpers.user_1_params()) |> User.insert()
+  #     {:ok, user_2} = %User{} |> User.changeset(Helpers.user_2_params()) |> User.insert()
+  #
+  #     assert {:error, user_2} =
+  #              user_2
+  #              |> User.changeset(%{username: user_1.username})
+  #              |> User.update()
+  #
+  #     assert user_2.errors == [username: {"has already been taken", []}]
+  #   end
+  # end
 end
diff --git a/test/delete_test.exs b/test/delete_test.exs
index c4162bd..82167ea 100644
--- a/test/delete_test.exs
+++ b/test/delete_test.exs
@@ -1,47 +1,47 @@
 defmodule AlogTest.DeleteTest do
-  use Alog.TestApp.DataCase
-
-  alias Alog.TestApp.{User, Helpers}
-
-  describe "delete/1:" do
-    test "succeeds" do
-      {:ok, user} = %User{} |> User.changeset(Helpers.user_1_params()) |> User.insert()
-      assert {:ok, _} = User.delete(user)
-    end
-
-    test "deleted items are not retrieved with 'get'" do
-      {:ok, user} = %User{} |> User.changeset(Helpers.user_1_params()) |> User.insert()
-      {:ok, _} = User.delete(user)
-
-      assert User.get(user.entry_id) == nil
-    end
-
-    test "deleted items are not retrieved with 'all'" do
-      {:ok, user} = %User{} |> User.changeset(Helpers.user_1_params()) |> User.insert()
-      {:ok, _} = User.delete(user)
-
-      assert length(User.all()) == 0
-    end
-  end
-
-  describe "delete/1 - with changeset:" do
-    test "succeeds" do
-      {:ok, user} = %User{} |> User.changeset(Helpers.user_1_params()) |> User.insert()
-      assert {:ok, _} = user |> User.changeset(%{}) |> User.delete()
-    end
-
-    test "deleted items are not retrieved with 'get'" do
-      {:ok, user} = %User{} |> User.changeset(Helpers.user_1_params()) |> User.insert()
-      {:ok, _} = user |> User.changeset(%{}) |> User.delete()
-
-      assert User.get(user.entry_id) == nil
-    end
-
-    test "deleted items are not retrieved with 'all'" do
-      {:ok, user} = %User{} |> User.changeset(Helpers.user_1_params()) |> User.insert()
-      {:ok, _} = user |> User.changeset(%{}) |> User.delete()
-
-      assert length(User.all()) == 0
-    end
-  end
+  # use Alog.TestApp.DataCase
+  #
+  # alias Alog.TestApp.{User, Helpers}
+  #
+  # describe "delete/1:" do
+  #   test "succeeds" do
+  #     {:ok, user} = %User{} |> User.changeset(Helpers.user_1_params()) |> User.insert()
+  #     assert {:ok, _} = User.delete(user)
+  #   end
+  #
+  #   test "deleted items are not retrieved with 'get'" do
+  #     {:ok, user} = %User{} |> User.changeset(Helpers.user_1_params()) |> User.insert()
+  #     {:ok, _} = User.delete(user)
+  #
+  #     assert User.get(user.entry_id) == nil
+  #   end
+  #
+  #   test "deleted items are not retrieved with 'all'" do
+  #     {:ok, user} = %User{} |> User.changeset(Helpers.user_1_params()) |> User.insert()
+  #     {:ok, _} = User.delete(user)
+  #
+  #     assert length(User.all()) == 0
+  #   end
+  # end
+  #
+  # describe "delete/1 - with changeset:" do
+  #   test "succeeds" do
+  #     {:ok, user} = %User{} |> User.changeset(Helpers.user_1_params()) |> User.insert()
+  #     assert {:ok, _} = user |> User.changeset(%{}) |> User.delete()
+  #   end
+  #
+  #   test "deleted items are not retrieved with 'get'" do
+  #     {:ok, user} = %User{} |> User.changeset(Helpers.user_1_params()) |> User.insert()
+  #     {:ok, _} = user |> User.changeset(%{}) |> User.delete()
+  #
+  #     assert User.get(user.entry_id) == nil
+  #   end
+  #
+  #   test "deleted items are not retrieved with 'all'" do
+  #     {:ok, user} = %User{} |> User.changeset(Helpers.user_1_params()) |> User.insert()
+  #     {:ok, _} = user |> User.changeset(%{}) |> User.delete()
+  #
+  #     assert length(User.all()) == 0
+  #   end
+  # end
 end
diff --git a/test/get_by_test.exs b/test/get_by_test.exs
index 34fb9ee..a0f0228 100644
--- a/test/get_by_test.exs
+++ b/test/get_by_test.exs
@@ -1,66 +1,66 @@
 defmodule AlogTest.GetByTest do
-  use Alog.TestApp.DataCase
-
-  alias Alog.TestApp.{User, Helpers}
-
-  describe "get_by/2:" do
-    test "only returns one result" do
-      {:ok, _user} = %User{} |> User.changeset(Helpers.user_1_params()) |> User.insert()
-
-      {:ok, user_2} =
-        %User{}
-        |> User.changeset(Map.put(Helpers.user_2_params(), :postcode, "E2 0SY"))
-        |> User.insert()
-
-      assert User.get_by(postcode: "E2 0SY") == user_2
-    end
-
-    test "works with multiple clauses" do
-      {:ok, user} = %User{} |> User.changeset(Helpers.user_1_params()) |> User.insert()
-      {:ok, _user_2} = %User{} |> User.changeset(Helpers.user_2_params()) |> User.insert()
-
-      assert User.get_by(postcode: "E2 0SY", name: "Thor") == user
-    end
-
-    test "works with map params " do
-      {:ok, user} = %User{} |> User.changeset(Helpers.user_1_params()) |> User.insert()
-
-      assert User.get_by(%{postcode: "E2 0SY", name: "Thor"}) == user
-    end
-
-    test "case_insensitive option" do
-      {:ok, user} = %User{} |> User.changeset(Helpers.user_1_params()) |> User.insert()
-
-      refute User.get_by(name: "thor") == user
-      assert User.get_by([name: "thor"], case_insensitive: true) == user
-      assert User.get_by(%{name: "thor"}, case_insensitive: true) == user
-    end
-
-    test "does not retrieve outdated results" do
-      {:ok, user} = %User{} |> User.changeset(Helpers.user_1_params()) |> User.insert()
-      {:ok, _updated_user} = user |> User.changeset(%{postcode: "EC3 RST"}) |> User.update()
-
-      assert User.get_by(postcode: "E2 0SY") == nil
-    end
-
-    test "does retrieve updated results if they match" do
-      {:ok, user} = %User{} |> User.changeset(Helpers.user_1_params()) |> User.insert()
-      {:ok, updated_user} = user |> User.changeset(%{postcode: "EC3 RST"}) |> User.update()
-
-      assert User.get_by(name: "Thor") |> User.preload(:items) == updated_user
-    end
-
-    test "ignores outdated and retrieves matching" do
-      {:ok, user} = %User{} |> User.changeset(Helpers.user_1_params()) |> User.insert()
-
-      {:ok, user_2} =
-        %User{}
-        |> User.changeset(Map.put(Helpers.user_2_params(), :postcode, "E2 0SY"))
-        |> User.insert()
-
-      {:ok, _} = user_2 |> User.changeset(%{postcode: "EC3 RST"}) |> User.update()
-
-      assert User.get_by(postcode: "E2 0SY") == user
-    end
-  end
+  # use Alog.TestApp.DataCase
+  #
+  # alias Alog.TestApp.{User, Helpers}
+  #
+  # describe "get_by/2:" do
+  #   test "only returns one result" do
+  #     {:ok, _user} = %User{} |> User.changeset(Helpers.user_1_params()) |> User.insert()
+  #
+  #     {:ok, user_2} =
+  #       %User{}
+  #       |> User.changeset(Map.put(Helpers.user_2_params(), :postcode, "E2 0SY"))
+  #       |> User.insert()
+  #
+  #     assert User.get_by(postcode: "E2 0SY") == user_2
+  #   end
+  #
+  #   test "works with multiple clauses" do
+  #     {:ok, user} = %User{} |> User.changeset(Helpers.user_1_params()) |> User.insert()
+  #     {:ok, _user_2} = %User{} |> User.changeset(Helpers.user_2_params()) |> User.insert()
+  #
+  #     assert User.get_by(postcode: "E2 0SY", name: "Thor") == user
+  #   end
+  #
+  #   test "works with map params " do
+  #     {:ok, user} = %User{} |> User.changeset(Helpers.user_1_params()) |> User.insert()
+  #
+  #     assert User.get_by(%{postcode: "E2 0SY", name: "Thor"}) == user
+  #   end
+  #
+  #   test "case_insensitive option" do
+  #     {:ok, user} = %User{} |> User.changeset(Helpers.user_1_params()) |> User.insert()
+  #
+  #     refute User.get_by(name: "thor") == user
+  #     assert User.get_by([name: "thor"], case_insensitive: true) == user
+  #     assert User.get_by(%{name: "thor"}, case_insensitive: true) == user
+  #   end
+  #
+  #   test "does not retrieve outdated results" do
+  #     {:ok, user} = %User{} |> User.changeset(Helpers.user_1_params()) |> User.insert()
+  #     {:ok, _updated_user} = user |> User.changeset(%{postcode: "EC3 RST"}) |> User.update()
+  #
+  #     assert User.get_by(postcode: "E2 0SY") == nil
+  #   end
+  #
+  #   test "does retrieve updated results if they match" do
+  #     {:ok, user} = %User{} |> User.changeset(Helpers.user_1_params()) |> User.insert()
+  #     {:ok, updated_user} = user |> User.changeset(%{postcode: "EC3 RST"}) |> User.update()
+  #
+  #     assert User.get_by(name: "Thor") |> User.preload(:items) == updated_user
+  #   end
+  #
+  #   test "ignores outdated and retrieves matching" do
+  #     {:ok, user} = %User{} |> User.changeset(Helpers.user_1_params()) |> User.insert()
+  #
+  #     {:ok, user_2} =
+  #       %User{}
+  #       |> User.changeset(Map.put(Helpers.user_2_params(), :postcode, "E2 0SY"))
+  #       |> User.insert()
+  #
+  #     {:ok, _} = user_2 |> User.changeset(%{postcode: "EC3 RST"}) |> User.update()
+  #
+  #     assert User.get_by(postcode: "E2 0SY") == user
+  #   end
+  # end
 end
diff --git a/test/get_history_test.exs b/test/get_history_test.exs
index 1926696..eb9bd16 100644
--- a/test/get_history_test.exs
+++ b/test/get_history_test.exs
@@ -1,14 +1,14 @@
 defmodule AlogTest.GetHistoryTest do
-  use Alog.TestApp.DataCase
-
-  alias Alog.TestApp.{User, Helpers}
-
-  describe "get_history/1:" do
-    test "gets all items" do
-      {:ok, user} = %User{} |> User.changeset(Helpers.user_1_params()) |> User.insert()
-      {:ok, updated_user} = user |> User.changeset(%{postcode: "W2 3EC"}) |> User.update()
-
-      assert length(User.get_history(updated_user)) == 2
-    end
-  end
+  # use Alog.TestApp.DataCase
+  #
+  # alias Alog.TestApp.{User, Helpers}
+  #
+  # describe "get_history/1:" do
+  #   test "gets all items" do
+  #     {:ok, user} = %User{} |> User.changeset(Helpers.user_1_params()) |> User.insert()
+  #     {:ok, updated_user} = user |> User.changeset(%{postcode: "W2 3EC"}) |> User.update()
+  #
+  #     assert length(User.get_history(updated_user)) == 2
+  #   end
+  # end
 end
diff --git a/test/insert_test.exs b/test/insert_test.exs
index ae3300b..cee1241 100644
--- a/test/insert_test.exs
+++ b/test/insert_test.exs
@@ -1,117 +1,117 @@
 defmodule AlogTest.InsertTest do
-  use Alog.TestApp.DataCase
-
-  alias Alog.TestApp.{User, Item, ItemType, Helpers}
-
-  describe "insert/1 - with changeset:" do
-    test "succeeds" do
-      assert {:ok, user} = %User{} |> User.changeset(Helpers.user_1_params()) |> User.insert()
-    end
-
-    test "validates required fields" do
-      {:error, changeset} =
-        %User{}
-        |> User.changeset(%{name: "Thor"})
-        |> User.insert()
-
-      assert length(changeset.errors) > 0
-    end
-
-    test "inserted user is available" do
-      {:ok, user} = %User{} |> User.changeset(Helpers.user_1_params()) |> User.insert()
-
-      assert User.get(user.entry_id) == user
-    end
-  end
-
-  describe "insert/1 - with struct:" do
-    test "succeeds" do
-      {:ok, user} = struct(User, Helpers.user_1_params()) |> User.insert()
-
-      assert User.get(user.entry_id) == user
-    end
-
-    test "inserted user is available" do
-      {:ok, user} = struct(User, Helpers.user_1_params()) |> User.insert()
-
-      assert User.get(user.entry_id) == user
-    end
-  end
-
-  describe "insert/1 - with nested changeset:" do
-    test "succeeds" do
-      assert {:ok, user} =
-               %User{}
-               |> User.user_and_item_changeset(
-                 Map.put(Helpers.user_1_params(), :items, [%{name: "Belt"}])
-               )
-               |> User.insert()
-    end
-
-    test "item is associated with user" do
-      {:ok, user} =
-        %User{}
-        |> User.user_and_item_changeset(
-          Map.put(Helpers.user_1_params(), :items, [%{name: "Belt"}])
-        )
-        |> User.insert()
-
-      assert User.get(user.entry_id) |> Repo.preload(:items) |> Map.get(:items) |> length == 1
-    end
-
-    test "associated item is inserted into database - has_many" do
-      {:ok, _user} =
-        %User{}
-        |> User.user_and_item_changeset(
-          Map.put(Helpers.user_1_params(), :items, [%{name: "Belt"}])
-        )
-        |> User.insert()
-
-      all_items = Item.all()
-
-      assert length(all_items) == 1
-      assert List.first(all_items).entry_id
-    end
-
-    test "associated item is inserted into database - belongs_to" do
-      {:ok, _item} =
-        %Item{}
-        |> Item.changeset(Map.put(%{name: "Stormbreaker"}, :user, Helpers.user_1_params()))
-        |> Item.insert()
-
-      all_users = User.all()
-
-      user = List.first(all_users)
-
-      assert length(all_users) == 1
-      assert user.entry_id
-      assert user.name == "Thor"
-    end
-
-    test "two level deep nested associations" do
-      {:ok, _user} =
-        %User{}
-        |> User.user_and_item_changeset(
-          Map.put(Helpers.user_1_params(), :items, [
-            %{name: "Stormbreaker", item_types: [%{type: "Axe"}]}
-          ])
-        )
-        |> User.insert()
-
-      all_items = Item.all()
-      all_types = ItemType.all()
-
-      item = List.first(all_items)
-      type = List.first(all_types)
-
-      assert length(all_items) == 1
-      assert length(all_types) == 1
-
-      assert item.entry_id
-      assert item.name == "Stormbreaker"
-
-      assert type.entry_id
-      assert type.type == "Axe"
-    end
-  end
+  # use Alog.TestApp.DataCase
+  #
+  # alias Alog.TestApp.{User, Item, ItemType, Helpers}
+  #
+  # describe "insert/1 - with changeset:" do
+  #   test "succeeds" do
+  #     assert {:ok, user} = %User{} |> User.changeset(Helpers.user_1_params()) |> User.insert()
+  #   end
+  #
+  #   test "validates required fields" do
+  #     {:error, changeset} =
+  #       %User{}
+  #       |> User.changeset(%{name: "Thor"})
+  #       |> User.insert()
+  #
+  #     assert length(changeset.errors) > 0
+  #   end
+  #
+  #   test "inserted user is available" do
+  #     {:ok, user} = %User{} |> User.changeset(Helpers.user_1_params()) |> User.insert()
+  #
+  #     assert User.get(user.entry_id) == user
+  #   end
+  # end
+  #
+  # describe "insert/1 - with struct:" do
+  #   test "succeeds" do
+  #     {:ok, user} = struct(User, Helpers.user_1_params()) |> User.insert()
+  #
+  #     assert User.get(user.entry_id) == user
+  #   end
+  #
+  #   test "inserted user is available" do
+  #     {:ok, user} = struct(User, Helpers.user_1_params()) |> User.insert()
+  #
+  #     assert User.get(user.entry_id) == user
+  #   end
+  # end
+  #
+  # describe "insert/1 - with nested changeset:" do
+  #   test "succeeds" do
+  #     assert {:ok, user} =
+  #              %User{}
+  #              |> User.user_and_item_changeset(
+  #                Map.put(Helpers.user_1_params(), :items, [%{name: "Belt"}])
+  #              )
+  #              |> User.insert()
+  #   end
+  #
+  #   test "item is associated with user" do
+  #     {:ok, user} =
+  #       %User{}
+  #       |> User.user_and_item_changeset(
+  #         Map.put(Helpers.user_1_params(), :items, [%{name: "Belt"}])
+  #       )
+  #       |> User.insert()
+  #
+  #     assert User.get(user.entry_id) |> Repo.preload(:items) |> Map.get(:items) |> length == 1
+  #   end
+  #
+  #   test "associated item is inserted into database - has_many" do
+  #     {:ok, _user} =
+  #       %User{}
+  #       |> User.user_and_item_changeset(
+  #         Map.put(Helpers.user_1_params(), :items, [%{name: "Belt"}])
+  #       )
+  #       |> User.insert()
+  #
+  #     all_items = Item.all()
+  #
+  #     assert length(all_items) == 1
+  #     assert List.first(all_items).entry_id
+  #   end
+  #
+  #   test "associated item is inserted into database - belongs_to" do
+  #     {:ok, _item} =
+  #       %Item{}
+  #       |> Item.changeset(Map.put(%{name: "Stormbreaker"}, :user, Helpers.user_1_params()))
+  #       |> Item.insert()
+  #
+  #     all_users = User.all()
+  #
+  #     user = List.first(all_users)
+  #
+  #     assert length(all_users) == 1
+  #     assert user.entry_id
+  #     assert user.name == "Thor"
+  #   end
+  #
+  #   test "two level deep nested associations" do
+  #     {:ok, _user} =
+  #       %User{}
+  #       |> User.user_and_item_changeset(
+  #         Map.put(Helpers.user_1_params(), :items, [
+  #           %{name: "Stormbreaker", item_types: [%{type: "Axe"}]}
+  #         ])
+  #       )
+  #       |> User.insert()
+  #
+  #     all_items = Item.all()
+  #     all_types = ItemType.all()
+  #
+  #     item = List.first(all_items)
+  #     type = List.first(all_types)
+  #
+  #     assert length(all_items) == 1
+  #     assert length(all_types) == 1
+  #
+  #     assert item.entry_id
+  #     assert item.name == "Stormbreaker"
+  #
+  #     assert type.entry_id
+  #     assert type.type == "Axe"
+  #   end
+  # end
 end
diff --git a/test/preload_test.exs b/test/preload_test.exs
index cecab64..d20fee5 100644
--- a/test/preload_test.exs
+++ b/test/preload_test.exs
@@ -1,57 +1,57 @@
 defmodule AlogTest.PreloadTest do
-  use Alog.TestApp.DataCase
-
-  alias Alog.TestApp.{User, Item, Helpers}
-
-  test "preloads one_to_many associations" do
-    {:ok, user, _} = Helpers.seed_data()
-
-    # items are not loaded by default
-    assert_raise ArgumentError, fn ->
-      user.entry_id
-      |> User.get()
-      |> Map.get(:items)
-      |> length()
-    end
-
-    assert user.entry_id
-           |> User.get()
-           |> User.preload(:items)
-           |> Map.get(:items)
-           |> length() == 1
-  end
-
-  test "preloads nested associations" do
-    {:ok, user, item} = Helpers.seed_data()
-
-    # item_types are not loaded by default
-    assert_raise ArgumentError, fn ->
-      item.entry_id
-      |> Item.get()
-      |> Map.get(:item_types)
-      |> length()
-    end
-
-    assert user.entry_id
-           |> User.get()
-           |> User.preload(items: [:item_types])
-           |> Map.get(:items)
-           |> List.first()
-           |> Map.get(:item_types)
-           |> length() == 1
-  end
-
-  test "preloads two level deep nested associations" do
-    {:ok, user, _} = Helpers.seed_data()
-
-    assert user.entry_id
-           |> User.get()
-           |> User.preload(items: [item_types: [:items]])
-           |> Map.get(:items)
-           |> List.first()
-           |> Map.get(:item_types)
-           |> List.first()
-           |> Map.get(:items)
-           |> length() == 2
-  end
+  # use Alog.TestApp.DataCase
+  #
+  # alias Alog.TestApp.{User, Item, Helpers}
+  #
+  # test "preloads one_to_many associations" do
+  #   {:ok, user, _} = Helpers.seed_data()
+  #
+  #   # items are not loaded by default
+  #   assert_raise ArgumentError, fn ->
+  #     user.entry_id
+  #     |> User.get()
+  #     |> Map.get(:items)
+  #     |> length()
+  #   end
+  #
+  #   assert user.entry_id
+  #          |> User.get()
+  #          |> User.preload(:items)
+  #          |> Map.get(:items)
+  #          |> length() == 1
+  # end
+  #
+  # test "preloads nested associations" do
+  #   {:ok, user, item} = Helpers.seed_data()
+  #
+  #   # item_types are not loaded by default
+  #   assert_raise ArgumentError, fn ->
+  #     item.entry_id
+  #     |> Item.get()
+  #     |> Map.get(:item_types)
+  #     |> length()
+  #   end
+  #
+  #   assert user.entry_id
+  #          |> User.get()
+  #          |> User.preload(items: [:item_types])
+  #          |> Map.get(:items)
+  #          |> List.first()
+  #          |> Map.get(:item_types)
+  #          |> length() == 1
+  # end
+  #
+  # test "preloads two level deep nested associations" do
+  #   {:ok, user, _} = Helpers.seed_data()
+  #
+  #   assert user.entry_id
+  #          |> User.get()
+  #          |> User.preload(items: [item_types: [:items]])
+  #          |> Map.get(:items)
+  #          |> List.first()
+  #          |> Map.get(:item_types)
+  #          |> List.first()
+  #          |> Map.get(:items)
+  #          |> length() == 2
+  # end
 end
diff --git a/test/support/application.ex b/test/support/application.ex
index 91becea..f0176dd 100644
--- a/test/support/application.ex
+++ b/test/support/application.ex
@@ -3,8 +3,6 @@ defmodule Alog.TestApp.Application do
   use Application
 
   def start(_type, _args) do
-    import Supervisor.Spec
-
     opts = [strategy: :one_for_one, name: Alog.TestApp.Supervisor]
 
     Supervisor.start_link([Alog.Repo], opts)
diff --git a/test/support/helpers.ex b/test/support/helpers.ex
index 2374956..ec3dbf6 100644
--- a/test/support/helpers.ex
+++ b/test/support/helpers.ex
@@ -1,48 +1,48 @@
 defmodule Alog.TestApp.Helpers do
-  alias Alog.TestApp.{User, Item, ItemType}
-  alias Alog.Repo
-
-  def user_1_params(), do: %{name: "Thor", username: "gdofthndr12", postcode: "E2 0SY"}
-
-  def user_2_params(), do: %{name: "Loki", username: "mschfmkr", postcode: "E1 6DR"}
-
-  def user_3_params(), do: %{name: "Bob", username: "bobuser", postcode: "E1 7DR"}
-
-  def seed_data() do
-    {:ok, item_type} = %ItemType{} |> ItemType.changeset(%{type: "Weapon"}) |> ItemType.insert()
-
-    {:ok, item} = %Item{} |> Item.changeset(%{name: "Mjolnir"}) |> Item.insert()
-    {:ok, item_2} = %Item{} |> Item.changeset(%{name: "Staff"}) |> Item.insert()
-
-    {:ok, item} = add_type_to_item(item, item_type)
-    {:ok, _item_2} = add_type_to_item(item_2, item_type)
-
-    {:ok, user} = %User{} |> User.changeset(user_1_params) |> User.insert()
-
-    {:ok, user} = add_item_to_user(user, item)
-
-    {:ok, user, item}
-  end
-
-  def add_type_to_item(item, type) do
-    item
-    |> Item.preload([:item_types, :user])
-    |> Map.put(:id, nil)
-    |> Map.put(:inserted_at, nil)
-    |> Map.put(:updated_at, nil)
-    |> Item.changeset(%{})
-    |> Ecto.Changeset.put_assoc(:item_types, [type])
-    |> Repo.insert()
-  end
-
-  def add_item_to_user(user, item) do
-    user
-    |> User.preload([:items])
-    |> Map.put(:id, nil)
-    |> Map.put(:inserted_at, nil)
-    |> Map.put(:updated_at, nil)
-    |> User.changeset(%{})
-    |> Ecto.Changeset.put_assoc(:items, [item])
-    |> Repo.insert()
-  end
+  # alias Alog.TestApp.{User, Item, ItemType}
+  # alias Alog.Repo
+  #
+  # def user_1_params(), do: %{name: "Thor", username: "gdofthndr12", postcode: "E2 0SY"}
+  #
+  # def user_2_params(), do: %{name: "Loki", username: "mschfmkr", postcode: "E1 6DR"}
+  #
+  # def user_3_params(), do: %{name: "Bob", username: "bobuser", postcode: "E1 7DR"}
+  #
+  # def seed_data() do
+  #   {:ok, item_type} = %ItemType{} |> ItemType.changeset(%{type: "Weapon"}) |> ItemType.insert()
+  #
+  #   {:ok, item} = %Item{} |> Item.changeset(%{name: "Mjolnir"}) |> Item.insert()
+  #   {:ok, item_2} = %Item{} |> Item.changeset(%{name: "Staff"}) |> Item.insert()
+  #
+  #   {:ok, item} = add_type_to_item(item, item_type)
+  #   {:ok, _item_2} = add_type_to_item(item_2, item_type)
+  #
+  #   {:ok, user} = %User{} |> User.changeset(user_1_params) |> User.insert()
+  #
+  #   {:ok, user} = add_item_to_user(user, item)
+  #
+  #   {:ok, user, item}
+  # end
+  #
+  # def add_type_to_item(item, type) do
+  #   item
+  #   |> Item.preload([:item_types, :user])
+  #   |> Map.put(:id, nil)
+  #   |> Map.put(:inserted_at, nil)
+  #   |> Map.put(:updated_at, nil)
+  #   |> Item.changeset(%{})
+  #   |> Ecto.Changeset.put_assoc(:item_types, [type])
+  #   |> Repo.insert()
+  # end
+  #
+  # def add_item_to_user(user, item) do
+  #   user
+  #   |> User.preload([:items])
+  #   |> Map.put(:id, nil)
+  #   |> Map.put(:inserted_at, nil)
+  #   |> Map.put(:updated_at, nil)
+  #   |> User.changeset(%{})
+  #   |> Ecto.Changeset.put_assoc(:items, [item])
+  #   |> Repo.insert()
+  # end
 end
diff --git a/test/update_test.exs b/test/update_test.exs
index 076f639..bd22a9f 100644
--- a/test/update_test.exs
+++ b/test/update_test.exs
@@ -1,38 +1,38 @@
 defmodule AlogTest.UpdateTest do
-  use Alog.TestApp.DataCase
-
-  alias Alog.TestApp.{User, Helpers}
-
-  describe "update/2:" do
-    test "succeeds" do
-      {:ok, user} = %User{} |> User.changeset(Helpers.user_1_params()) |> User.insert()
-
-      assert {:ok, updated_user} = user |> User.changeset(%{postcode: "W2 3EC"}) |> User.update()
-    end
-
-    test "updates" do
-      {:ok, user} = %User{} |> User.changeset(Helpers.user_1_params()) |> User.insert()
-
-      {:ok, updated_user} = user |> User.changeset(%{postcode: "W2 3EC"}) |> User.update()
-
-      assert updated_user.postcode == "W2 3EC"
-    end
-
-    test "'get' returns most recently updated item" do
-      {:ok, user} = %User{} |> User.changeset(Helpers.user_1_params()) |> User.insert()
-
-      {:ok, updated_user} = user |> User.changeset(%{postcode: "W2 3EC"}) |> User.update()
-
-      assert User.get(user.entry_id) |> User.preload(:items) == updated_user
-      assert User.get(user.entry_id).postcode == "W2 3EC"
-    end
-
-    test "associations remain after update" do
-      {:ok, user, _item} = Helpers.seed_data()
-
-      {:ok, _updated_user} = user |> User.changeset(%{postcode: "W2 3EC"}) |> User.update()
-
-      assert User.get(user.entry_id) |> User.preload(:items) |> Map.get(:items) |> length == 1
-    end
-  end
+  # use Alog.TestApp.DataCase
+  #
+  # alias Alog.TestApp.{User, Helpers}
+  #
+  # describe "update/2:" do
+  #   test "succeeds" do
+  #     {:ok, user} = %User{} |> User.changeset(Helpers.user_1_params()) |> User.insert()
+  #
+  #     assert {:ok, updated_user} = user |> User.changeset(%{postcode: "W2 3EC"}) |> User.update()
+  #   end
+  #
+  #   test "updates" do
+  #     {:ok, user} = %User{} |> User.changeset(Helpers.user_1_params()) |> User.insert()
+  #
+  #     {:ok, updated_user} = user |> User.changeset(%{postcode: "W2 3EC"}) |> User.update()
+  #
+  #     assert updated_user.postcode == "W2 3EC"
+  #   end
+  #
+  #   test "'get' returns most recently updated item" do
+  #     {:ok, user} = %User{} |> User.changeset(Helpers.user_1_params()) |> User.insert()
+  #
+  #     {:ok, updated_user} = user |> User.changeset(%{postcode: "W2 3EC"}) |> User.update()
+  #
+  #     assert User.get(user.entry_id) |> User.preload(:items) == updated_user
+  #     assert User.get(user.entry_id).postcode == "W2 3EC"
+  #   end
+  #
+  #   test "associations remain after update" do
+  #     {:ok, user, _item} = Helpers.seed_data()
+  #
+  #     {:ok, _updated_user} = user |> User.changeset(%{postcode: "W2 3EC"}) |> User.update()
+  #
+  #     assert User.get(user.entry_id) |> User.preload(:items) |> Map.get(:items) |> length == 1
+  #   end
+  # end
 end

From ad663909671e0145e922347724d0c9669a7085d0 Mon Sep 17 00:00:00 2001
From: Robert Francis <robertefrancis18@gmail.com>
Date: Fri, 1 Mar 2019 15:03:22 +0000
Subject: [PATCH 18/35] remove functions that were causing errors #45

---
 lib/alog.ex | 6 ------
 1 file changed, 6 deletions(-)

diff --git a/lib/alog.ex b/lib/alog.ex
index 324f998..0097a6d 100644
--- a/lib/alog.ex
+++ b/lib/alog.ex
@@ -18,12 +18,6 @@ defmodule Alog do
   @impl true
   defdelegate storage_down(opts), to: EAP
 
-  @impl true
-  defdelegate structure_dump(default, config), to: EAP
-
-  @impl true
-  defdelegate structure_load(default, config), to: EAP
-
   # overrides insert/6 defined in Ecto.Adapters.SQL
   def insert(adapter_meta, %{source: source, prefix: prefix}, params, on_conflict, returning, opts) do
     # converts params from a keyword list to a map

From eaa87b510dd565783e044d75613df393970f436d Mon Sep 17 00:00:00 2001
From: Robert Francis <robertefrancis18@gmail.com>
Date: Fri, 1 Mar 2019 15:04:10 +0000
Subject: [PATCH 19/35] Adds timestamps to migration file. (leaves timestamps
 out of schema on purpose) #45

---
 .../test_app/migrations/20190301105228_create_comments.exs     | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/priv/repo/test_app/migrations/20190301105228_create_comments.exs b/priv/repo/test_app/migrations/20190301105228_create_comments.exs
index e0b3ccf..92a6810 100644
--- a/priv/repo/test_app/migrations/20190301105228_create_comments.exs
+++ b/priv/repo/test_app/migrations/20190301105228_create_comments.exs
@@ -4,10 +4,13 @@ defmodule Alog.Repo.Migrations.CreateComments do
   def change do
     create table(:comments, primary_key: false) do
       # cid & entry_id need to be removed later as they should be handled in execute_ddl I believe
+      # timestamps are needed in alog but may or may not be in the schema.
       add(:cid, :string, primary_key: true)
       add(:entry_id, :string)
       add(:comment, :string)
       add(:deleted, :boolean, default: false)
+
+      timestamps()
     end
   end
 end

From f43ca3564658d8b598a664826d6631b9f9ed790b Mon Sep 17 00:00:00 2001
From: Robert Francis <robertefrancis18@gmail.com>
Date: Fri, 1 Mar 2019 15:04:21 +0000
Subject: [PATCH 20/35] correct typo

---
 test/support/comment.ex | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/test/support/comment.ex b/test/support/comment.ex
index f04cc96..2d7311e 100644
--- a/test/support/comment.ex
+++ b/test/support/comment.ex
@@ -4,7 +4,7 @@ defmodule Alog.TestApp.Comment do
 
   # I'd imagine we'll change string as the type but
   @primary_key {:cid, :string, autogenerate: false}
-  schema "users" do
+  schema "comments" do
     field(:entry_id, :string)
     field(:comment, :string)
     field(:deleted, :boolean, default: false)

From 7124449a48c772c8a741c2df1080222eff72df15 Mon Sep 17 00:00:00 2001
From: Robert Francis <robertefrancis18@gmail.com>
Date: Fri, 1 Mar 2019 15:04:44 +0000
Subject: [PATCH 21/35] Creates a test to insert a comment into the database
 #45

---
 test/insert_test.exs | 52 ++++++++++++++++++++++++--------------------
 1 file changed, 28 insertions(+), 24 deletions(-)

diff --git a/test/insert_test.exs b/test/insert_test.exs
index cee1241..4d5eebe 100644
--- a/test/insert_test.exs
+++ b/test/insert_test.exs
@@ -1,28 +1,32 @@
 defmodule AlogTest.InsertTest do
-  # use Alog.TestApp.DataCase
-  #
-  # alias Alog.TestApp.{User, Item, ItemType, Helpers}
-  #
-  # describe "insert/1 - with changeset:" do
-  #   test "succeeds" do
-  #     assert {:ok, user} = %User{} |> User.changeset(Helpers.user_1_params()) |> User.insert()
-  #   end
-  #
-  #   test "validates required fields" do
-  #     {:error, changeset} =
-  #       %User{}
-  #       |> User.changeset(%{name: "Thor"})
-  #       |> User.insert()
-  #
-  #     assert length(changeset.errors) > 0
-  #   end
-  #
-  #   test "inserted user is available" do
-  #     {:ok, user} = %User{} |> User.changeset(Helpers.user_1_params()) |> User.insert()
-  #
-  #     assert User.get(user.entry_id) == user
-  #   end
-  # end
+  use Alog.TestApp.DataCase
+  alias Alog.Repo
+  alias Alog.TestApp.{Comment}
+
+  describe "Repo.insert/2 - with Comment struct:" do
+    test "succeeds" do
+      Repo.insert(%Comment{comment: "hi"})
+      |> IO.inspect(label: "===> Result of insert")
+
+      Repo.all(Comment)
+      |> IO.inspect(label: "===> All comments (should only be the one)")
+    end
+
+    # test "validates required fields" do
+    #   {:error, changeset} =
+    #     %User{}
+    #     |> User.changeset(%{name: "Thor"})
+    #     |> User.insert()
+    #
+    #   assert length(changeset.errors) > 0
+    # end
+    #
+    # test "inserted user is available" do
+    #   {:ok, user} = %User{} |> User.changeset(Helpers.user_1_params()) |> User.insert()
+    #
+    #   assert User.get(user.entry_id) == user
+    # end
+  end
   #
   # describe "insert/1 - with struct:" do
   #   test "succeeds" do

From ff3f1d38817dd1313eef0216c74af042f6126a0f Mon Sep 17 00:00:00 2001
From: Robert Francis <robertefrancis18@gmail.com>
Date: Fri, 1 Mar 2019 15:44:26 +0000
Subject: [PATCH 22/35] creates a clause to ensure migrations to not fail
 because of schema_migrations table #45

---
 lib/alog.ex             | 16 ++++++++++++----
 test/support/comment.ex |  2 +-
 2 files changed, 13 insertions(+), 5 deletions(-)

diff --git a/lib/alog.ex b/lib/alog.ex
index 0097a6d..ad89e50 100644
--- a/lib/alog.ex
+++ b/lib/alog.ex
@@ -19,6 +19,10 @@ defmodule Alog do
   defdelegate storage_down(opts), to: EAP
 
   # overrides insert/6 defined in Ecto.Adapters.SQL
+  def insert(adapter_meta, %{source: "schema_migrations", prefix: prefix}, params, on_conflict, returning, opts) do
+    insert_logic(adapter_meta, "schema_migrations", prefix, params, on_conflict, returning, opts)
+  end
+
   def insert(adapter_meta, %{source: source, prefix: prefix}, params, on_conflict, returning, opts) do
     # converts params from a keyword list to a map
     params_map = Enum.into(params, %{})
@@ -41,10 +45,7 @@ defmodule Alog do
       |> Map.put(:entry_id, entry_id)
       |> Enum.into([])
 
-    {kind, conflict_params, _} = on_conflict
-    {fields, values} = :lists.unzip(params)
-    sql = @conn.insert(prefix, source, fields, [fields], on_conflict, returning)
-    Ecto.Adapters.SQL.struct(adapter_meta, @conn, sql, :insert, source, [], values ++ conflict_params, kind, returning, opts)
+    insert_logic(adapter_meta, source, prefix, params, on_conflict, returning, opts)
   end
 
   # I think that this step need to also make sure that the data is not an exact copy.
@@ -70,4 +71,11 @@ defmodule Alog do
     |> Map.put_new(:inserted_at, NaiveDateTime.utc_now())
     |> Map.put_new(:updated_at, NaiveDateTime.utc_now())
   end
+
+  defp insert_logic(adapter_meta, source, prefix, params, on_conflict, returning, opts) do
+    {kind, conflict_params, _} = on_conflict
+    {fields, values} = :lists.unzip(params)
+    sql = @conn.insert(prefix, source, fields, [fields], on_conflict, returning)
+    Ecto.Adapters.SQL.struct(adapter_meta, @conn, sql, :insert, source, [], values ++ conflict_params, kind, returning, opts)
+  end
 end
diff --git a/test/support/comment.ex b/test/support/comment.ex
index 2d7311e..bbb792c 100644
--- a/test/support/comment.ex
+++ b/test/support/comment.ex
@@ -2,7 +2,7 @@ defmodule Alog.TestApp.Comment do
   use Ecto.Schema
   import Ecto.Changeset
 
-  # I'd imagine we'll change string as the type but
+  # I'd imagine we'll change string as the type
   @primary_key {:cid, :string, autogenerate: false}
   schema "comments" do
     field(:entry_id, :string)

From 65f898e66ba87084ef65f53dc63231d5979e9b19 Mon Sep 17 00:00:00 2001
From: Robert Francis <robertefrancis18@gmail.com>
Date: Fri, 1 Mar 2019 20:22:35 +0000
Subject: [PATCH 23/35] adds unique constraint to comment changeset #45

---
 test/support/comment.ex | 1 +
 1 file changed, 1 insertion(+)

diff --git a/test/support/comment.ex b/test/support/comment.ex
index bbb792c..ee1b788 100644
--- a/test/support/comment.ex
+++ b/test/support/comment.ex
@@ -13,5 +13,6 @@ defmodule Alog.TestApp.Comment do
   def changeset(comment_struct, attrs \\ %{}) do
     comment_struct
     |> cast(attrs, [:cid, :entry_id, :comment, :deleted])
+    |> unique_constraint(:cid, name: :comments_pkey)
   end
 end
\ No newline at end of file

From 0c11e6ff588903864182e1a58189b71ec6d69121 Mon Sep 17 00:00:00 2001
From: Robert Francis <robertefrancis18@gmail.com>
Date: Fri, 1 Mar 2019 20:23:09 +0000
Subject: [PATCH 24/35] adds tests #45

---
 test/insert_test.exs | 20 +++++++++++++++++---
 1 file changed, 17 insertions(+), 3 deletions(-)

diff --git a/test/insert_test.exs b/test/insert_test.exs
index 4d5eebe..75e7a13 100644
--- a/test/insert_test.exs
+++ b/test/insert_test.exs
@@ -6,10 +6,24 @@ defmodule AlogTest.InsertTest do
   describe "Repo.insert/2 - with Comment struct:" do
     test "succeeds" do
       Repo.insert(%Comment{comment: "hi"})
-      |> IO.inspect(label: "===> Result of insert")
+      num_comments = Comment |> Repo.all() |> length()
+      assert num_comments == 1
+    end
+
+    test "inserting the same comment twice fails with changeset" do
+      Repo.insert(%Comment{comment: "hi"})
+
+      {atom, _changeset} =
+        %Comment{}
+        |> Comment.changeset(%{comment: "hi"})
+        |> Repo.insert()
 
-      Repo.all(Comment)
-      |> IO.inspect(label: "===> All comments (should only be the one)")
+      assert atom == :error
+    end
+
+    test "inserting the same comment twice fails without changeset" do
+      Repo.insert(%Comment{comment: "hi"})
+      Repo.insert(%Comment{comment: "hi"})
     end
 
     # test "validates required fields" do

From 2b1bdf0d832d163df6d2ed4d191602f8296e2827 Mon Sep 17 00:00:00 2001
From: Robert Francis <robertefrancis18@gmail.com>
Date: Mon, 4 Mar 2019 12:04:21 +0000
Subject: [PATCH 25/35] removes test causing error #45

---
 .../test_app/migrations/20190301105228_create_comments.exs   | 2 +-
 test/insert_test.exs                                         | 5 -----
 test/support/comment.ex                                      | 2 +-
 3 files changed, 2 insertions(+), 7 deletions(-)

diff --git a/priv/repo/test_app/migrations/20190301105228_create_comments.exs b/priv/repo/test_app/migrations/20190301105228_create_comments.exs
index 92a6810..503dc0b 100644
--- a/priv/repo/test_app/migrations/20190301105228_create_comments.exs
+++ b/priv/repo/test_app/migrations/20190301105228_create_comments.exs
@@ -7,8 +7,8 @@ defmodule Alog.Repo.Migrations.CreateComments do
       # timestamps are needed in alog but may or may not be in the schema.
       add(:cid, :string, primary_key: true)
       add(:entry_id, :string)
-      add(:comment, :string)
       add(:deleted, :boolean, default: false)
+      add(:comment, :string)
 
       timestamps()
     end
diff --git a/test/insert_test.exs b/test/insert_test.exs
index 75e7a13..d3059aa 100644
--- a/test/insert_test.exs
+++ b/test/insert_test.exs
@@ -21,11 +21,6 @@ defmodule AlogTest.InsertTest do
       assert atom == :error
     end
 
-    test "inserting the same comment twice fails without changeset" do
-      Repo.insert(%Comment{comment: "hi"})
-      Repo.insert(%Comment{comment: "hi"})
-    end
-
     # test "validates required fields" do
     #   {:error, changeset} =
     #     %User{}
diff --git a/test/support/comment.ex b/test/support/comment.ex
index ee1b788..5a3ab13 100644
--- a/test/support/comment.ex
+++ b/test/support/comment.ex
@@ -6,8 +6,8 @@ defmodule Alog.TestApp.Comment do
   @primary_key {:cid, :string, autogenerate: false}
   schema "comments" do
     field(:entry_id, :string)
-    field(:comment, :string)
     field(:deleted, :boolean, default: false)
+    field(:comment, :string)
   end
 
   def changeset(comment_struct, attrs \\ %{}) do

From 90927dea730ce1a727314d5d77ef39c901cb5e05 Mon Sep 17 00:00:00 2001
From: Robert Francis <robertefrancis18@gmail.com>
Date: Mon, 4 Mar 2019 12:35:49 +0000
Subject: [PATCH 26/35] removes comments that are no longer needed #45

---
 lib/alog.ex                                              | 9 +--------
 .../migrations/20190301105228_create_comments.exs        | 2 --
 2 files changed, 1 insertion(+), 10 deletions(-)

diff --git a/lib/alog.ex b/lib/alog.ex
index ad89e50..24bb1b8 100644
--- a/lib/alog.ex
+++ b/lib/alog.ex
@@ -7,8 +7,6 @@ defmodule Alog do
 
   @behaviour Ecto.Adapter.Storage
 
-  # Why did we define our own version of this function?
-  # Sorry if I have missed something that has been explained already.
   @impl true
   def supports_ddl_transaction?, do: true
 
@@ -41,18 +39,13 @@ defmodule Alog do
     params =
       map_for_cid
       |> add_timestamps()
-      |> Map.put(:cid, cid) # <==== Should this be Map.put(:id, cid)??????????
+      |> Map.put(:cid, cid)
       |> Map.put(:entry_id, entry_id)
       |> Enum.into([])
 
     insert_logic(adapter_meta, source, prefix, params, on_conflict, returning, opts)
   end
 
-  # I think that this step need to also make sure that the data is not an exact copy.
-  # if the full cid already exists then this is duplicate data.
-  # Should we insert duplicate data.
-  # i was thinking maybe if it was existing data but not the most recent data we should re-insert the data
-  # e.g. if the comment was hi, edited to hey, and then changed back to hi.
   defp create_entry_id(source, adapter_meta, cid, n) do
     entry_id = String.slice(cid, 0..n)
     entry_id_query = "SELECT * FROM #{source} where entry_id='#{entry_id}'"
diff --git a/priv/repo/test_app/migrations/20190301105228_create_comments.exs b/priv/repo/test_app/migrations/20190301105228_create_comments.exs
index 503dc0b..002816b 100644
--- a/priv/repo/test_app/migrations/20190301105228_create_comments.exs
+++ b/priv/repo/test_app/migrations/20190301105228_create_comments.exs
@@ -3,8 +3,6 @@ defmodule Alog.Repo.Migrations.CreateComments do
 
   def change do
     create table(:comments, primary_key: false) do
-      # cid & entry_id need to be removed later as they should be handled in execute_ddl I believe
-      # timestamps are needed in alog but may or may not be in the schema.
       add(:cid, :string, primary_key: true)
       add(:entry_id, :string)
       add(:deleted, :boolean, default: false)

From c023e30bf82d1abd83fd5808e4a58a64e4f0e46e Mon Sep 17 00:00:00 2001
From: Robert Francis <robertefrancis18@gmail.com>
Date: Mon, 4 Mar 2019 14:22:08 +0000
Subject: [PATCH 27/35] replace @conn with module name for clarity #45

---
 lib/alog.ex | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/lib/alog.ex b/lib/alog.ex
index 24bb1b8..bdff4b5 100644
--- a/lib/alog.ex
+++ b/lib/alog.ex
@@ -68,7 +68,7 @@ defmodule Alog do
   defp insert_logic(adapter_meta, source, prefix, params, on_conflict, returning, opts) do
     {kind, conflict_params, _} = on_conflict
     {fields, values} = :lists.unzip(params)
-    sql = @conn.insert(prefix, source, fields, [fields], on_conflict, returning)
-    Ecto.Adapters.SQL.struct(adapter_meta, @conn, sql, :insert, source, [], values ++ conflict_params, kind, returning, opts)
+    sql = Alog.Connection.insert(prefix, source, fields, [fields], on_conflict, returning)
+    Ecto.Adapters.SQL.struct(adapter_meta, Alog.Connection, sql, :insert, source, [], values ++ conflict_params, kind, returning, opts)
   end
 end

From 8c6d232a67d88b528865a03e68d0f1251fb6b5de Mon Sep 17 00:00:00 2001
From: SimonLab <simon.labondance@gmail.com>
Date: Wed, 6 Mar 2019 08:21:51 +0000
Subject: [PATCH 28/35] add "distinct on" in query, #40

---
 lib/alog/connection.ex | 45 +++++++++++++++++++++++++++++++++++++++++-
 1 file changed, 44 insertions(+), 1 deletion(-)

diff --git a/lib/alog/connection.ex b/lib/alog/connection.ex
index 496faa0..59b4209 100644
--- a/lib/alog/connection.ex
+++ b/lib/alog/connection.ex
@@ -27,7 +27,50 @@ defmodule Alog.Connection do
   defdelegate to_constraints(error_struct), to: EAPC
 
   @impl true
-  defdelegate all(query), to: EAPC
+  def all(query) do
+    iodata_query =  EAPC.all(query)
+
+    # sub =
+    #   from(m in __MODULE__,
+    #     distinct: m.entry_id,
+    #     order_by: [desc: :updated_at],
+    #     select: m
+    #   )
+    #
+    # query = from(m in subquery(sub), where: not m.deleted, select: m)
+
+
+# SELECT
+#   s0."id",
+#   s0."name",
+#   s0."entry_id",
+#   s0."deleted",
+#   s0."inserted_at",
+#   s0."updated_at"
+# FROM
+#   (SELECT DISTINCT ON (d0."entry_id")
+#       d0."id" AS "id"
+#     , d0."name" AS "name"
+#     , d0."entry_id" AS "entry_id"
+#     , d0."deleted" AS "deleted"
+#     , d0."inserted_at" AS "inserted_at"
+#     , d0."updated_at" AS "updated_at"
+#   FROM "drink_types" AS d0
+#   ORDER BY d0."entry_id", d0."updated_at" DESC)
+# AS s0 WHERE (NOT (s0."deleted"))
+
+
+    query = iodata_query
+    |> IO.iodata_to_binary()
+    |> distinct_entry_id()
+
+    IO.inspect query
+    query
+  end
+
+  defp distinct_entry_id("SELECT " <> query) do
+    IO.iodata_to_binary(["SELECT ", "DISTINCT ON (\"entry_id\" ) ", query])
+  end
 
   @impl true
   defdelegate update_all(query, prefix \\ nil), to: EAPC

From c934649b91b81a47b7cfe95b79d73cc208c0044c Mon Sep 17 00:00:00 2001
From: SimonLab <simon.labondance@gmail.com>
Date: Wed, 6 Mar 2019 13:09:54 +0000
Subject: [PATCH 29/35] use regex instead of String.split to match query terms,
 https://github.com/dwyl/alog/issues/40#issuecomment-470015373

---
 config/test.exs        |  4 ++--
 lib/alog/connection.ex | 25 +++++++++++++++++++++++--
 2 files changed, 25 insertions(+), 4 deletions(-)

diff --git a/config/test.exs b/config/test.exs
index cead70a..47d1f1b 100644
--- a/config/test.exs
+++ b/config/test.exs
@@ -2,8 +2,8 @@ use Mix.Config
 
 config :alog, Alog.Repo,
   username: "postgres",
-  password: "postgres",
-  database: "test_app_dev",
+  password: "docker",
+  database: "routinedb",
   hostname: "localhost",
   pool: Ecto.Adapters.SQL.Sandbox,
   priv: "priv/repo/test_app/"
diff --git a/lib/alog/connection.ex b/lib/alog/connection.ex
index 59b4209..167008f 100644
--- a/lib/alog/connection.ex
+++ b/lib/alog/connection.ex
@@ -68,8 +68,29 @@ defmodule Alog.Connection do
     query
   end
 
-  defp distinct_entry_id("SELECT " <> query) do
-    IO.iodata_to_binary(["SELECT ", "DISTINCT ON (\"entry_id\" ) ", query])
+  # defp distinct_entry_id("SELECT " <> fields <> " FROM " <> table_name <> " AS " <> table_as <> " " <> rest_query) do
+  #
+  #   IO.iodata_to_binary(["SELECT ", "DISTINCT ON (#{table_as}\".entry_id\" ) ", query])
+  # end
+
+  defp distinct_entry_id(query) do
+    query_data = get_query_data(query)
+    if (query_data["table_name"] == "\"schema_migrations\"") do
+      query
+    else
+      IO.iodata_to_binary(
+      [ "SELECT DISTINCT ON (#{query_data["table_as"]}.\"entry_id\" ) ",
+        query_data["fields"],
+        " FROM ",
+        query_data["table_name"], " AS ", query_data["table_as"],
+        query_data["rest_query"]
+    ]
+    )
+    end
+  end
+
+  defp get_query_data(query) do
+    Regex.named_captures(~r/(\bSELECT\b)\s(?<fields>.*)\sFROM\s(?<table_name>.*)\sas\s(?<table_as>.*)(?<rest_query>.*)/i, query)
   end
 
   @impl true

From 0eb4ce577cba06ab537c25bb47c5736fb036da37 Mon Sep 17 00:00:00 2001
From: SimonLab <simon.labondance@gmail.com>
Date: Wed, 6 Mar 2019 13:26:11 +0000
Subject: [PATCH 30/35] order by result by entry_id and inserted_at, #40

---
 config/test.exs        | 4 ++--
 lib/alog/connection.ex | 3 ++-
 2 files changed, 4 insertions(+), 3 deletions(-)

diff --git a/config/test.exs b/config/test.exs
index 47d1f1b..cead70a 100644
--- a/config/test.exs
+++ b/config/test.exs
@@ -2,8 +2,8 @@ use Mix.Config
 
 config :alog, Alog.Repo,
   username: "postgres",
-  password: "docker",
-  database: "routinedb",
+  password: "postgres",
+  database: "test_app_dev",
   hostname: "localhost",
   pool: Ecto.Adapters.SQL.Sandbox,
   priv: "priv/repo/test_app/"
diff --git a/lib/alog/connection.ex b/lib/alog/connection.ex
index 167008f..d711174 100644
--- a/lib/alog/connection.ex
+++ b/lib/alog/connection.ex
@@ -83,7 +83,8 @@ defmodule Alog.Connection do
         query_data["fields"],
         " FROM ",
         query_data["table_name"], " AS ", query_data["table_as"],
-        query_data["rest_query"]
+        query_data["rest_query"],
+        " ORDER BY #{query_data["table_as"]}.\"entry_id\", #{query_data["table_as"]}.\"inserted_at\" DESC", 
     ]
     )
     end

From 2c4f4a261eb909916ef217a486e6a8689665a4d6 Mon Sep 17 00:00:00 2001
From: SimonLab <simon.labondance@gmail.com>
Date: Wed, 6 Mar 2019 15:01:47 +0000
Subject: [PATCH 31/35] create subquery for all function, #40

---
 lib/alog/connection.ex | 70 +++++++++++++++---------------------------
 1 file changed, 25 insertions(+), 45 deletions(-)

diff --git a/lib/alog/connection.ex b/lib/alog/connection.ex
index d711174..c68e751 100644
--- a/lib/alog/connection.ex
+++ b/lib/alog/connection.ex
@@ -30,68 +30,48 @@ defmodule Alog.Connection do
   def all(query) do
     iodata_query =  EAPC.all(query)
 
-    # sub =
-    #   from(m in __MODULE__,
-    #     distinct: m.entry_id,
-    #     order_by: [desc: :updated_at],
-    #     select: m
-    #   )
-    #
-    # query = from(m in subquery(sub), where: not m.deleted, select: m)
-
-
-# SELECT
-#   s0."id",
-#   s0."name",
-#   s0."entry_id",
-#   s0."deleted",
-#   s0."inserted_at",
-#   s0."updated_at"
-# FROM
-#   (SELECT DISTINCT ON (d0."entry_id")
-#       d0."id" AS "id"
-#     , d0."name" AS "name"
-#     , d0."entry_id" AS "entry_id"
-#     , d0."deleted" AS "deleted"
-#     , d0."inserted_at" AS "inserted_at"
-#     , d0."updated_at" AS "updated_at"
-#   FROM "drink_types" AS d0
-#   ORDER BY d0."entry_id", d0."updated_at" DESC)
-# AS s0 WHERE (NOT (s0."deleted"))
-
-
     query = iodata_query
     |> IO.iodata_to_binary()
     |> distinct_entry_id()
 
-    IO.inspect query
     query
   end
 
-  # defp distinct_entry_id("SELECT " <> fields <> " FROM " <> table_name <> " AS " <> table_as <> " " <> rest_query) do
-  #
-  #   IO.iodata_to_binary(["SELECT ", "DISTINCT ON (#{table_as}\".entry_id\" ) ", query])
-  # end
-
   defp distinct_entry_id(query) do
     query_data = get_query_data(query)
     if (query_data["table_name"] == "\"schema_migrations\"") do
       query
     else
+      subquery = IO.iodata_to_binary(
+                  [ "SELECT DISTINCT ON (#{query_data["table_as"]}.\"entry_id\" ) ",
+                    query_data["subquery_fields"], ", #{query_data["table_as"]}.\"deleted\" AS \"delted\"",
+                    " FROM ",
+                    query_data["table_name"], " AS ", query_data["table_as"],
+                    query_data["rest_query"],
+                    " ORDER BY #{query_data["table_as"]}.\"entry_id\", #{query_data["table_as"]}.\"inserted_at\" DESC"
+                ]
+              )
+
       IO.iodata_to_binary(
-      [ "SELECT DISTINCT ON (#{query_data["table_as"]}.\"entry_id\" ) ",
-        query_data["fields"],
-        " FROM ",
-        query_data["table_name"], " AS ", query_data["table_as"],
-        query_data["rest_query"],
-        " ORDER BY #{query_data["table_as"]}.\"entry_id\", #{query_data["table_as"]}.\"inserted_at\" DESC", 
-    ]
-    )
+        ["SELECT ", query_data["field_names"], " FROM (", subquery, ") AS alogsubquery WHERE (NOT alogsubquery.\"deleted\")"]
+      )
+
     end
   end
 
   defp get_query_data(query) do
-    Regex.named_captures(~r/(\bSELECT\b)\s(?<fields>.*)\sFROM\s(?<table_name>.*)\sas\s(?<table_as>.*)(?<rest_query>.*)/i, query)
+    data = Regex.named_captures(~r/(\bSELECT\b)\s(?<fields>.*)\sFROM\s(?<table_name>.*)\sas\s(?<table_as>.*)(?<rest_query>.*)/i, query)
+    data = Map.put(data, "field_names", Regex.replace(~r/#{data["table_as"]}/, data["fields"], "alogsubquery"))
+
+    subquery_fields = data["fields"]
+      |> String.split(",")
+      |> Enum.map(fn f ->
+        field_name = Regex.replace(~r/#{data["table_as"]}./, f, "")
+        f <> " AS #{field_name}"
+      end)
+      |> Enum.join(", ")
+
+    Map.put(data, "subquery_fields", subquery_fields)
   end
 
   @impl true

From abf0f46d100093c9601311bc456211e438c61a45 Mon Sep 17 00:00:00 2001
From: Simon <simon+github@dwyl.com>
Date: Mon, 11 Mar 2019 14:35:06 +0000
Subject: [PATCH 32/35] Update lib/alog/connection.ex

---
 lib/alog/connection.ex | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/lib/alog/connection.ex b/lib/alog/connection.ex
index c68e751..14e3bf6 100644
--- a/lib/alog/connection.ex
+++ b/lib/alog/connection.ex
@@ -44,7 +44,7 @@ defmodule Alog.Connection do
     else
       subquery = IO.iodata_to_binary(
                   [ "SELECT DISTINCT ON (#{query_data["table_as"]}.\"entry_id\" ) ",
-                    query_data["subquery_fields"], ", #{query_data["table_as"]}.\"deleted\" AS \"delted\"",
+                    query_data["subquery_fields"], ", #{query_data["table_as"]}.\"deleted\" AS \"deleted\"",
                     " FROM ",
                     query_data["table_name"], " AS ", query_data["table_as"],
                     query_data["rest_query"],

From 53c92d15ecf6c49879254536c5d9c3070e1e19c2 Mon Sep 17 00:00:00 2001
From: SimonLab <simon.labondance@gmail.com>
Date: Tue, 12 Mar 2019 09:24:36 +0000
Subject: [PATCH 33/35] check deleted field is necessary on subquery, #40

---
 lib/alog/connection.ex | 19 +++++++++++++++----
 1 file changed, 15 insertions(+), 4 deletions(-)

diff --git a/lib/alog/connection.ex b/lib/alog/connection.ex
index 14e3bf6..7e9e81e 100644
--- a/lib/alog/connection.ex
+++ b/lib/alog/connection.ex
@@ -32,19 +32,23 @@ defmodule Alog.Connection do
 
     query = iodata_query
     |> IO.iodata_to_binary()
-    |> distinct_entry_id()
+    |> alogify_all_query()
 
     query
   end
 
-  defp distinct_entry_id(query) do
+  defp alogify_all_query(query) do
     query_data = get_query_data(query)
+    # if all query is called during migration, some column used in the
+    # alogify version might not be yet defined.
+    # Return the "normal" query
     if (query_data["table_name"] == "\"schema_migrations\"") do
       query
     else
       subquery = IO.iodata_to_binary(
                   [ "SELECT DISTINCT ON (#{query_data["table_as"]}.\"entry_id\" ) ",
-                    query_data["subquery_fields"], ", #{query_data["table_as"]}.\"deleted\" AS \"deleted\"",
+                    query_data["subquery_fields"],
+                    get_deleted_field(query_data),
                     " FROM ",
                     query_data["table_name"], " AS ", query_data["table_as"],
                     query_data["rest_query"],
@@ -55,7 +59,6 @@ defmodule Alog.Connection do
       IO.iodata_to_binary(
         ["SELECT ", query_data["field_names"], " FROM (", subquery, ") AS alogsubquery WHERE (NOT alogsubquery.\"deleted\")"]
       )
-
     end
   end
 
@@ -74,6 +77,14 @@ defmodule Alog.Connection do
     Map.put(data, "subquery_fields", subquery_fields)
   end
 
+  defp get_deleted_field(query_data) do
+    if String.contains?(query_data["subquery_fields"], "#{query_data["table_as"]}.\"deleted\"") do
+      ""
+    else
+      ", #{query_data["table_as"]}.\"deleted\" AS \"deleted\""
+    end
+  end
+
   @impl true
   defdelegate update_all(query, prefix \\ nil), to: EAPC
 

From d9eb8b91be9481bb18fb0919ebcc5bc2c3549883 Mon Sep 17 00:00:00 2001
From: SimonLab <simon.labondance@gmail.com>
Date: Tue, 12 Mar 2019 10:05:35 +0000
Subject: [PATCH 34/35] add test for all, #40

---
 test/all_test.exs | 37 ++++++++++---------------------------
 1 file changed, 10 insertions(+), 27 deletions(-)

diff --git a/test/all_test.exs b/test/all_test.exs
index 1184943..cb8c043 100644
--- a/test/all_test.exs
+++ b/test/all_test.exs
@@ -1,31 +1,14 @@
 defmodule AlogTest.AllTest do
   use Alog.TestApp.DataCase
 
-  # alias Alog.TestApp.{User, Helpers}
-  #
-  # describe "all/0:" do
-  #   test "succeeds" do
-  #     {:ok, _} = %User{} |> User.changeset(Helpers.user_1_params()) |> User.insert()
-  #     {:ok, _} = %User{} |> User.changeset(Helpers.user_2_params()) |> User.insert()
-  #
-  #     assert length(User.all()) == 2
-  #   end
-  #
-  #   test "does not include old items" do
-  #     {:ok, user} = %User{} |> User.changeset(Helpers.user_1_params()) |> User.insert()
-  #     {:ok, _} = %User{} |> User.changeset(Helpers.user_2_params()) |> User.insert()
-  #     {:ok, _} = user |> User.changeset(%{postcode: "W2 3EC"}) |> User.update()
-  #
-  #     assert length(User.all()) == 2
-  #   end
-  #
-  #   test "all return inserted_at original value" do
-  #     {:ok, user} = %User{} |> User.changeset(Helpers.user_3_params()) |> User.insert()
-  #     {:ok, user_updated} = user |> User.changeset(%{postcode: "W2 3EC"}) |> User.update()
-  #
-  #     [user_all] = User.all()
-  #     assert user_all.inserted_at == user.inserted_at
-  #     assert user_all.postcode == user_updated.postcode
-  #   end
-  # end
+  alias Alog.TestApp.{Comment}
+
+  describe "all/0:" do
+    test "succeeds" do
+      {:ok, _comment} = %Comment{comment: "Hello Rob"}  |> Repo.insert()
+      {:ok, _} = %Comment{comment: "Hello Dan"} |> Repo.insert()
+
+      assert length(Repo.all(Comment)) == 2
+    end
+  end
 end

From db5378c8540c927bdeffc2e0e64d2db50e08516e Mon Sep 17 00:00:00 2001
From: Danielwhyte <danwhy@gmail.com>
Date: Tue, 12 Mar 2019 15:45:01 +0000
Subject: [PATCH 35/35] adds documentation

---
 README.md               |  59 +++----------
 test/migration_test.exs | 179 ----------------------------------------
 2 files changed, 13 insertions(+), 225 deletions(-)
 delete mode 100644 test/migration_test.exs

diff --git a/README.md b/README.md
index 4ef930a..0d99952 100644
--- a/README.md
+++ b/README.md
@@ -1,59 +1,26 @@
 # alog
 alog (Append-only Log) is an easy way to start using the Lambda/Kappa architecture in your Elixir/Phoenix Apps while still using PostgreSQL (with Ecto).
 
-This module provides some helper functions to make it easy to insert and retrieve the data you need.
+This module is an Ecto Adapter that extends the default Postgres adapter with functionality to ensure data is only ever appended, never deleted or edited.
 
 ## Usage
 
-  At the top of the schema you wish to use append only functions for, `use` this module:
+ In your Repo module, when defining your Ecto Repo, set the adapter to be this module, Alog
 
-  ``` elixir
-  use Alog
-  ```
-
-  The append only functions will then be available to call as part of your schema.
-
-  ## Example
-
-  ``` elixir
-  defmodule MyApp.User do
-    use Ecto.Schema
-    use Alog
-
-    import Ecto.Changeset
-
-    schema "users" do
-      ...
-    end
-
-    def changeset(user, attrs) do
-      ...
-    end
+ ``` elixir
+  defmodule MyApp.Repo do
+    use Ecto.Repo,
+      otp_app: :my_app,
+      adapter: Alog
   end
-  ```
-
-  ## Repo
-
-  You can set the repo you want Alog to use in a config file:
-
-  ``` elixir
- config :alog, Alog,
-    repo: MyApp.Repo
-  ```
-  
-  If you do not explicitly set a Repo, Alog will try to find it using your application name.
-  So if your app is `MyApp` and your schema is `MyApp.User`, or `MyApp.Accounts.User`, your Repo should be `MyApp.Repo`.
-
-  ## Uniqueness
+ ```
 
-  Due to the append only manner in which Alog stores data, it is not compatible with tables that have Unique Indexes applied to any of their columns. If you wish to use alog, you will have to remove these indexes.
+## Considerations
 
-  For example, the following in a migration file would remove a unique index on the `email` column from the `users` table.
+- When inserting or updating an item, the return value of the insert/update function is currently incorrect. The updates and inserts are however done correctly, as you will see if you get all items from the database using `Repo.all`.
 
-  ```
-  drop(unique_index(:users, :email))
-  ```
+- We exclude the `schema_migrations` file from all alog functions, instead forwarding them on to the original Postgres Adapter.
 
-  See https://hexdocs.pm/ecto_sql/Ecto.Migration.html#content for more details.
+- The autogenerated cid is used as the primary key. There is no way currently to define a custom primary key.
 
-  If you want to ensure each entry in your database has a unique field, you can use the [`Ecto.Changeset.unique_constraint/3`](https://hexdocs.pm/ecto/Ecto.Changeset.html#unique_constraint/3) function as normal, and Alog will ensure there are no repeated fields, other than those of the same entry, returning an invalid changeset if there are.
\ No newline at end of file
+Hopefully these issues can later be resolved by looking at defining/extending our own version of the the `Ecto.Schema` macro.
\ No newline at end of file
diff --git a/test/migration_test.exs b/test/migration_test.exs
deleted file mode 100644
index 71e9962..0000000
--- a/test/migration_test.exs
+++ /dev/null
@@ -1,179 +0,0 @@
-defmodule AlogTest.MigrationTest do
-  use ExUnit.Case, async: true
-
-  alias Alog.Repo
-
-  # Avoid migration out of order warnings
-  @moduletag :capture_log
-  @base_migration 3_000_000
-
-  setup do
-    {:ok, migration_number: System.unique_integer([:positive]) + @base_migration}
-  end
-
-  defmodule AddColumnIfNotExistsMigration do
-    use Ecto.Migration
-
-    def up do
-      create(table(:add_col_if_not_exists_migration, primary_key: false))
-
-      alter table(:add_col_if_not_exists_migration) do
-        add_if_not_exists(:value, :integer)
-        add_if_not_exists(:to_be_added, :integer)
-      end
-
-      execute(
-        "INSERT INTO add_col_if_not_exists_migration (value, to_be_added, cid, entry_id, inserted_at, updated_at) VALUES (1, 2, 'a', 'a', '2019-02-10 10:04:30', '2019-02-10 10:04:30')"
-      )
-    end
-
-    def down do
-      drop(table(:add_col_if_not_exists_migration))
-    end
-  end
-
-  defmodule DropColumnIfExistsMigration do
-    use Ecto.Migration
-
-    def up do
-      create table(:drop_col_if_exists_migration, primary_key: false) do
-        add(:value, :integer)
-        add(:to_be_removed, :integer)
-      end
-
-      execute(
-        "INSERT INTO drop_col_if_exists_migration (value, to_be_removed, cid, entry_id, inserted_at, updated_at) VALUES (1, 2, 'a', 'a', '2019-02-10 10:04:30', '2019-02-10 10:04:30')"
-      )
-
-      alter table(:drop_col_if_exists_migration) do
-        remove_if_exists(:to_be_removed, :integer)
-      end
-    end
-
-    def down do
-      drop(table(:drop_col_if_exists_migration))
-    end
-  end
-
-  defmodule DuplicateTableMigration do
-    use Ecto.Migration
-
-    def change do
-      create_if_not_exists(table(:duplicate_table, primary_key: false))
-      create_if_not_exists(table(:duplicate_table, primary_key: false))
-    end
-  end
-
-  defmodule NoErrorOnConditionalColumnMigration do
-    use Ecto.Migration
-
-    def up do
-      create(table(:no_error_on_conditional_column_migration, primary_key: false))
-
-      alter table(:no_error_on_conditional_column_migration) do
-        add_if_not_exists(:value, :integer)
-        add_if_not_exists(:value, :integer)
-
-        remove_if_exists(:value, :integer)
-        remove_if_exists(:value, :integer)
-      end
-    end
-
-    def down do
-      drop(table(:no_error_on_conditional_column_migration))
-    end
-  end
-
-  defmodule DefaultMigration do
-    use Ecto.Migration
-
-    def up do
-      create table(:default_migration, primary_key: false) do
-        add(:name, :string)
-      end
-
-      execute(
-        "INSERT INTO default_migration (name, cid, entry_id, inserted_at, updated_at) VALUES ('a', 'b', 'a', '2019-02-10 10:04:30', '2019-02-10 10:04:30')"
-      )
-    end
-
-    def down do
-      drop(table(:default_migration))
-    end
-  end
-
-  defmodule ExistingDefaultMigration do
-    use Ecto.Migration
-
-    def change do
-      create table(:existing_default_migration, primary_key: false) do
-        timestamps()
-      end
-    end
-  end
-
-  import Ecto.Query, only: [from: 2]
-  import Ecto.Migrator, only: [up: 4, down: 4]
-
-  test "logs Postgres notice messages" do
-    log =
-      ExUnit.CaptureLog.capture_log(fn ->
-        num = @base_migration + System.unique_integer([:positive])
-        up(Repo, num, DuplicateTableMigration, log: false)
-      end)
-
-    assert log =~ ~s(relation "duplicate_table" already exists, skipping)
-  end
-
-  @tag :no_error_on_conditional_column_migration
-  test "add if not exists and drop if exists does not raise on failure", %{migration_number: num} do
-    assert :ok == up(Repo, num, NoErrorOnConditionalColumnMigration, log: false)
-    assert :ok == down(Repo, num, NoErrorOnConditionalColumnMigration, log: false)
-  end
-
-  @tag :add_column_if_not_exists
-  test "add column if not exists", %{migration_number: num} do
-    assert :ok == up(Repo, num, AddColumnIfNotExistsMigration, log: false)
-
-    assert [2] == Repo.all(from(p in "add_col_if_not_exists_migration", select: p.to_be_added))
-
-    :ok = down(Repo, num, AddColumnIfNotExistsMigration, log: false)
-  end
-
-  @tag :remove_column_if_exists
-  test "remove column when exists", %{migration_number: num} do
-    assert :ok == up(Repo, num, DropColumnIfExistsMigration, log: false)
-
-    assert catch_error(
-             Repo.all(from(p in "drop_col_if_exists_migration", select: p.to_be_removed))
-           )
-
-    :ok = down(Repo, num, DropColumnIfExistsMigration, log: false)
-  end
-
-  test "creates default columns", %{migration_number: num} do
-    assert :ok == up(Repo, num, DefaultMigration, log: false)
-
-    assert [%{name: _, cid: _, entry_id: _, inserted_at: _, updated_at: _, deleted: false}] =
-             Repo.all(
-               from(a in "default_migration",
-                 select: %{
-                   name: a.name,
-                   cid: a.cid,
-                   entry_id: a.entry_id,
-                   inserted_at: a.inserted_at,
-                   updated_at: a.updated_at,
-                   deleted: a.deleted
-                 }
-               )
-             )
-
-    :ok = down(Repo, num, DefaultMigration, log: false)
-  end
-
-  test "existing default columns don't throw errors", %{migration_number: num} do
-    assert :ok == up(Repo, num, ExistingDefaultMigration, log: false)
-
-    :ok = down(Repo, num, ExistingDefaultMigration, log: false)
-  end
-end