updated documents

Author: zookzook

CHANGELOG.md

@@ -12,8 +12,8 @@
    * Travis now using the right MongoDB version
 
 * Bug Fixes
-   * added test unit for change streams
-   * removed debug code from change streams
+   * Added test unit for change streams
+   * Removed debug code from change streams
 
 ## v0.5.2
 

lib/mongo.ex

@@ -967,7 +967,7 @@ defmodule Mongo do
     def select_server(topology_pid, type, opts \\ []) do
     with {:ok, servers, slave_ok, mongos?} <- select_servers(topology_pid, type, opts) do
       if Enum.empty? servers do
-        {:ok, nil, slave_ok, mongos?}  # todo: warum wird [] zurückgeliefert?, nil wäre besser?
+        {:ok, nil, slave_ok, mongos?}
       else
         with {:ok, connection} <- servers |> Enum.take_random(1) |> Enum.at(0)
                                           |> get_connection(topology_pid) do

lib/mongo/bulk_ops.ex

@@ -11,13 +11,16 @@ defmodule Mongo.BulkOps do
   ## Example
 
   ```
-    Filestream!("large.csv")
-    |> Stream.map(&String.trim(&1))
-    |> Stream.map(&String.split(&1,","))
-    |> Stream.map(fn [firstname | [lastname | _]] -> %{firstname: firstname, lastname: lastname} end)
-    |> Stream.map(fn doc -> BulkOps.get_insert_one(doc) end)
-    |> UnorderedBulk.write(:mongo, "bulk", 1_000)
-    |> Stream.run()
+  alias Mongo.UnorderedBulk
+  alias Mongo.BulkOps
+
+  Filestream!("large.csv")
+  |> Stream.map(&String.trim(&1))
+  |> Stream.map(&String.split(&1,","))
+  |> Stream.map(fn [firstname | [lastname | _]] -> %{firstname: firstname, lastname: lastname} end)
+  |> Stream.map(fn doc -> BulkOps.get_insert_one(doc) end)
+  |> UnorderedBulk.write(:mongo, "bulk", 1_000)
+  |> Stream.run()
   ```
 
   """

lib/mongo/bulk_write.ex

@@ -20,7 +20,6 @@ defmodule Mongo.BulkWrite do
   2. updates
   3. deletes
 
-
   ## Example:
 
   ```
@@ -68,19 +67,19 @@ defmodule Mongo.BulkWrite do
 
   ## Stream bulk writes
 
-  The examples shown initially filled the bulk with a few operations and then the bulk was written to the database.
+  The examples shown initially filled the bulk with a few operations and then the bulk is written to the database.
   This is all done in memory. For larger amounts of operations or imports of very long files, the main memory would
   be unnecessarily burdened. It could come to some resource problems.
 
-  For such cases you could use streams. Unordered and ordered bulk writes can also be combined with Stream.
+  For such cases you could use streams. Unordered and ordered bulk writes can also be combined with Streams.
   You set the maximum size of the bulk. Once the number of bulk operations has been reached,
   it will be sent to the database. While streaming you can limit the memory consumption regarding the current task.
 
   In the following example we import 1.000.000 integers into the MongoDB using the stream api:
 
   We need to create an insert operation (`BulkOps.get_insert_one()`) for each number. Then we call the `UnorderedBulk.stream`
   function to import it. This function returns a stream function which accumulate
-  all inserts operations until the limit `1000` is reached. In this case the operation group is send to
+  all inserts operations until the limit `1000` is reached. In this case the operation group is written to
   MongoDB.
 
   ## Example
@@ -94,7 +93,7 @@ defmodule Mongo.BulkWrite do
 
   ## Benchmark
 
-  The following benchmark compares single `Mongo.insert_one()` calls with stream unordered bulk writes.
+  The following benchmark compares multiple `Mongo.insert_one()` calls with a stream using unordered bulk writes.
   Both tests inserts documents into a replica set with `w: 1`.
 
   ```
@@ -159,7 +158,8 @@ defmodule Mongo.BulkWrite do
   alias Mongo.UnorderedBulk
   alias Mongo.OrderedBulk
 
-  @max_batch_size 100_000
+  @max_batch_size 100_000   ## todo    The maxWriteBatchSize limit of a database, which indicates the maximum number of write operations permitted in a write batch, raises from 1,000 to 100,000.
+
 
   @doc """
   Executes unordered and ordered bulk writes.
@@ -179,14 +179,16 @@ defmodule Mongo.BulkWrite do
   If a group (inserts, updates or deletes) exceeds the limit `maxWriteBatchSize` it will be split into chunks.
   Everything is done in memory, so this use case is limited by memory. A better approach seems to use streaming bulk writes.
   """
-  @spec write(GenServer.server, UnorderedBulk.t, Keyword.t) :: Keyword.t
+  @spec write(GenServer.server, (UnorderedBulk.t | OrderedBulk.t), Keyword.t) :: Keyword.t
   def write(topology_pid, %UnorderedBulk{} = bulk, opts) do
 
     write_concern = write_concern(opts)
     with {:ok, conn, _, _} <- Mongo.select_server(topology_pid, :write, opts) do
       one_bulk_write(conn, bulk, write_concern, opts)
     end
+
   end
+
   def write(topology_pid, %OrderedBulk{coll: coll, ops: ops}, opts) do
 
     write_concern = write_concern(opts)
@@ -253,13 +255,13 @@ defmodule Mongo.BulkWrite do
   #
   # The function returns a keyword list with the results of each operation group:
   # For the details see https://github.com/mongodb/specifications/blob/master/source/crud/crud.rst#results
+  #
   defp one_bulk_write(conn, %UnorderedBulk{coll: coll, inserts: inserts, updates: updates, deletes: deletes}, write_concern, opts) do
 
     with {_, {inserts, ids}}                           <- one_bulk_write_operation(conn, :insert, coll, inserts, write_concern, opts),
          {_, {matched, modified, upserts, upsert_ids}} <- one_bulk_write_operation(conn, :update, coll, updates, write_concern, opts),
          {_, deletes}                                  <- one_bulk_write_operation(conn, :delete, coll, deletes, write_concern, opts) do
 
-
       %{
         acknowledged: acknowledged(write_concern),
         insertedCount: inserts,
@@ -302,9 +304,11 @@ defmodule Mongo.BulkWrite do
   end
   defp get_op_sequence(_coll, [], acc), do: acc
   defp get_op_sequence(coll, ops, acc) do
+
     [{kind, _doc} | _rest] = ops
     {docs, rest} = find_max_sequence(kind, ops)
     get_op_sequence(coll, rest, [{kind, docs} | acc])
+
   end
 
   ###
@@ -325,9 +329,6 @@ defmodule Mongo.BulkWrite do
     {acc, rest}
   end
 
-  defp filter_upsert_ids(nil), do: []
-  defp filter_upsert_ids(upserted), do: Enum.map(upserted, fn doc -> doc["_id"] end)
-
   ##
   # collects the returns values for each operation
   #
@@ -367,6 +368,10 @@ defmodule Mongo.BulkWrite do
 
   end
 
+  defp filter_upsert_ids(nil), do: []
+  defp filter_upsert_ids(upserted), do: Enum.map(upserted, fn doc -> doc["_id"] end)
+
+
   defp run_commands(conn, {cmds, ids}, opts) do
     {Enum.map(cmds, fn cmd -> Mongo.direct_command(conn, cmd, opts) end), ids}
   end
@@ -449,5 +454,4 @@ defmodule Mongo.BulkWrite do
 
   end
 
-
 end