couchbase 3.5.7 → 3.7.0

data/ext/couchbase/core/transactions/attempt_context_impl.cxx

@@ -21,12 +21,18 @@
 #include "attempt_context_testing_hooks.hxx"
 #include "attempt_state.hxx"
 #include "core/cluster.hxx"
+#include "core/error_context/transaction_error_context.hxx"
+#include "core/error_context/transaction_op_error_context.hxx"
 #include "core/impl/error.hxx"
 #include "core/operations.hxx"
 #include "core/transactions/error_class.hxx"
+#include "core/transactions/transaction_get_multi_mode.hxx"
+#include "couchbase/error_codes.hxx"
 #include "durability_level.hxx"
 #include "exceptions.hxx"
+#include "exceptions_fmt.hxx"
 #include "forward_compat.hxx"
+#include "get_multi_orchestrator.hxx"
 #include "internal/exceptions_internal.hxx"
 #include "internal/exceptions_internal_fmt.hxx"
 #include "internal/logging.hxx"
@@ -36,6 +42,8 @@
 #include "internal/utils.hxx"
 #include "staged_mutation.hxx"
 
+#include <optional>
+
 namespace couchbase::core::transactions
 {
 
@@ -95,7 +103,7 @@ wrap_call_for_public_api(std::function<transaction_get_result()>&& handler)
   } catch (const transaction_operation_failed& e) {
     return { core::impl::make_error(e), {} };
   } catch (const op_exception& ex) {
-    return { core::impl::make_error(ex.ctx()), {} };
+    return { core::impl::make_error(ex), {} };
   } catch (...) {
     // the handler should catch everything else, but just in case...
     return { { errc::transaction_op::generic }, {} };
@@ -115,7 +123,7 @@ wrap_callback_for_async_public_api(
     try {
       std::rethrow_exception(err);
     } catch (const op_exception& e) {
-      return cb(core::impl::make_error(e.ctx()), {});
+      return cb(core::impl::make_error(e), {});
     } catch (const transaction_operation_failed& e) {
       return cb(core::impl::make_error(e), {});
     } catch (...) {
@@ -235,9 +243,10 @@ attempt_context_impl::get(const core::document_id& id, Callback&& cb)
       false,
       std::nullopt,
       [self, id, cb = std::move(cb)](std::optional<error_class> ec,
+                                     std::optional<external_exception> cause,
                                      const std::optional<std::string>& err_message,
                                      std::optional<transaction_get_result> res) mutable {
-        auto handler = [self, id, err_message, res = std::move(res), cb = std::move(cb)](
+        auto handler = [self, id, cause, err_message, res = std::move(res), cb = std::move(cb)](
                          std::optional<error_class> ec) mutable {
           if (ec) {
             switch (*ec) {
@@ -268,8 +277,8 @@ attempt_context_impl::get(const core::document_id& id, Callback&& cb)
                                        err_message.value_or(""),
                                        *ec,
                                        id.key());
-                return self->op_completed_with_error(std::move(cb),
-                                                     transaction_operation_failed(FAIL_OTHER, msg));
+                return self->op_completed_with_error(
+                  std::move(cb), transaction_operation_failed(FAIL_OTHER, cause, msg));
               }
             }
           } else {
@@ -330,9 +339,10 @@ attempt_context_impl::get_optional(const core::document_id& id, Callback&& cb)
           false,
           std::nullopt,
           [self, id, cb = std::move(cb)](std::optional<error_class> ec,
+                                         std::optional<external_exception> cause,
                                          const std::optional<std::string>& err_message,
                                          std::optional<transaction_get_result> res) mutable {
-            auto handler = [self, id, err_message, res, cb = std::move(cb)](
+            auto handler = [self, id, cause, err_message, res, cb = std::move(cb)](
                              std::optional<error_class> ec) mutable {
               if (ec) {
                 switch (*ec) {
@@ -341,6 +351,7 @@ attempt_context_impl::get_optional(const core::document_id& id, Callback&& cb)
                       std::move(cb),
                       transaction_operation_failed(
                         *ec,
+                        cause,
                         fmt::format("transaction expired during get {}", err_message.value_or("")))
                         .expired());
                   case FAIL_DOC_NOT_FOUND:
@@ -350,19 +361,22 @@ attempt_context_impl::get_optional(const core::document_id& id, Callback&& cb)
                     return self->op_completed_with_error(
                       std::move(cb),
                       transaction_operation_failed(
-                        *ec, fmt::format("transient failure in get {}", err_message.value_or("")))
+                        *ec,
+                        cause,
+                        fmt::format("transient failure in get {}", err_message.value_or("")))
                         .retry());
                   case FAIL_HARD:
                     return self->op_completed_with_error(
                       std::move(cb),
                       transaction_operation_failed(
-                        *ec, fmt::format("fail hard in get {}", err_message.value_or("")))
+                        *ec, cause, fmt::format("fail hard in get {}", err_message.value_or("")))
                         .no_rollback());
                   default: {
                     return self->op_completed_with_error(
                       std::move(cb),
                       transaction_operation_failed(
                         FAIL_OTHER,
+                        cause,
                         fmt::format("error getting {} {}", id.key(), err_message.value_or(""))));
                   }
                 }
@@ -392,29 +406,32 @@ attempt_context_impl::get_replica_from_preferred_server_group(
   const core::document_id& id,
   std::function<void(std::exception_ptr, std::optional<transaction_get_result>)>&& cb)
 {
-  if (op_list_.get_mode().is_query()) {
-    return cb(std::make_exception_ptr(transaction_operation_failed(
-                                        FAIL_OTHER, "Replica Read is not supported in Query Mode")
-                                        .cause(FEATURE_NOT_AVAILABLE_EXCEPTION)),
-              {});
-  }
   cache_error_async(cb, [self = shared_from_this(), id, cb]() mutable {
+    if (self->op_list_.get_mode().is_query()) {
+      return self->op_completed_with_error(
+        std::move(cb),
+        transaction_operation_failed(FAIL_OTHER,
+                                     FEATURE_NOT_AVAILABLE_EXCEPTION,
+                                     "Get Replica is not supported in Query Mode"));
+    }
     self->check_if_done(cb);
     self->do_get(
       id,
       true,
       std::nullopt,
       [self, id, cb = std::move(cb)](std::optional<error_class> ec,
+                                     std::optional<external_exception> cause,
                                      const std::optional<std::string>& err_message,
                                      std::optional<transaction_get_result> res) mutable {
-        auto handler = [self, id, err_message, res = std::move(res), cb = std::move(cb)](
+        auto handler = [self, id, cause, err_message, res = std::move(res), cb = std::move(cb)](
                          std::optional<error_class> ec) mutable {
           if (ec) {
             switch (*ec) {
               case FAIL_EXPIRY:
                 return self->op_completed_with_error(
                   std::move(cb),
-                  transaction_operation_failed(*ec, "transaction expired during get").expired());
+                  transaction_operation_failed(*ec, cause, "transaction expired during get")
+                    .expired());
               case FAIL_DOC_NOT_FOUND:
                 return self->op_completed_with_callback(std::move(cb),
                                                         std::optional<transaction_get_result>());
@@ -422,18 +439,20 @@ attempt_context_impl::get_replica_from_preferred_server_group(
                 return self->op_completed_with_error(
                   std::move(cb),
                   transaction_operation_failed(
-                    *ec, fmt::format("transient failure in get {}", err_message.value_or("")))
+                    *ec,
+                    cause,
+                    fmt::format("transient failure in get {}", err_message.value_or("")))
                     .retry());
               case FAIL_HARD:
                 return self->op_completed_with_error(
                   std::move(cb),
                   transaction_operation_failed(
-                    *ec, fmt::format("fail hard in get {}", err_message.value_or("")))
+                    *ec, cause, fmt::format("fail hard in get {}", err_message.value_or("")))
                     .no_rollback());
               case FAIL_OTHER:
-                if (err_message.value_or("") == "document_irretrievable (102)") {
-                  return self->op_completed_with_callback(std::move(cb),
-                                                          std::optional<transaction_get_result>());
+                if (cause == DOCUMENT_UNRETRIEVABLE_EXCEPTION) {
+                  return self->op_completed_with_error(
+                    std::move(cb), document_unretrievable("failed to retrieve document"));
                 }
                 [[fallthrough]];
               default: {
@@ -441,14 +460,16 @@ attempt_context_impl::get_replica_from_preferred_server_group(
                                        err_message.value_or(""),
                                        *ec,
                                        id.key());
-                return self->op_completed_with_error(std::move(cb),
-                                                     transaction_operation_failed(FAIL_OTHER, msg));
+                return self->op_completed_with_error(
+                  std::move(cb), transaction_operation_failed(FAIL_OTHER, cause, msg));
               }
             }
           } else {
             if (!res) {
               return self->op_completed_with_error(
-                std::move(cb), transaction_operation_failed(*ec, "document not found"));
+                std::move(cb),
+                transaction_operation_failed(
+                  *ec, external_exception::DOCUMENT_NOT_FOUND_EXCEPTION, "document not found"));
             }
             auto err =
               check_forward_compat(forward_compat_stage::GETS, res->links().forward_compat());
@@ -476,7 +497,7 @@ attempt_context_impl::get_replica_from_preferred_server_group(const core::docume
   get_replica_from_preferred_server_group(
     id, [barrier](const std::exception_ptr& err, std::optional<transaction_get_result> res) {
       if (err) {
-        barrier->set_exception(err);
+        return barrier->set_exception(err);
       }
       return barrier->set_value(std::move(res));
     });
@@ -520,6 +541,277 @@ attempt_context_impl::get_replica_from_preferred_server_group(
     });
 }
 
+namespace
+{
+// FIXME(SA): do not use Public API in the core
+auto
+from_public_api(couchbase::transactions::transaction_get_multi_mode mode)
+  -> transaction_get_multi_mode
+{
+  switch (mode) {
+    case couchbase::transactions::transaction_get_multi_mode::prioritise_latency:
+      return transaction_get_multi_mode::prioritise_latency;
+    case couchbase::transactions::transaction_get_multi_mode::disable_read_skew_detection:
+      return transaction_get_multi_mode::disable_read_skew_detection;
+    case couchbase::transactions::transaction_get_multi_mode::prioritise_read_skew_detection:
+      return transaction_get_multi_mode::prioritise_read_skew_detection;
+  }
+  return transaction_get_multi_mode::prioritise_latency;
+}
+
+auto
+from_public_api(
+  couchbase::transactions::transaction_get_multi_replicas_from_preferred_server_group_mode mode)
+  -> transaction_get_multi_replicas_from_preferred_server_group_mode
+{
+  switch (mode) {
+    case couchbase::transactions::transaction_get_multi_replicas_from_preferred_server_group_mode::
+      prioritise_latency:
+      return transaction_get_multi_replicas_from_preferred_server_group_mode::prioritise_latency;
+    case couchbase::transactions::transaction_get_multi_replicas_from_preferred_server_group_mode::
+      disable_read_skew_detection:
+      return transaction_get_multi_replicas_from_preferred_server_group_mode::
+        disable_read_skew_detection;
+    case couchbase::transactions::transaction_get_multi_replicas_from_preferred_server_group_mode::
+      prioritise_read_skew_detection:
+      return transaction_get_multi_replicas_from_preferred_server_group_mode::
+        prioritise_read_skew_detection;
+      break;
+  }
+  return transaction_get_multi_replicas_from_preferred_server_group_mode::prioritise_latency;
+}
+} // namespace
+
+void
+attempt_context_impl::get_multi(
+  const std::vector<core::document_id>& ids,
+  transaction_get_multi_mode mode,
+  std::function<void(std::exception_ptr, std::optional<transaction_get_multi_result>)>&& cb)
+{
+  if (op_list_.get_mode().is_query()) {
+    return cb(std::make_exception_ptr(op_exception({ errc::transaction_op::feature_not_available },
+                                                   "Get Multi is not supported in Query Mode",
+                                                   FEATURE_NOT_AVAILABLE_EXCEPTION)),
+              {});
+  }
+  cache_error_async(cb, [self = shared_from_this(), ids, mode, cb]() mutable {
+    self->check_if_done(cb);
+    const auto manager = std::make_shared<get_multi_orchestrator>(self, ids);
+    manager->get_multi(
+      mode,
+      [self, cb = std::move(cb)](std::exception_ptr err,
+                                 std::optional<transaction_get_multi_result> res) mutable {
+        if (err) {
+          self->op_completed_with_error(std::move(cb), std::move(err));
+          return;
+        }
+        self->op_completed_with_callback(std::move(cb), std::move(res));
+      });
+  });
+}
+
+auto
+attempt_context_impl::get_multi(const std::vector<core::document_id>& ids,
+                                transaction_get_multi_mode mode) -> transaction_get_multi_result
+{
+  auto barrier = std::make_shared<std::promise<transaction_get_multi_result>>();
+  auto f = barrier->get_future();
+  get_multi(
+    ids, mode, [barrier](std::exception_ptr err, std::optional<transaction_get_multi_result> res) {
+      if (err) {
+        return barrier->set_exception(std::move(err));
+      }
+      if (res) {
+        return barrier->set_value(std::move(*res));
+      }
+      return barrier->set_exception(std::make_exception_ptr(
+        transaction_operation_failed(FAIL_OTHER, "get_multi: either error or result must be set")));
+    });
+  return f.get();
+}
+
+void
+attempt_context_impl::get_multi(
+  const std::vector<couchbase::transactions::transaction_get_multi_spec>& specs,
+  const couchbase::transactions::transaction_get_multi_options& options,
+  std::function<void(error, std::optional<couchbase::transactions::transaction_get_multi_result>)>&&
+    cb)
+{
+  std::vector<core::document_id> ids;
+  ids.reserve(specs.size());
+  for (const auto& spec : specs) {
+    ids.emplace_back(spec.bucket_, spec.scope_, spec.collection_, spec.id_);
+  }
+
+  get_multi(ids, from_public_api(options.mode_), [cb = std::move(cb)](const auto& err, auto res) {
+    if (err) {
+      try {
+        std::rethrow_exception(err);
+      } catch (const op_exception& e) {
+        return cb(core::impl::make_error(e), {});
+      } catch (const transaction_operation_failed& e) {
+        return cb(core::impl::make_error(e), {});
+      } catch (...) {
+        return cb({ errc::transaction_op::generic }, {});
+      }
+    }
+    if (res) {
+      return cb({}, couchbase::transactions::transaction_get_multi_result{ res->content() });
+    }
+    return cb({ errc::transaction_op::generic }, {});
+  });
+}
+
+auto
+attempt_context_impl::get_multi(
+  const std::vector<couchbase::transactions::transaction_get_multi_spec>& specs,
+  const couchbase::transactions::transaction_get_multi_options& options)
+  -> std::pair<error, std::optional<couchbase::transactions::transaction_get_multi_result>>
+{
+  auto barrier = std::make_shared<std::promise<
+    std::pair<error, std::optional<couchbase::transactions::transaction_get_multi_result>>>>();
+  auto f = barrier->get_future();
+  get_multi(
+    specs,
+    options,
+    [barrier](error err, std::optional<couchbase::transactions::transaction_get_multi_result> res) {
+      return barrier->set_value(std::make_pair(std::move(err), std::move(res)));
+    });
+  return f.get();
+}
+
+void
+attempt_context_impl::get_multi_replicas_from_preferred_server_group(
+  const std::vector<core::document_id>& ids,
+  transaction_get_multi_replicas_from_preferred_server_group_mode mode,
+  std::function<
+    void(std::exception_ptr,
+         std::optional<transaction_get_multi_replicas_from_preferred_server_group_result>)>&& cb)
+{
+  if (op_list_.get_mode().is_query()) {
+    return cb(
+      std::make_exception_ptr(op_exception({ errc::transaction_op::feature_not_available },
+                                           "Get Multi Replica is not supported in Query Mode",
+                                           FEATURE_NOT_AVAILABLE_EXCEPTION)),
+      {});
+  }
+
+  cache_error_async(cb, [self = shared_from_this(), ids, mode, cb]() mutable {
+    self->check_if_done(cb);
+    const auto manager = std::make_shared<get_multi_orchestrator>(self, ids);
+    manager->get_multi_replicas_from_preferred_server_group(
+      mode,
+      [self, cb = std::move(cb)](
+        std::exception_ptr err,
+        std::optional<transaction_get_multi_replicas_from_preferred_server_group_result>
+          res) mutable {
+        if (err) {
+          self->op_completed_with_error(std::move(cb), std::move(err));
+          return;
+        }
+        self->op_completed_with_callback(std::move(cb), std::move(res));
+      });
+  });
+}
+
+auto
+attempt_context_impl::get_multi_replicas_from_preferred_server_group(
+  const std::vector<core::document_id>& ids,
+  transaction_get_multi_replicas_from_preferred_server_group_mode mode)
+  -> transaction_get_multi_replicas_from_preferred_server_group_result
+{
+  auto barrier = std::make_shared<
+    std::promise<transaction_get_multi_replicas_from_preferred_server_group_result>>();
+  auto f = barrier->get_future();
+  get_multi_replicas_from_preferred_server_group(
+    ids,
+    mode,
+    [barrier](
+      std::exception_ptr err,
+      std::optional<transaction_get_multi_replicas_from_preferred_server_group_result> res) {
+      if (err) {
+        return barrier->set_exception(std::move(err));
+      }
+      if (res) {
+        return barrier->set_value(std::move(*res));
+      }
+      return barrier->set_exception(std::make_exception_ptr(
+        transaction_operation_failed(FAIL_OTHER, "get_multi: either error or result must be set")));
+    });
+  return f.get();
+}
+
+void
+attempt_context_impl::get_multi_replicas_from_preferred_server_group(
+  const std::vector<
+    couchbase::transactions::transaction_get_multi_replicas_from_preferred_server_group_spec>&
+    specs,
+  const couchbase::transactions::transaction_get_multi_replicas_from_preferred_server_group_options&
+    options,
+  std::function<
+    void(error,
+         std::optional<couchbase::transactions::
+                         transaction_get_multi_replicas_from_preferred_server_group_result>)>&& cb)
+{
+  std::vector<core::document_id> ids;
+  ids.reserve(specs.size());
+  for (const auto& spec : specs) {
+    ids.emplace_back(spec.bucket_, spec.scope_, spec.collection_, spec.id_);
+  }
+
+  get_multi_replicas_from_preferred_server_group(
+    ids, from_public_api(options.mode_), [cb = std::move(cb)](const auto& err, auto res) {
+      if (err) {
+        try {
+          std::rethrow_exception(err);
+        } catch (const op_exception& e) {
+          return cb(core::impl::make_error(e), {});
+        } catch (const transaction_operation_failed& e) {
+          return cb(core::impl::make_error(e), {});
+        } catch (...) {
+          return cb({ errc::transaction_op::generic }, {});
+        }
+      }
+      if (res) {
+        return cb(
+          {},
+          couchbase::transactions::
+            transaction_get_multi_replicas_from_preferred_server_group_result{ res->content() });
+      }
+      return cb({ errc::transaction_op::generic }, {});
+    });
+}
+
+auto
+attempt_context_impl::get_multi_replicas_from_preferred_server_group(
+  const std::vector<
+    couchbase::transactions::transaction_get_multi_replicas_from_preferred_server_group_spec>&
+    specs,
+  const couchbase::transactions::transaction_get_multi_replicas_from_preferred_server_group_options&
+    options)
+  -> std::pair<
+    error,
+    std::optional<
+      couchbase::transactions::transaction_get_multi_replicas_from_preferred_server_group_result>>
+{
+  auto barrier = std::make_shared<std::promise<std::pair<
+    error,
+    std::optional<couchbase::transactions::
+                    transaction_get_multi_replicas_from_preferred_server_group_result>>>>();
+  auto f = barrier->get_future();
+  get_multi_replicas_from_preferred_server_group(
+    specs,
+    options,
+    [barrier](
+      error err,
+      std::optional<
+        couchbase::transactions::transaction_get_multi_replicas_from_preferred_server_group_result>
+        res) {
+      return barrier->set_value(std::make_pair(std::move(err), std::move(res)));
+    });
+  return f.get();
+}
+
 auto
 attempt_context_impl::create_document_metadata(
   const std::string& operation_type,
@@ -576,8 +868,8 @@ attempt_context_impl::create_document_metadata(
       }),
     });
     txn["fc"] = {
-      { to_string(forward_compat_stage::WWC_INSERTING), fc_check },
-      { to_string(forward_compat_stage::WWC_INSERTING_GET), fc_check },
+      { to_string(forward_compat_stage::WRITE_WRITE_CONFLICT_INSERTING), fc_check },
+      { to_string(forward_compat_stage::WRITE_WRITE_CONFLICT_INSERTING_GET), fc_check },
       { to_string(forward_compat_stage::GETS), fc_check },
       { to_string(forward_compat_stage::CLEANUP_ENTRY), fc_check },
     };
@@ -616,7 +908,7 @@ attempt_context_impl::replace(const transaction_get_result& document,
                   .cause(external_exception::DOCUMENT_NOT_FOUND_EXCEPTION));
             }
             CB_ATTEMPT_CTX_LOG_TRACE(
-              self, "replacing {} with {}", document, to_string(content.data));
+              self, "replacing {} with {}", document, utils::to_string(content.data));
             self->check_if_done(cb);
             staged_mutation* existing_sm = self->staged_mutations_->find_any(document.id());
             if (existing_sm != nullptr && existing_sm->type() == staged_mutation_type::REMOVE) {
@@ -637,7 +929,7 @@ attempt_context_impl::replace(const transaction_get_result& document,
 
             self->check_and_handle_blocking_transactions(
               document,
-              forward_compat_stage::WWC_REPLACING,
+              forward_compat_stage::WRITE_WRITE_CONFLICT_REPLACING,
               [self,
                existing_sm,
                document,
@@ -670,7 +962,7 @@ attempt_context_impl::replace(const transaction_get_result& document,
                         self, "found existing INSERT of {} while replacing", document);
                       self->create_staged_insert(document.id(),
                                                  std::move(content),
-                                                 existing_sm->doc().cas().value(),
+                                                 document.cas().value(),
                                                  exp_delay(std::chrono::milliseconds(5),
                                                            std::chrono::milliseconds(300),
                                                            self->overall()->config().timeout),
@@ -678,7 +970,13 @@ attempt_context_impl::replace(const transaction_get_result& document,
                                                  std::move(cb));
                       return;
                     }
-                    self->create_staged_replace(document, std::move(content), op_id, std::move(cb));
+                    self->create_staged_replace(document.id(),
+                                                std::move(content),
+                                                document.content().flags,
+                                                document.cas(),
+                                                op_id,
+                                                document.metadata(),
+                                                std::move(cb));
                   });
               });
           } catch (const client_error& e) {
@@ -701,6 +999,9 @@ template<typename Response>
 auto
 external_exception_from_response(const Response& resp) -> external_exception
 {
+  if (resp.ctx.ec() == errc::key_value::document_irretrievable) {
+    return DOCUMENT_UNRETRIEVABLE_EXCEPTION;
+  }
   if (const auto error_index = resp.ctx.first_error_index(); error_index) {
     const auto status = resp.fields.at(error_index.value()).status;
     const auto path = resp.fields.at(error_index.value()).path;
@@ -714,20 +1015,22 @@ external_exception_from_response(const Response& resp) -> external_exception
 
 template<typename Handler>
 void
-attempt_context_impl::create_staged_replace(const transaction_get_result& document,
-                                            codec::encoded_value content,
-                                            const std::string& op_id,
-                                            Handler&& cb)
+attempt_context_impl::create_staged_replace(
+  const document_id& id,
+  codec::encoded_value content,
+  std::uint32_t original_flags,
+  const couchbase::cas& cas,
+  const std::string& op_id,
+  const std::optional<document_metadata>& document_metadata,
+  Handler&& cb)
 {
-  core::operations::mutate_in_request req{ document.id() };
+  operations::mutate_in_request req{ id };
   const bool binary =
     codec::codec_flags::has_common_flags(content.flags, codec::codec_flags::binary_common_flags);
-  auto txn = create_document_metadata("replace", op_id, document.metadata(), content.flags);
+  auto txn = create_document_metadata("replace", op_id, document_metadata, content.flags);
   req.specs =
     mutate_in_specs{
-      mutate_in_specs::upsert_raw("txn", core::utils::to_binary(jsonify(txn)))
-        .xattr()
-        .create_path(),
+      mutate_in_specs::upsert_raw("txn", utils::to_binary(jsonify(txn))).xattr().create_path(),
       mutate_in_specs::upsert_raw(binary ? "txn.op.bin" : "txn.op.stgd", content.data)
         .xattr()
         .binary(binary),
@@ -737,8 +1040,8 @@ attempt_context_impl::create_staged_replace(const transaction_get_result& docume
     }
       .specs();
   req.durability_level = overall()->config().level;
-  req.cas = document.cas();
-  req.flags = document.content().flags;
+  req.cas = cas;
+  req.flags = original_flags;
   req.access_deleted = true;
   auto error_handler = [self = shared_from_this()](error_class ec,
                                                    external_exception cause,
@@ -759,25 +1062,26 @@ attempt_context_impl::create_staged_replace(const transaction_get_result& docume
         return self->op_completed_with_error(std::forward<Handler>(cb), err);
     }
   };
-  auto ec =
-    wait_for_hook([self = shared_from_this(), key = document.id().key()](auto handler) mutable {
-      return self->hooks_.before_staged_replace(self, key, std::move(handler));
-    });
+  auto ec = wait_for_hook([self = shared_from_this(), key = id.key()](auto handler) mutable {
+    return self->hooks_.before_staged_replace(self, key, std::move(handler));
+  });
   if (ec) {
     return error_handler(
       *ec, UNKNOWN, "before_staged_replace hook raised error", std::forward<Handler>(cb));
   }
   CB_ATTEMPT_CTX_LOG_TRACE(this,
                            "about to replace doc {} with cas {} in txn {}",
-                           document.id(),
-                           document.cas().value(),
+                           id,
+                           cas.value(),
                            overall()->transaction_id());
   overall()->cluster_ref().execute(
     req,
     [self = shared_from_this(),
-     operation_id = op_id,
-     document,
+     op_id,
+     id,
+     document_metadata,
      content = std::move(content),
+     original_flags,
      cb = std::forward<Handler>(cb),
      error_handler = std::move(error_handler)](core::operations::mutate_in_response resp) mutable {
       if (auto ec2 = error_class_from_response(resp); ec2) {
@@ -789,11 +1093,13 @@ attempt_context_impl::create_staged_replace(const transaction_get_result& docume
       }
       return self->hooks_.after_staged_replace_complete(
         self,
-        document.id().key(),
+        id.key(),
         [self,
-         operation_id,
-         document,
+         op_id,
+         id,
+         document_metadata,
          content = std::move(content),
+         original_flags,
          error_handler = std::move(error_handler),
          cb = std::forward<Handler>(cb),
          resp = std::move(resp)](auto ec) mutable {
@@ -808,23 +1114,23 @@ attempt_context_impl::create_staged_replace(const transaction_get_result& docume
           std::optional<codec::encoded_value> staged_content_binary{};
           if (codec::codec_flags::has_common_flags(content.flags,
                                                    codec::codec_flags::json_common_flags)) {
-            staged_content_json = std::move(content);
+            staged_content_json = content;
           } else if (codec::codec_flags::has_common_flags(
                        content.flags, codec::codec_flags::binary_common_flags)) {
-            staged_content_binary = std::move(content);
+            staged_content_binary = content;
           }
           transaction_get_result out{
-            document.id(),
-            document.content(),
+            id,
+            content,
             resp.cas.value(),
             transaction_links{
               self->atr_id_->key(),
-              document.id().bucket(),
-              document.id().scope(),
-              document.id().collection(),
+              id.bucket(),
+              id.scope(),
+              id.collection(),
               self->overall()->transaction_id(),
               self->id(),
-              operation_id,
+              op_id,
               std::move(staged_content_json),
               std::move(staged_content_binary),
               std::nullopt,
@@ -835,25 +1141,50 @@ attempt_context_impl::create_staged_replace(const transaction_get_result& docume
               std::nullopt,
               false,
             },
-            document.metadata(),
+            document_metadata,
           };
 
           CB_ATTEMPT_CTX_LOG_TRACE(self, "replace staged content, result {}", out);
-          self->staged_mutations_->add(staged_mutation{
-            out,
-            // TODO(SA): java SDK checks for
-            // bucket_capability::subdoc_revive_document here
-            out.links().staged_content_json_or_binary(),
-            staged_mutation_type::REPLACE,
-          });
-          return self->op_completed_with_callback(std::forward<Handler>(cb), std::optional(out));
+
+          self->supports_replace_body_with_xattr(
+            id.bucket(),
+            [self,
+             out = std::move(out),
+             error_handler = std::move(error_handler),
+             original_flags,
+             cb = std::forward<Handler>(cb)](auto ec, bool supports) mutable {
+              if (ec) {
+                return error_handler(
+                  FAIL_OTHER,
+                  UNKNOWN,
+                  "failed to check whether replace_body_with_xattr is supported: " + ec.message(),
+                  std::forward<Handler>(cb));
+              }
+
+              auto [staged_content, staged_flags] = out.links().staged_content_json_or_binary();
+
+              self->staged_mutations_->add(staged_mutation{
+                staged_mutation_type::REPLACE,
+                out.id(),
+                out.cas(),
+                supports ? std::nullopt
+                         : std::make_optional(staged_content), // We don't store the staged contents
+                                                               // if the cluster supports
+                                                               // replace_body_with_xattr
+                staged_flags,
+                original_flags,
+                out.metadata(),
+              });
+              return self->op_completed_with_callback(std::forward<Handler>(cb),
+                                                      std::optional(out));
+            });
         });
     });
 }
 
 auto
-attempt_context_impl::replace(const transaction_get_result& document,
-                              codec::encoded_value content) -> transaction_get_result
+attempt_context_impl::replace(const transaction_get_result& document, codec::encoded_value content)
+  -> transaction_get_result
 {
   auto barrier = std::make_shared<std::promise<transaction_get_result>>();
   auto f = barrier->get_future();
@@ -920,8 +1251,8 @@ attempt_context_impl::insert_raw(const collection& coll,
 }
 
 auto
-attempt_context_impl::insert(const core::document_id& id,
-                             codec::encoded_value content) -> transaction_get_result
+attempt_context_impl::insert(const core::document_id& id, codec::encoded_value content)
+  -> transaction_get_result
 {
   auto barrier = std::make_shared<std::promise<transaction_get_result>>();
   auto f = barrier->get_future();
@@ -964,8 +1295,7 @@ attempt_context_impl::insert(const core::document_id& id,
                 self, "found existing insert or replace of {} while inserting", id);
               return self->op_completed_with_error(
                 std::move(cb),
-                transaction_operation_failed(FAIL_DOC_ALREADY_EXISTS,
-                                             "found existing insert or replace of same document"));
+                document_exists("found existing insert or replace of same document"));
             }
             if (self->check_expiry_pre_commit(STAGE_INSERT, id.key())) {
               return self->op_completed_with_error(
@@ -981,8 +1311,13 @@ attempt_context_impl::insert(const core::document_id& id,
                 }
                 if (existing_sm != nullptr && existing_sm->type() == staged_mutation_type::REMOVE) {
                   CB_ATTEMPT_CTX_LOG_DEBUG(self, "found existing remove of {} while inserting", id);
-                  return self->create_staged_replace(
-                    existing_sm->doc(), std::move(content), op_id, std::move(cb));
+                  return self->create_staged_replace(existing_sm->id(),
+                                                     std::move(content),
+                                                     existing_sm->current_user_flags(),
+                                                     existing_sm->cas(),
+                                                     op_id,
+                                                     existing_sm->doc_metadata(),
+                                                     std::move(cb));
                 }
                 const std::uint64_t cas = 0;
                 self->create_staged_insert(id,
@@ -1076,8 +1411,8 @@ attempt_context_impl::check_atr_entry_for_blocking_document(const transaction_ge
                   return e.attempt_id() == doc.links().staged_attempt_id();
                 });
                 if (it != entries.end()) {
-                  auto fwd_err = check_forward_compat(forward_compat_stage::WWC_READING_ATR,
-                                                      it->forward_compat());
+                  auto fwd_err = check_forward_compat(
+                    forward_compat_stage::WRITE_WRITE_CONFLICT_READING_ATR, it->forward_compat());
                   if (fwd_err) {
                     return cb(fwd_err);
                   }
@@ -1168,7 +1503,7 @@ attempt_context_impl::remove(const transaction_get_result& document, VoidCallbac
         }
         return self->check_and_handle_blocking_transactions(
           document,
-          forward_compat_stage::WWC_REMOVING,
+          forward_compat_stage::WRITE_WRITE_CONFLICT_REMOVING,
           [self, document, cb = std::move(cb), op_id, error_handler = std::move(error_handler)](
             std::optional<transaction_operation_failed> err1) mutable {
             if (err1) {
@@ -1252,11 +1587,16 @@ attempt_context_impl::remove(const transaction_get_result& document, VoidCallbac
                                                      document.id(),
                                                      resp.cas.value(),
                                                      resp.ctx.ec().message());
-                            // TODO(SA): this copy...  can we do better?
-                            transaction_get_result new_res = document;
-                            new_res.cas(resp.cas.value());
-                            self->staged_mutations_->add(
-                              staged_mutation(new_res, {}, staged_mutation_type::REMOVE));
+
+                            self->staged_mutations_->add(staged_mutation{
+                              staged_mutation_type::REMOVE,
+                              document.id(),
+                              resp.cas,
+                              {},
+                              document.content().flags,
+                              document.content().flags,
+                              document.metadata(),
+                            });
                             return self->op_completed_with_callback(cb);
                           });
                       });
@@ -1413,11 +1753,11 @@ attempt_context_impl::query_begin_work(const std::optional<std::string>& query_c
   if (!staged_mutations_->empty()) {
     staged_mutations_->iterate([&mutations](staged_mutation& mut) {
       mutations.push_back(tao::json::value{
-        { "scp", mut.doc().id().scope() },
-        { "coll", mut.doc().id().collection() },
-        { "bkt", mut.doc().id().bucket() },
-        { "id", mut.doc().id().key() },
-        { "cas", std::to_string(mut.doc().cas().value()) },
+        { "scp", mut.id().scope() },
+        { "coll", mut.id().collection() },
+        { "bkt", mut.id().bucket() },
+        { "id", mut.id().key() },
+        { "cas", std::to_string(mut.cas().value()) },
         { "type", mut.type_as_string() },
       });
     });
@@ -1797,11 +2137,25 @@ attempt_context_impl::do_public_query(
   try {
     auto result = do_core_query(statement, opts, query_context);
     auto [ctx, res] = core::impl::build_transaction_query_result(result);
-    return std::make_pair(core::impl::make_error(ctx), res);
+    if (ctx.ec()) {
+      // This should have already been converted to an exception by handle_query_error, which we
+      // handle above. Let's return an error here just in case
+      std::string msg = "Txns query error occured that should have been handled further upstream, "
+                        "which might indicate a bug.";
+      if (std::holds_alternative<query_error_context>(ctx.cause())) {
+        return { { ctx.ec(),
+                   std::move(msg),
+                   {},
+                   impl::make_error(std::get<query_error_context>(ctx.cause())) },
+                 {} };
+      }
+      return { { ctx.ec(), std::move(msg) }, {} };
+    }
+    return { {}, res };
   } catch (const transaction_operation_failed& e) {
     return { core::impl::make_error(e), {} };
   } catch (const op_exception& qe) {
-    return { core::impl::make_error(qe.ctx()), {} };
+    return { core::impl::make_error(qe), {} };
   } catch (...) {
     // should not be necessary, but just in case...
     return { { couchbase::errc::transaction_op::generic }, {} };
@@ -1809,8 +2163,8 @@ attempt_context_impl::do_public_query(
 }
 
 auto
-make_params(const core::document_id& id,
-            std::optional<codec::encoded_value> content) -> std::vector<core::json_string>
+make_params(const core::document_id& id, std::optional<codec::encoded_value> content)
+  -> std::vector<core::json_string>
 {
   if (content && !codec::codec_flags::has_common_flags(content->flags,
                                                        codec::codec_flags::json_common_flags)) {
@@ -1925,7 +2279,7 @@ attempt_context_impl::insert_raw_with_query(const core::document_id& id,
               std::rethrow_exception(err);
             } catch (const transaction_operation_failed& e) {
               return self->op_completed_with_error(std::move(cb), e);
-            } catch (const document_exists& ex) {
+            } catch (const op_exception& ex) {
               return self->op_completed_with_error(std::move(cb), ex);
             } catch (const std::exception& e) {
               return self->op_completed_with_error(
@@ -2939,20 +3293,32 @@ attempt_context_impl::do_get(const core::document_id& id,
 {
   try {
     if (check_expiry_pre_commit(STAGE_GET, id.key())) {
-      return cb(FAIL_EXPIRY, "expired in do_get", std::nullopt);
+      return cb(FAIL_EXPIRY, std::nullopt, "expired in do_get", std::nullopt);
     }
 
+    // Check if we already have a staged insert/replace for this document AND we have the content
+    // for it (i.e. the cluster does not support replace body_with_xattr)
     if (const staged_mutation* own_write = check_for_own_write(id); own_write != nullptr) {
-      CB_ATTEMPT_CTX_LOG_DEBUG(this, "found own-write of mutated doc {}", id);
-      return cb(std::nullopt,
-                std::nullopt,
-                transaction_get_result::create_from(own_write->doc(), own_write->content()));
+      const auto own_write_content = own_write->staged_content();
+      if (own_write_content.has_value()) {
+        CB_ATTEMPT_CTX_LOG_DEBUG(this, "found own-write of mutated doc {}", id);
+        return cb(std::nullopt,
+                  std::nullopt,
+                  std::nullopt,
+                  transaction_get_result{
+                    own_write->id(),
+                    codec::encoded_value{ own_write_content.value(), own_write->staged_flags() },
+                    own_write->cas().value(),
+                    {},
+                    {},
+                  });
+      }
     }
     if (const staged_mutation* own_remove = staged_mutations_->find_remove(id);
         own_remove != nullptr) {
       auto msg = fmt::format("found own-write of removed doc {}", id);
       CB_ATTEMPT_CTX_LOG_DEBUG(this, "{}", msg);
-      return cb(FAIL_DOC_NOT_FOUND, msg, std::nullopt);
+      return cb(FAIL_DOC_NOT_FOUND, std::nullopt, msg, std::nullopt);
     }
 
     return hooks_.before_doc_get(
@@ -2964,7 +3330,7 @@ attempt_context_impl::do_get(const core::document_id& id,
        resolving_missing_atr_entry = std::move(resolving_missing_atr_entry),
        cb = std::forward<Handler>(cb)](auto ec) mutable {
         if (ec) {
-          return cb(ec, "before_doc_get hook raised error", std::nullopt);
+          return cb(ec, std::nullopt, "before_doc_get hook raised error", std::nullopt);
         }
 
         return self->get_doc(
@@ -2975,115 +3341,133 @@ attempt_context_impl::do_get(const core::document_id& id,
            allow_replica,
            resolving_missing_atr_entry = std::move(resolving_missing_atr_entry),
            cb = std::move(cb)](std::optional<error_class> ec,
+                               std::optional<external_exception> cause,
                                const std::optional<std::string>& err_message,
                                std::optional<transaction_get_result> doc) mutable {
             if (!ec && !doc) {
               // it just isn't there.
-              return cb(std::nullopt, std::nullopt, std::nullopt);
+              return cb(std::nullopt, std::nullopt, std::nullopt, std::nullopt);
             }
-            if (!ec) {
-              if (doc->links().is_document_in_transaction()) {
+
+            if (ec) {
+              return cb(ec, cause, err_message, std::nullopt);
+            }
+
+            if (!doc->links().is_document_in_transaction()) {
+              if (doc->links().is_deleted()) {
                 CB_ATTEMPT_CTX_LOG_DEBUG(self,
-                                         "doc {} in transaction, resolving_missing_atr_entry={}",
-                                         *doc,
-                                         resolving_missing_atr_entry.value_or("-"));
-
-                if (resolving_missing_atr_entry.has_value() &&
-                    resolving_missing_atr_entry.value() == doc->links().staged_attempt_id()) {
-                  CB_ATTEMPT_CTX_LOG_DEBUG(self, "doc is in lost pending transaction");
-
-                  if (doc->links().is_document_being_inserted()) {
-                    // this document is being inserted, so should not be visible
-                    // yet
-                    return cb(std::nullopt, std::nullopt, std::nullopt);
-                  }
+                                         "doc not in txn, and is_deleted, so not returning it.");
+                // doc has been deleted, not in txn, so don't return it
+                return cb(std::nullopt, std::nullopt, std::nullopt, std::nullopt);
+              }
+              return cb(std::nullopt, std::nullopt, std::nullopt, doc);
+            }
 
-                  return cb(std::nullopt, std::nullopt, doc);
-                }
+            if (doc->links().staged_attempt_id() == self->id()) {
+              // This is a RYOW, and we can optimise here by not looking up the document's ATR.
 
-                const core::document_id doc_atr_id{ doc->links().atr_bucket_name().value(),
-                                                    doc->links().atr_scope_name().value(),
-                                                    doc->links().atr_collection_name().value(),
-                                                    doc->links().atr_id().value() };
-                active_transaction_record::get_atr(
-                  self->cluster_ref(),
-                  doc_atr_id,
-                  [self, id, allow_replica, doc, cb = std::move(cb)](
-                    std::error_code ec2, std::optional<active_transaction_record> atr) mutable {
-                    if (!ec2 && atr) {
-                      const active_transaction_record& atr_doc = atr.value();
-                      std::optional<atr_entry> entry;
-                      for (const auto& e : atr_doc.entries()) {
-                        if (doc->links().staged_attempt_id().value() == e.attempt_id()) {
-                          entry.emplace(e);
-                          break;
-                        }
+              if (doc->links().is_document_being_removed()) {
+                // The document is being removed by this attempt, return empty.
+                return cb(std::nullopt, std::nullopt, std::nullopt, std::nullopt);
+              }
+
+              // Return the post-transaction version.
+              return cb(std::nullopt,
+                        std::nullopt,
+                        std::nullopt,
+                        transaction_get_result::create_from(
+                          *doc, doc->links().staged_content_json_or_binary()));
+            }
+
+            CB_ATTEMPT_CTX_LOG_DEBUG(self,
+                                     "doc {} in transaction, resolving_missing_atr_entry={}",
+                                     *doc,
+                                     resolving_missing_atr_entry.value_or("-"));
+
+            if (resolving_missing_atr_entry.has_value() &&
+                resolving_missing_atr_entry.value() == doc->links().staged_attempt_id()) {
+              CB_ATTEMPT_CTX_LOG_DEBUG(self, "doc is in lost pending transaction");
+
+              if (doc->links().is_document_being_inserted()) {
+                // this document is being inserted, so should not be visible
+                // yet
+                return cb(std::nullopt, std::nullopt, std::nullopt, std::nullopt);
+              }
+
+              return cb(std::nullopt, std::nullopt, std::nullopt, doc);
+            }
+
+            const core::document_id doc_atr_id{ doc->links().atr_bucket_name().value(),
+                                                doc->links().atr_scope_name().value(),
+                                                doc->links().atr_collection_name().value(),
+                                                doc->links().atr_id().value() };
+            active_transaction_record::get_atr(
+              self->cluster_ref(),
+              doc_atr_id,
+              [self, id, allow_replica, doc, cb = std::move(cb)](
+                std::error_code ec2, std::optional<active_transaction_record> atr) mutable {
+                if (!ec2 && atr) {
+                  const active_transaction_record& atr_doc = atr.value();
+                  std::optional<atr_entry> entry;
+                  for (const auto& e : atr_doc.entries()) {
+                    if (doc->links().staged_attempt_id().value() == e.attempt_id()) {
+                      entry.emplace(e);
+                      break;
+                    }
+                  }
+                  bool ignore_doc = false;
+                  auto content = doc->content();
+                  if (entry) {
+                    if (doc->links().staged_attempt_id() && entry->attempt_id() == self->id()) {
+                      // Attempt is reading its own writes
+                      // This is here as backup, it should be returned
+                      // from the in-memory cache instead
+                      content = doc->links().staged_content_json_or_binary();
+                    } else {
+                      auto err = check_forward_compat(forward_compat_stage::GETS_READING_ATR,
+                                                      entry->forward_compat());
+                      if (err) {
+                        return cb(FAIL_OTHER, err->cause(), err->what(), std::nullopt);
                       }
-                      bool ignore_doc = false;
-                      auto content = doc->content();
-                      if (entry) {
-                        if (doc->links().staged_attempt_id() && entry->attempt_id() == self->id()) {
-                          // Attempt is reading its own writes
-                          // This is here as backup, it should be returned
-                          // from the in-memory cache instead
-                          content = doc->links().staged_content_json_or_binary();
-                        } else {
-                          auto err = check_forward_compat(forward_compat_stage::GETS_READING_ATR,
-                                                          entry->forward_compat());
-                          if (err) {
-                            return cb(FAIL_OTHER, err->what(), std::nullopt);
+                      switch (entry->state()) {
+                        case attempt_state::COMPLETED:
+                        case attempt_state::COMMITTED:
+                          if (doc->links().is_document_being_removed()) {
+                            ignore_doc = true;
+                          } else {
+                            content = doc->links().staged_content_json_or_binary();
                           }
-                          switch (entry->state()) {
-                            case attempt_state::COMPLETED:
-                            case attempt_state::COMMITTED:
-                              if (doc->links().is_document_being_removed()) {
-                                ignore_doc = true;
-                              } else {
-                                content = doc->links().staged_content_json_or_binary();
-                              }
-                              break;
-                            default:
-                              if (doc->links().is_document_being_inserted()) {
-                                // This document is being inserted, so should
-                                // not be visible yet
-                                ignore_doc = true;
-                              }
-                              break;
+                          break;
+                        default:
+                          if (doc->links().is_document_being_inserted()) {
+                            // This document is being inserted, so should
+                            // not be visible yet
+                            ignore_doc = true;
                           }
-                        }
-                      } else {
-                        // failed to get the ATR entry
-                        CB_ATTEMPT_CTX_LOG_DEBUG(self,
-                                                 "could not get ATR entry, checking again with {}",
-                                                 doc->links().staged_attempt_id().value_or("-"));
-                        return self->do_get(
-                          id, allow_replica, doc->links().staged_attempt_id(), cb);
-                      }
-                      if (ignore_doc) {
-                        return cb(std::nullopt, std::nullopt, std::nullopt);
+                          break;
                       }
-                      return cb(std::nullopt,
-                                std::nullopt,
-                                transaction_get_result::create_from(*doc, content));
                     }
-                    // failed to get the ATR
+                  } else {
+                    // failed to get the ATR entry
                     CB_ATTEMPT_CTX_LOG_DEBUG(self,
-                                             "could not get ATR, checking again with {}",
+                                             "could not get ATR entry, checking again with {}",
                                              doc->links().staged_attempt_id().value_or("-"));
                     return self->do_get(id, allow_replica, doc->links().staged_attempt_id(), cb);
-                  });
-              } else {
-                if (doc->links().is_deleted()) {
-                  CB_ATTEMPT_CTX_LOG_DEBUG(self,
-                                           "doc not in txn, and is_deleted, so not returning it.");
-                  // doc has been deleted, not in txn, so don't return it
-                  return cb(std::nullopt, std::nullopt, std::nullopt);
+                  }
+                  if (ignore_doc) {
+                    return cb(std::nullopt, std::nullopt, std::nullopt, std::nullopt);
+                  }
+                  return cb(std::nullopt,
+                            std::nullopt,
+                            std::nullopt,
+                            transaction_get_result::create_from(*doc, content));
                 }
-                return cb(std::nullopt, std::nullopt, doc);
-              }
-            } else {
-              return cb(ec, err_message, std::nullopt);
-            }
+                // failed to get the ATR
+                CB_ATTEMPT_CTX_LOG_DEBUG(self,
+                                         "could not get ATR, checking again with {}",
+                                         doc->links().staged_attempt_id().value_or("-"));
+                return self->do_get(id, allow_replica, doc->links().staged_attempt_id(), cb);
+              });
           });
       });
   } catch (const transaction_operation_failed&) {
@@ -3108,12 +3492,17 @@ execute_lookup(attempt_context_impl* ctx, LookupInRequest& req, Callback&& cb)
         CB_ATTEMPT_CTX_LOG_TRACE(ctx, "get_doc got error {} : {}", resp.ctx.ec().message(), *ec);
         switch (*ec) {
           case FAIL_PATH_NOT_FOUND:
-            return cb(ec, resp.ctx.ec().message(), transaction_get_result::create_from(resp));
+            return cb(ec,
+                      external_exception_from_response(resp),
+                      resp.ctx.ec().message(),
+                      transaction_get_result::create_from(resp));
           default:
-            return cb(ec, resp.ctx.ec().message(), std::nullopt);
+            return cb(
+              ec, external_exception_from_response(resp), resp.ctx.ec().message(), std::nullopt);
         }
       } else {
-        return cb({}, {}, transaction_get_result::create_from(resp));
+        return cb(
+          std::nullopt, std::nullopt, std::nullopt, transaction_get_result::create_from(resp));
       }
     });
 }
@@ -3123,6 +3512,7 @@ void
 attempt_context_impl::get_doc(const core::document_id& id,
                               bool allow_replica,
                               std::function<void(std::optional<error_class>,
+                                                 std::optional<external_exception>,
                                                  std::optional<std::string>,
                                                  std::optional<transaction_get_result>)>&& cb)
 {
@@ -3144,10 +3534,23 @@ attempt_context_impl::get_doc(const core::document_id& id,
 
   try {
     if (allow_replica) {
-      core::operations::lookup_in_any_replica_request req{ id };
-      req.read_preference = couchbase::read_preference::selected_server_group;
-      req.specs = specs;
-      execute_lookup(this, req, cb);
+      cluster_ref().with_bucket_configuration(
+        id.bucket(),
+        [this, id, specs, cb = std::move(cb)](
+          std::error_code ec, const std::shared_ptr<topology::configuration>& config) {
+          if (ec) {
+            cb(FAIL_OTHER,
+               std::nullopt,
+               "failed to check whether access_deleted is supported: " + ec.message(),
+               std::nullopt);
+            return;
+          }
+          core::operations::lookup_in_any_replica_request req{ id };
+          req.read_preference = couchbase::read_preference::selected_server_group_or_all_available;
+          req.specs = specs;
+          req.access_deleted = config->capabilities.supports_subdoc_access_deleted();
+          execute_lookup(this, req, cb);
+        });
     } else {
       core::operations::lookup_in_request req{ id };
       req.access_deleted = true;
@@ -3155,7 +3558,7 @@ attempt_context_impl::get_doc(const core::document_id& id,
       execute_lookup(this, req, cb);
     }
   } catch (const std::exception& e) {
-    return cb(FAIL_OTHER, e.what(), std::nullopt);
+    return cb(FAIL_OTHER, std::nullopt, e.what(), std::nullopt);
   }
 }
 
@@ -3252,6 +3655,7 @@ attempt_context_impl::create_staged_insert_error_handler(const core::document_id
             false,
             [self, id, content, op_id, cb = std::forward<Handler>(cb), error_handler, delay](
               std::optional<error_class> ec3,
+              std::optional<external_exception> /* cause */,
               std::optional<std::string> err_message,
               std::optional<transaction_get_result> doc) mutable {
               if (!ec3) {
@@ -3263,8 +3667,9 @@ attempt_context_impl::create_staged_insert_error_handler(const core::document_id
                     doc->links().is_document_in_transaction(),
                     doc->links().is_deleted());
 
-                  if (auto err = check_forward_compat(forward_compat_stage::WWC_INSERTING_GET,
-                                                      doc->links().forward_compat());
+                  if (auto err = check_forward_compat(
+                        forward_compat_stage::WRITE_WRITE_CONFLICT_INSERTING_GET,
+                        doc->links().forward_compat());
                       err) {
                     return self->op_completed_with_error(std::forward<Handler>(cb), *err);
                   }
@@ -3293,8 +3698,15 @@ attempt_context_impl::create_staged_insert_error_handler(const core::document_id
                       // this is us dealing with resolving an ambiguity.  So, lets
                       // just update the staged_mutation with the correct cas and
                       // continue...
-                      self->staged_mutations_->add(
-                        staged_mutation(*doc, content, staged_mutation_type::INSERT));
+                      self->staged_mutations_->add(staged_mutation{
+                        staged_mutation_type::INSERT,
+                        doc->id(),
+                        doc->cas(),
+                        content.data,
+                        content.flags,
+                        doc->content().flags,
+                        doc->metadata(),
+                      });
                       return self->op_completed_with_callback(std::forward<Handler>(cb), doc);
                     }
                     return self->op_completed_with_error(
@@ -3307,13 +3719,11 @@ attempt_context_impl::create_staged_insert_error_handler(const core::document_id
                   if (doc->links().op() && *doc->links().op() != "insert") {
                     return self->op_completed_with_error(
                       std::forward<Handler>(cb),
-                      transaction_operation_failed(FAIL_DOC_ALREADY_EXISTS,
-                                                   "doc exists, not a staged insert")
-                        .cause(DOCUMENT_EXISTS_EXCEPTION));
+                      document_exists("doc exists, not a staged insert"));
                   }
                   self->check_and_handle_blocking_transactions(
                     *doc,
-                    forward_compat_stage::WWC_INSERTING,
+                    forward_compat_stage::WRITE_WRITE_CONFLICT_INSERTING,
                     [self, id, op_id, content, doc, cb = std::forward<Handler>(cb), delay](
                       std::optional<transaction_operation_failed> err) mutable {
                       if (err) {
@@ -3459,55 +3869,89 @@ attempt_context_impl::create_staged_insert(const core::document_id& id,
 
           CB_ATTEMPT_CTX_LOG_DEBUG(
             self, "inserted doc {} CAS={}, {}", id, resp.cas.value(), resp.ctx.ec().message());
-          std::optional<codec::encoded_value> staged_content_json{};
-          std::optional<codec::encoded_value> staged_content_binary{};
-          if (codec::codec_flags::has_common_flags(content.flags,
-                                                   codec::codec_flags::json_common_flags)) {
-            staged_content_json = std::move(content);
-          } else if (codec::codec_flags::has_common_flags(
-                       content.flags, codec::codec_flags::binary_common_flags)) {
-            staged_content_binary = std::move(content);
-          }
-          transaction_get_result out{
-            id,
-            {},
-            resp.cas.value(),
-            transaction_links{
-              self->atr_id_->key(),
-              id.bucket(),
-              id.scope(),
-              id.collection(),
-              self->overall()->transaction_id(),
-              self->id(),
-              op_id,
-              std::move(staged_content_json),
-              std::move(staged_content_binary),
-              std::nullopt,
-              std::nullopt,
-              std::nullopt,
-              std::nullopt,
-              "insert",
-              std::nullopt,
-              true,
-            },
-            std::nullopt,
-          };
-          self->staged_mutations_->add(staged_mutation{
-            out,
-            // TODO(SA): java SDK checks for
-            // bucket_capability::subdoc_revive_document here
-            out.links().staged_content_json_or_binary(),
-            staged_mutation_type::INSERT,
-          });
-          return self->op_completed_with_callback(std::forward<Handler>(cb),
-                                                  std::optional{ std::move(out) });
+
+          self->supports_replace_body_with_xattr(
+            id.bucket(),
+            [self,
+             id,
+             content = std::move(content),
+             cas,
+             op_id,
+             delay = std::forward<Delay>(delay),
+             resp = std::move(resp),
+             cb = std::forward<Handler>(cb)](auto ec, bool supports) mutable {
+              if (ec) {
+                return self->create_staged_insert_error_handler(
+                  id,
+                  std::move(content),
+                  cas,
+                  std::forward<Delay>(delay),
+                  op_id,
+                  std::forward<Handler>(cb),
+                  FAIL_OTHER,
+                  UNKNOWN,
+                  "failed to check whether replace_body_with_xattr is supported: " + ec.message());
+              }
+
+              std::optional<codec::encoded_value> staged_content_json{};
+              std::optional<codec::encoded_value> staged_content_binary{};
+              if (codec::codec_flags::has_common_flags(content.flags,
+                                                       codec::codec_flags::json_common_flags)) {
+                staged_content_json = content;
+              } else if (codec::codec_flags::has_common_flags(
+                           content.flags, codec::codec_flags::binary_common_flags)) {
+                staged_content_binary = content;
+              }
+
+              transaction_get_result out{
+                id,
+                content,
+                resp.cas.value(),
+                transaction_links{
+                  self->atr_id_->key(),
+                  id.bucket(),
+                  id.scope(),
+                  id.collection(),
+                  self->overall()->transaction_id(),
+                  self->id(),
+                  op_id,
+                  std::move(staged_content_json),
+                  std::move(staged_content_binary),
+                  std::nullopt,
+                  std::nullopt,
+                  std::nullopt,
+                  std::nullopt,
+                  "insert",
+                  std::nullopt,
+                  true,
+                },
+                std::nullopt,
+              };
+
+              auto [staged_content, staged_flags] = out.links().staged_content_json_or_binary();
+
+              self->staged_mutations_->add(staged_mutation{
+                staged_mutation_type::INSERT,
+                id,
+                resp.cas,
+                supports ? std::nullopt
+                         : std::make_optional(staged_content), // We don't store the staged contents
+                                                               // if the cluster supports
+                                                               // replace_body_with_xattr
+                staged_flags,
+                staged_flags,
+                out.metadata(),
+              });
+              return self->op_completed_with_callback(std::forward<Handler>(cb),
+                                                      std::optional{ std::move(out) });
+            });
         });
     });
 }
 
 void
 attempt_context_impl::ensure_open_bucket(const std::string& bucket_name,
-                                         std::function<void(std::error_code)>&& handler)
+                                         std::function<void(std::error_code)>&& handler) const
 {
   if (bucket_name.empty()) {
     CB_LOG_DEBUG("ensure_open_bucket called with empty bucket_name");
@@ -3518,6 +3962,29 @@ attempt_context_impl::ensure_open_bucket(const std::string& bucket_name,
   });
 }
 
+void
+attempt_context_impl::supports_replace_body_with_xattr(
+  const std::string& bucket_name,
+  std::function<void(std::error_code, bool)>&& handler) const
+{
+  cluster_ref().with_bucket_configuration(
+    bucket_name,
+    [handler = std::move(handler)](std::error_code ec,
+                                   const std::shared_ptr<topology::configuration>& config) {
+      if (ec) {
+        handler(ec, {});
+        return;
+      }
+
+      // We use subdoc_revive_document instead of subdoc_replace_body_with_xattr.
+      // The version where subdoc_replace_body_with_xattr was released (7.0) contained a significant
+      // bug.
+      // (https://github.com/couchbaselabs/couchbase-transactions-specs/blob/master/transactions-stages.md#supportsreplacebodywithxattr)
+      handler(
+        {}, config->capabilities.has_bucket_capability(bucket_capability::subdoc_revive_document));
+    });
+}
+
 void
 attempt_context_impl::remove(couchbase::transactions::transaction_get_result doc,
                              couchbase::transactions::async_err_handler&& handler)
@@ -3585,14 +4052,28 @@ attempt_context_impl::query(std::string statement,
             } catch (const transaction_operation_failed& e) {
               return handler(core::impl::make_error(e), {});
             } catch (const op_exception& ex) {
-              return handler(core::impl::make_error(ex.ctx()), {});
+              return handler(core::impl::make_error(ex), {});
             } catch (...) {
               // just in case...
               return handler({ couchbase::errc::transaction_op::generic }, {});
             }
           }
           auto [ctx, res] = core::impl::build_transaction_query_result(*resp);
-          handler(core::impl::make_error(ctx), res);
+          if (ctx.ec()) {
+            // This should have already been converted to an exception by handle_query_error,
+            // which we handle above. Let's return an error here just in case
+            std::string msg = "Txns query error occured that should have been handled further "
+                              "upstream, which might indicate a bug.";
+            if (std::holds_alternative<query_error_context>(ctx.cause())) {
+              return handler({ ctx.ec(),
+                               std::move(msg),
+                               {},
+                               impl::make_error(std::get<query_error_context>(ctx.cause())) },
+                             {});
+            }
+            return handler({ ctx.ec(), std::move(msg) }, {});
+          }
+          return handler({}, res);
         });
 }
 
@@ -3729,4 +4210,10 @@ attempt_context_impl::atr_collection_name(const std::string& coll) const
 {
   overall()->atr_collection(coll);
 }
+
+auto
+attempt_context_impl::expiry_time() const -> std::chrono::steady_clock::time_point
+{
+  return overall()->expiry_time();
+}
 } // namespace couchbase::core::transactions