update_one, update_many, replace_one, replace_many now return 'upserted_ids'

Author: zookzook

README.md

@@ -13,12 +13,12 @@ to implement the current requirements for the driver.
 
 ## Motivation
 
-  * Refactoring old code into new
-  * Understand the magic in the code
-  * Simplify code: remove raw_find (raw_find called from cursors, raw_find called with "$cmd"), so raw_find is more calling a command than a find query.
-  * Better support for new MongoDB version, for example the ability to use views
-  * Upgrade to DBConnection 2.x
-  * Because the driver is used in production environments, quick adjustments are necessary.
+  * [ ] Refactoring old code into new
+  * [ ] Understand the magic in the code
+  * [x] Simplify code: remove raw_find (raw_find called from cursors, raw_find called with "$cmd"), so raw_find is more calling a command than a find query.
+  * [x] Better support for new MongoDB version, for example the ability to use views
+  * [x] Upgrade to DBConnection 2.x
+  * [ ] Because the driver is used in production environments, quick adjustments are necessary.
 
 ## Features
 

lib/mongo.ex

@@ -769,25 +769,24 @@ defmodule Mongo do
   @doc """
   Update all documents matching the filter.
 
-  Uses MongoDB update operators to specify the updates. For more information
+  Uses MongoDB update operators to specify the updates. For more information and all options
   please refer to the
-  [MongoDB documentation](http://docs.mongodb.org/manual/reference/operator/update/)
-
-  ## Options
+  [MongoDB documentation](https://docs.mongodb.com/manual/reference/command/update/#dbcmd.update)
 
-    * `:upsert` - if set to `true` creates a new document when no document
-      matches the filter (default: `false`)
   """
   @spec update_many(GenServer.server, collection, BSON.document, BSON.document, Keyword.t) :: result(Mongo.UpdateResult.t)
   def update_many(topology_pid, coll, filter, update, opts \\ []) do
     _ = modifier_docs(update, :update)
     update_documents(topology_pid, coll, filter, update, true, opts)
   end
 
+  ##
+  # Calls the update command:
+  #
+  # see https://docs.mongodb.com/manual/reference/command/update/#update-command-output
+  #
   defp update_documents(topology_pid, coll, filter, update, multi, opts) do
 
-    # see https://docs.mongodb.com/manual/reference/command/update/#update-command-output
-    # validation of the update document
     write_concern = %{
                       w: Keyword.get(opts, :w),
                       j: Keyword.get(opts, :j),
@@ -799,7 +798,7 @@ defmodule Mongo do
                u: update,
                upsert: Keyword.get(opts, :upsert),
                multi: multi,
-               collation: Keyword.get(opts, :ordered),
+               collation: Keyword.get(opts, :collation),
                arrayFilters: Keyword.get(opts, :filters)
              } |> filter_nils()
 
@@ -812,20 +811,33 @@ defmodule Mongo do
             ] |> filter_nils()
 
     with {:ok, conn, _, _} <- select_server(topology_pid, :write, opts),
-         {:ok, doc} <- direct_command(conn, query, opts) do
+         {:ok, doc}        <- direct_command(conn, query, opts) do
+
       case doc do
-        # todo: better handling off the result
+
         %{"writeErrors" => _} -> {:error, %Mongo.WriteError{n: doc["n"], ok: doc["ok"], write_errors: doc["writeErrors"]}}
+
+        %{"n" => n, "nModified" => n_modified, "upserted" => upserted} ->
+          case Map.get(write_concern, :w) do
+            0 -> {:ok, %Mongo.UpdateResult{acknowledged: false}}
+            _ -> {:ok, %Mongo.UpdateResult{matched_count: n, modified_count: n_modified, upserted_ids: filter_upsert_ids(upserted)}}
+          end
+
         %{"n" => n, "nModified" => n_modified} ->
           case Map.get(write_concern, :w) do
             0 -> {:ok, %Mongo.UpdateResult{acknowledged: false}}
             _ -> {:ok, %Mongo.UpdateResult{matched_count: n, modified_count: n_modified}}
           end
-          _ -> {:ok, nil}
+
+        _ -> {:ok, nil}
+
       end
     end
   end
 
+  defp filter_upsert_ids(nil), do: []
+  defp filter_upsert_ids(upserted), do: Enum.map(upserted, fn doc -> doc["_id"] end)
+
   @doc """
   Similar to `update_many/5` but unwraps the result and raises on error.
   """

lib/mongo/results.ex

@@ -50,15 +50,15 @@ defmodule Mongo.UpdateResult do
 
     * `:matched_count` - Number of matched documents
     * `:modified_count` - Number of modified documents
