DOCSP-47041: Causal consistency

source/crud/transactions.txt

@@ -28,14 +28,10 @@ error, the driver cancels the transaction and discards all data changes
 before they ever become visible.
 
 In MongoDB, transactions run within logical **sessions**. A
-:manual:`session </reference/server-sessions/>` is a grouping of related
-read or write operations that you intend to run sequentially. Sessions
-enable :manual:`causal consistency
-</core/read-isolation-consistency-recency/#causal-consistency>` for a
-group of operations or allow you to execute operations in an
-:website:`ACID transaction </basics/acid-transactions>`. MongoDB
-guarantees that the data involved in your transaction operations remains
-consistent, even if the operations encounter unexpected errors.
+session is a grouping of related read or write operations that you
+intend to run sequentially. Sessions allow you to run operations
+in an ACID-compliant transaction, which is a transaction that meets
+an expectation of atomicity, consistency, isolation, and durability.
 
 When using the {+driver-short+}, you can create a new session from a 
 ``MongoClient`` instance as a ``ClientSession`` type. We recommend that you reuse
@@ -54,6 +50,64 @@ instantiating a new client each time.
    You must include the ``session`` as a parameter for any operations that you
    want to include in a transaction.
 
+Causal Consistency
+~~~~~~~~~~~~~~~~~~
+
+MongoDB enables **causal consistency** in client sessions.
+The causal consistency model guarantees that operations within a session
+run in a causal order. Clients observe results that are consistent
+with the causal relationships, or the dependencies between
+operations. For example, if you perform a series of operations where
+one operation logically depends on the result of another, any subsequent
+reads reflect the dependent relationship.
+
+The following table describes the guarantees that causally
+consistent sessions provide:
+
+.. list-table::
+   :widths: 40 60
+   :header-rows: 1
+
+   * - Guarantee
+     - Description
+
+   * - Read your writes
+     - Read operations reflect the results of preceding write operations.
+
+   * - Monotonic reads
+     - Read operations do not return results that reflect an earlier data state than
+       a preceding read operation.
+
+   * - Monotonic writes
+     - If a write operation must precede other write operations, the driver
+       runs this write operation first.
+
+       For example, if you call ``insertOne()`` to insert a document, then call
+       ``updateOne()`` to modify the inserted document, the driver runs the 
+       insert operation first.
+
+   * - Writes follow reads
+     - If a write operation must follow other read operations, the driver runs
+       the read operations first.
+
+       For example, if you call ``find()`` to retrieve a document, then call
+       ``deleteOne()`` to delete the retrieved document, the driver runs the find
+       operation first.
+
+In a causally consistent session, MongoDB ensures a
+causal relationship between the following operations:
+
+- Read operations that have a ``MAJORITY`` read concern
+- Write operations that have a ``MAJORITY`` write concern
+
+.. tip::
+
+   To learn more about the concepts mentioned in this section, see the 
+   following {+mdb-server+} manual entries:
+
+   - :manual:`Causal Consistency </core/read-isolation-consistency-recency/#causal-consistency>`
+   - :manual:`Causal Consistency and Read and Write Concerns </core/causal-consistency-read-write-concerns/>`
+
 Methods
 -------
 

source/includes/AtlasSearch.java

@@ -0,0 +1,28 @@
+package source.includes;
+
+import org.bson.Document;
+
+import com.mongodb.client.MongoClient;
+import com.mongodb.client.MongoClients;
+import com.mongodb.client.MongoCollection;
+import com.mongodb.client.MongoDatabase;
+
+public class AtlasSearch {
+    public static void main( String[] args ) {
+
+        // Replace the placeholder with your MongoDB deployment's connection string
+        String uri = "<connection string uri>";
+
+        try (MongoClient mongoClient = MongoClients.create(uri)) {
+            MongoDatabase database = mongoClient.getDatabase("sample_mflix");
+            MongoCollection<Document> collection = database.getCollection("movies");
+
+            Document doc = collection.find(eq("title", "Back to the Future")).first();
+            if (doc != null) {
+                System.out.println(doc.toJson());
+            } else {
+                System.out.println("No matching documents found.");
+            }
+        }
+    }
+}