updated documentation

Author: zookzook

CHANGELOG.md

@@ -1,5 +1,11 @@
 ## v0.5.4
 
+* Enhancements
+   * Added support for bulk writes (ordered/unordered)
+   * Added support for op_msg with payload type 1 
+
+## v0.5.4
+
 * Enhancements
    * The driver provides now client metadata 
    * Added support for connecting via UNIX sockets (`:socket` and `:socket_dir`)

README.md

@@ -235,17 +235,17 @@ result = Mongo.BulkWrite.bulk_write(:mongo, bulk, w: 1)
 
 In the following example we import 1.000.000 integers into the MongoDB using the stream api:
 
-We need to create an insert operation for each number. Then we call the `ongo.UnorderedBulk.stream`
+We need to create an insert operation for each number. Then we call the `Mongo.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
 MongoDB. So using the stream api you can reduce the memory using while 
 importing big volume of data.
 
 ```elixir
-stream = 1..1_000_000 
-    |> Stream.map(fn i -> Mongo.BulkUtils.get_insert_one(%{number: i}) end) 
-    |> Mongo.UnorderedBulk.stream(top, "bulk", 1_000)
-    |> Stream.run()
+1..1_000_000 
+|> Stream.map(fn i -> Mongo.BulkOps.get_insert_one(%{number: i}) end) 
+|> Mongo.UnorderedBulk.write(:mongo, "bulk", 1_000)
+|> Stream.run()
 ```
 ### Examples
 

lib/mongo/bulk_ops.ex

@@ -0,0 +1,92 @@
+defmodule Mongo.BulkOps do
+  @moduledoc """
+
+  This module defines bulk operation for insert, update and delete. A bulk operation is a tupel of two elements
+
+  1. an atom, which specify the type `:insert`, `:update` and `:delete`
+  2. a document or another tupel which contains all parameters of the operation.
+
+  You use these function in streams:
+
+  ## 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()
+  ```
+
+  """
+
+  @type bulk_op :: {atom, BSON.document} |
+                   {atom, {BSON.document, Keyword.t}} |
+                   {atom, {BSON.document, BSON.document, Keyword.t}}
+
+  import Mongo.Utils
+
+  @doc """
+  Returns an `insert_one` operation tupel for appending to a bulk. Used to perform stream bulk writes.
+
+  ## Example
+  ```
+  BulkOps.get_insert_one(%{name: "Waldo"})
+
+  {:insert, %{name: "Waldo"}}
+  ```
+  """
+  @spec get_insert_one(BSON.document) :: bulk_op
+  def get_insert_one(doc), do: {:insert, doc}
+
+  @doc """
+  Returns an `delete_one` operation tupel for appending to a bulk. Used to perform stream bulk writes.
+
+  ## Example
+
+  ```
+  BulkOps.get_delete_one(%{name: "Waldo"})
+
+  {:delete, {%{name: "Waldo"}, [limit: 1]}}
+  ```
+  """
+  @spec get_delete_one(BSON.document, Keyword.t) :: bulk_op
+  def get_delete_one(doc, opts \\ []), do: {:delete, {doc, Keyword.put(opts, :limit, 1)}}
+
+
+  @doc """
+  Returns an `delete_many` operation for appending to a bulk. Used to perform stream bulk writes.
+  """
+  @spec get_delete_many(BSON.document, Keyword.t) :: bulk_op
+  def get_delete_many(doc, opts \\ []), do: {:delete, {doc, Keyword.put(opts, :limit, 0)}}
+
+  @doc """
+  Returns an `update_one` operation for appending to a bulk. Used to perform stream bulk writes.
+  """
+  @spec get_update_one(BSON.document, BSON.document, Keyword.t) :: bulk_op
+  def get_update_one(filter, update, opts \\ []) do
+    _ = modifier_docs(update, :update)
+    {:update, {filter, update, Keyword.put(opts, :multi, false)}}
+  end
+
+  @doc """
+  Returns an `update_many` operation for appending to a bulk. Used to perform stream bulk writes.
+  """
+  @spec get_update_many(BSON.document, BSON.document, Keyword.t) :: bulk_op
+  def get_update_many(filter, update, opts \\ []) do
+    _ = modifier_docs(update, :update)
+    {:update, {filter, update, Keyword.put(opts, :multi, true)}}
+  end
+
+  @doc """
+  Returns an `replace_one` operation for appending to a bulk. Used to perform stream bulk writes.
+  """
+  @spec get_replace_one(BSON.document, BSON.document, Keyword.t) :: bulk_op
+  def get_replace_one(filter, replacement, opts \\ []) do
+    _ = modifier_docs(replacement, :replace)
+    {:update, {filter, replacement, Keyword.put(opts, :multi, false)}}
+  end
+
+end