-    * `:upserted_id` - If the operation was an upsert, the upserted id
+    * `:upserted_ids` - If the operation was an upsert, the upserted ids
   """
 
   @type t :: %__MODULE__{
     acknowledged: boolean,
     matched_count: non_neg_integer,
     modified_count: non_neg_integer,
-    upserted_id: nil | BSON.ObjectId.t
+    upserted_ids: list(BSON.ObjectId.t)
   }
 
-  defstruct [acknowledged: true, matched_count: 0, modified_count: 0, upserted_id: 0]
+  defstruct [acknowledged: true, matched_count: 0, modified_count: 0, upserted_ids: []]
 end

test/mongo_test.exs

@@ -449,16 +449,15 @@ defmodule Mongo.Test do
 
     assert {:ok, _} = Mongo.insert_many(c.pid, coll, [%{foo: 42}, %{foo: 42}, %{foo: 43}])
 
-    assert {:ok, %Mongo.UpdateResult{acknowledged: true, matched_count: 1, modified_count: 1, upserted_id: 0}} = Mongo.replace_one(c.pid, coll, %{foo: 42}, %{foo: 0})
+    assert {:ok, %Mongo.UpdateResult{acknowledged: true, matched_count: 1, modified_count: 1, upserted_ids: []}} = Mongo.replace_one(c.pid, coll, %{foo: 42}, %{foo: 0})
 
     assert [_] = Mongo.find(c.pid, coll, %{foo: 0}) |> Enum.to_list
     assert [_] = Mongo.find(c.pid, coll, %{foo: 42}) |> Enum.to_list
 
-    # todo id
-    assert {:ok, %Mongo.UpdateResult{acknowledged: true, matched_count: 1, modified_count: 0, upserted_id: 0}} = Mongo.replace_one(c.pid, coll, %{foo: 50}, %{foo: 0}, upsert: true)
-    # assert [_] = Mongo.find(c.pid, coll, %{_id: id}) |> Enum.to_list
+    assert {:ok, %Mongo.UpdateResult{acknowledged: true, matched_count: 1, modified_count: 0, upserted_ids: [id]}} = Mongo.replace_one(c.pid, coll, %{foo: 50}, %{foo: 0}, upsert: true)
+    assert [_] = Mongo.find(c.pid, coll, %{_id: id}) |> Enum.to_list
 
-    assert {:ok, %Mongo.UpdateResult{acknowledged: true, matched_count: 1, modified_count: 1, upserted_id: 0}} = Mongo.replace_one(c.pid, coll, %{foo: 43}, %{foo: 1}, upsert: true)
+    assert {:ok, %Mongo.UpdateResult{acknowledged: true, matched_count: 1, modified_count: 1, upserted_ids: []}} = Mongo.replace_one(c.pid, coll, %{foo: 43}, %{foo: 1}, upsert: true)
     assert [] = Mongo.find(c.pid, coll, %{foo: 43}) |> Enum.to_list
     assert [_] = Mongo.find(c.pid, coll, %{foo: 1}) |> Enum.to_list
   end
@@ -468,7 +467,7 @@ defmodule Mongo.Test do
 
     assert {:ok, _} = Mongo.insert_many(c.pid, coll, [%{foo: 42}, %{_id: 1}])
 
-    assert %Mongo.UpdateResult{acknowledged: true, matched_count: 0, modified_count: 0, upserted_id: 0} = Mongo.replace_one!(c.pid, coll, %{foo: 43}, %{foo: 0})
+    assert %Mongo.UpdateResult{acknowledged: true, matched_count: 0, modified_count: 0, upserted_ids: []} = Mongo.replace_one!(c.pid, coll, %{foo: 43}, %{foo: 0})
 
     assert nil == Mongo.replace_one!(c.pid, coll, %{foo: 45}, %{foo: 0}, w: 0)
 
@@ -486,16 +485,15 @@ defmodule Mongo.Test do
 
     assert {:ok, _} = Mongo.insert_many(c.pid, coll, [%{foo: 42}, %{foo: 42}, %{foo: 43}])
 
-    assert {:ok, %Mongo.UpdateResult{acknowledged: true, matched_count: 1, modified_count: 1, upserted_id: 0}} =  Mongo.update_one(c.pid, coll, %{foo: 42}, %{"$set": %{foo: 0}})
+    assert {:ok, %Mongo.UpdateResult{acknowledged: true, matched_count: 1, modified_count: 1, upserted_ids: []}} =  Mongo.update_one(c.pid, coll, %{foo: 42}, %{"$set": %{foo: 0}})
 
     assert [_] = Mongo.find(c.pid, coll, %{foo: 0}) |> Enum.to_list
     assert [_] = Mongo.find(c.pid, coll, %{foo: 42}) |> Enum.to_list
 
-    # todo id
-    assert {:ok, %Mongo.UpdateResult{acknowledged: true, matched_count: 1, modified_count: 0, upserted_id: 0}} = Mongo.update_one(c.pid, coll, %{foo: 50}, %{"$set": %{foo: 0}}, upsert: true)
-    # todo assert [_] = Mongo.find(c.pid, coll, %{_id: id}) |> Enum.to_list
+    assert {:ok, %Mongo.UpdateResult{acknowledged: true, matched_count: 1, modified_count: 0, upserted_ids: [id]}} = Mongo.update_one(c.pid, coll, %{foo: 50}, %{"$set": %{foo: 0}}, upsert: true)
+    assert [_] = Mongo.find(c.pid, coll, %{_id: id}) |> Enum.to_list
 
-    assert {:ok, %Mongo.UpdateResult{acknowledged: true, matched_count: 1, modified_count: 1, upserted_id: 0}} = Mongo.update_one(c.pid, coll, %{foo: 43}, %{"$set": %{foo: 1}}, upsert: true)
+    assert {:ok, %Mongo.UpdateResult{acknowledged: true, matched_count: 1, modified_count: 1, upserted_ids: []}} = Mongo.update_one(c.pid, coll, %{foo: 43}, %{"$set": %{foo: 1}}, upsert: true)
     assert [] = Mongo.find(c.pid, coll, %{foo: 43}) |> Enum.to_list
     assert [_] = Mongo.find(c.pid, coll, %{foo: 1}) |> Enum.to_list
   end
@@ -505,7 +503,7 @@ defmodule Mongo.Test do
 
     assert {:ok, _} = Mongo.insert_many(c.pid, coll, [%{foo: 42}, %{_id: 1}])
 
-    assert %Mongo.UpdateResult{acknowledged: true, matched_count: 1, modified_count: 1, upserted_id: 0} = Mongo.update_one!(c.pid, coll, %{foo: 42}, %{"$set": %{foo: 0}})
+    assert %Mongo.UpdateResult{acknowledged: true, matched_count: 1, modified_count: 1, upserted_ids: []} = Mongo.update_one!(c.pid, coll, %{foo: 42}, %{"$set": %{foo: 0}})
 
     assert nil == Mongo.update_one!(c.pid, coll, %{foo: 42}, %{}, w: 0)
 
@@ -517,22 +515,19 @@ defmodule Mongo.Test do
   test "update_many", c do
     coll = unique_name()
 
-    assert_raise ArgumentError, fn ->
-      Mongo.update_many(c.pid, coll, %{foo: 42}, %{foo: 0})
-    end
+    assert_raise ArgumentError, fn -> Mongo.update_many(c.pid, coll, %{foo: 42}, %{foo: 0}) end
 
     assert {:ok, _} = Mongo.insert_many(c.pid, coll, [%{foo: 42}, %{foo: 42}, %{foo: 43}])
 
-    assert {:ok, %Mongo.UpdateResult{acknowledged: true, matched_count: 2, modified_count: 2, upserted_id: 0}} = Mongo.update_many(c.pid, coll, %{foo: 42}, %{"$set": %{foo: 0}})
+    assert {:ok, %Mongo.UpdateResult{acknowledged: true, matched_count: 2, modified_count: 2, upserted_ids: []}} = Mongo.update_many(c.pid, coll, %{foo: 42}, %{"$set": %{foo: 0}})
 
     assert [_, _] = Mongo.find(c.pid, coll, %{foo: 0}) |> Enum.to_list
     assert [] = Mongo.find(c.pid, coll, %{foo: 42}) |> Enum.to_list
 
-    # todo id
-    assert {:ok, %Mongo.UpdateResult{acknowledged: true, matched_count: 1, modified_count: 0, upserted_id: 0}} = Mongo.update_many(c.pid, coll, %{foo: 50}, %{"$set": %{foo: 0}}, upsert: true)
-    # assert [_] = Mongo.find(c.pid, coll, %{_id: id}) |> Enum.to_list
+    assert {:ok, %Mongo.UpdateResult{acknowledged: true, matched_count: 1, modified_count: 0, upserted_ids: [id]}} = Mongo.update_many(c.pid, coll, %{foo: 50}, %{"$set": %{foo: 0}}, upsert: true)
+    assert [_] = Mongo.find(c.pid, coll, %{_id: id}) |> Enum.to_list
 
-    assert {:ok, %Mongo.UpdateResult{acknowledged: true, matched_count: 1, modified_count: 1, upserted_id: 0}} = Mongo.update_many(c.pid, coll, %{foo: 43}, %{"$set": %{foo: 1}}, upsert: true)
+    assert {:ok, %Mongo.UpdateResult{acknowledged: true, matched_count: 1, modified_count: 1, upserted_ids: []}} = Mongo.update_many(c.pid, coll, %{foo: 43}, %{"$set": %{foo: 1}}, upsert: true)
     assert [] = Mongo.find(c.pid, coll, %{foo: 43}) |> Enum.to_list
     assert [_] = Mongo.find(c.pid, coll, %{foo: 1}) |> Enum.to_list
   end
@@ -542,7 +537,7 @@ defmodule Mongo.Test do
 
     assert {:ok, _} = Mongo.insert_many(c.pid, coll, [%{foo: 42}, %{foo: 42}, %{_id: 1}])
 
-    assert %Mongo.UpdateResult{acknowledged: true, matched_count: 2, modified_count: 2, upserted_id: 0} = Mongo.update_many!(c.pid, coll, %{foo: 42}, %{"$set": %{foo: 0}})
+    assert %Mongo.UpdateResult{acknowledged: true, matched_count: 2, modified_count: 2, upserted_ids: []} = Mongo.update_many!(c.pid, coll, %{foo: 42}, %{"$set": %{foo: 0}})
 
     assert nil == Mongo.update_many!(c.pid, coll, %{foo: 0}, %{}, w: 0)