diff options
Diffstat (limited to 'src/mongo/db/ops/write_ops_exec.cpp')
| -rw-r--r-- | src/mongo/db/ops/write_ops_exec.cpp | 218 |
1 files changed, 109 insertions, 109 deletions
diff --git a/src/mongo/db/ops/write_ops_exec.cpp b/src/mongo/db/ops/write_ops_exec.cpp index f3f183a60fe..a0d0f067333 100644 --- a/src/mongo/db/ops/write_ops_exec.cpp +++ b/src/mongo/db/ops/write_ops_exec.cpp @@ -83,15 +83,15 @@ MONGO_FP_DECLARE(failAllInserts); MONGO_FP_DECLARE(failAllUpdates); MONGO_FP_DECLARE(failAllRemoves); -void finishCurOp(OperationContext* txn, CurOp* curOp) { +void finishCurOp(OperationContext* opCtx, CurOp* curOp) { try { curOp->done(); long long executionTimeMicros = curOp->totalTimeMicros(); curOp->debug().executionTimeMicros = executionTimeMicros; - recordCurOpMetrics(txn); - Top::get(txn->getServiceContext()) - .record(txn, + recordCurOpMetrics(opCtx); + Top::get(opCtx->getServiceContext()) + .record(opCtx, curOp->getNS(), curOp->getLogicalOp(), 1, // "write locked" @@ -111,16 +111,16 @@ void finishCurOp(OperationContext* txn, CurOp* curOp) { const bool shouldSample = serverGlobalParams.sampleRate == 1.0 ? true - : txn->getClient()->getPrng().nextCanonicalDouble() < serverGlobalParams.sampleRate; + : opCtx->getClient()->getPrng().nextCanonicalDouble() < serverGlobalParams.sampleRate; if (logAll || (shouldSample && logSlow)) { Locker::LockerInfo lockerInfo; - txn->lockState()->getLockerInfo(&lockerInfo); - log() << curOp->debug().report(txn->getClient(), *curOp, lockerInfo.stats); + opCtx->lockState()->getLockerInfo(&lockerInfo); + log() << curOp->debug().report(opCtx->getClient(), *curOp, lockerInfo.stats); } if (shouldSample && curOp->shouldDBProfile()) { - profile(txn, CurOp::get(txn)->getNetworkOp()); + profile(opCtx, CurOp::get(opCtx)->getNetworkOp()); } } catch (const DBException& ex) { // We need to ignore all errors here. We don't want a successful op to fail because of a @@ -135,8 +135,8 @@ void finishCurOp(OperationContext* txn, CurOp* curOp) { */ class LastOpFixer { public: - LastOpFixer(OperationContext* txn, const NamespaceString& ns) - : _txn(txn), _isOnLocalDb(ns.isLocal()) {} + LastOpFixer(OperationContext* opCtx, const NamespaceString& ns) + : _opCtx(opCtx), _isOnLocalDb(ns.isLocal()) {} ~LastOpFixer() { if (_needToFixLastOp && !_isOnLocalDb) { @@ -144,7 +144,7 @@ public: // here. No-op updates will not generate a new lastOp, so we still need the // guard to fire in that case. Operations on the local DB aren't replicated, so they // don't need to bump the lastOp. - replClientInfo().setLastOpToSystemLastOpTime(_txn); + replClientInfo().setLastOpToSystemLastOpTime(_opCtx); } } @@ -161,45 +161,45 @@ public: private: repl::ReplClientInfo& replClientInfo() { - return repl::ReplClientInfo::forClient(_txn->getClient()); + return repl::ReplClientInfo::forClient(_opCtx->getClient()); } - OperationContext* const _txn; + OperationContext* const _opCtx; bool _needToFixLastOp = true; const bool _isOnLocalDb; repl::OpTime _opTimeAtLastOpStart; }; -void assertCanWrite_inlock(OperationContext* txn, const NamespaceString& ns) { - uassert( - ErrorCodes::PrimarySteppedDown, - str::stream() << "Not primary while writing to " << ns.ns(), - repl::ReplicationCoordinator::get(txn->getServiceContext())->canAcceptWritesFor(txn, ns)); - CollectionShardingState::get(txn, ns)->checkShardVersionOrThrow(txn); +void assertCanWrite_inlock(OperationContext* opCtx, const NamespaceString& ns) { + uassert(ErrorCodes::PrimarySteppedDown, + str::stream() << "Not primary while writing to " << ns.ns(), + repl::ReplicationCoordinator::get(opCtx->getServiceContext()) + ->canAcceptWritesFor(opCtx, ns)); + CollectionShardingState::get(opCtx, ns)->checkShardVersionOrThrow(opCtx); } -void makeCollection(OperationContext* txn, const NamespaceString& ns) { +void makeCollection(OperationContext* opCtx, const NamespaceString& ns) { MONGO_WRITE_CONFLICT_RETRY_LOOP_BEGIN { - AutoGetOrCreateDb db(txn, ns.db(), MODE_X); - assertCanWrite_inlock(txn, ns); + AutoGetOrCreateDb db(opCtx, ns.db(), MODE_X); + assertCanWrite_inlock(opCtx, ns); if (!db.getDb()->getCollection(ns.ns())) { // someone else may have beat us to it. - WriteUnitOfWork wuow(txn); - uassertStatusOK(userCreateNS(txn, db.getDb(), ns.ns(), BSONObj())); + WriteUnitOfWork wuow(opCtx); + uassertStatusOK(userCreateNS(opCtx, db.getDb(), ns.ns(), BSONObj())); wuow.commit(); } } - MONGO_WRITE_CONFLICT_RETRY_LOOP_END(txn, "implicit collection creation", ns.ns()); + MONGO_WRITE_CONFLICT_RETRY_LOOP_END(opCtx, "implicit collection creation", ns.ns()); } /** * Returns true if the operation can continue. */ -bool handleError(OperationContext* txn, +bool handleError(OperationContext* opCtx, const DBException& ex, const ParsedWriteOp& wholeOp, WriteResult* out) { - LastError::get(txn->getClient()).setLastError(ex.getCode(), ex.getInfo().msg); - auto& curOp = *CurOp::get(txn); + LastError::get(opCtx->getClient()).setLastError(ex.getCode(), ex.getInfo().msg); + auto& curOp = *CurOp::get(opCtx); curOp.debug().exceptionInfo = ex.getInfo(); if (ErrorCodes::isInterruption(ErrorCodes::Error(ex.getCode()))) { @@ -221,8 +221,8 @@ bool handleError(OperationContext* txn, << demangleName(typeid(ex))); } - ShardingState::get(txn)->onStaleShardVersion( - txn, wholeOp.ns, staleConfigException->getVersionReceived()); + ShardingState::get(opCtx)->onStaleShardVersion( + opCtx, wholeOp.ns, staleConfigException->getVersionReceived()); out->staleConfigException = stdx::make_unique<SendStaleConfigException>(*staleConfigException); return false; @@ -234,7 +234,7 @@ bool handleError(OperationContext* txn, } // namespace -static WriteResult::SingleResult createIndex(OperationContext* txn, +static WriteResult::SingleResult createIndex(OperationContext* opCtx, const NamespaceString& systemIndexes, const BSONObj& spec) { BSONElement nsElement = spec["ns"]; @@ -264,7 +264,7 @@ static WriteResult::SingleResult createIndex(OperationContext* txn, .done(); rpc::CommandRequest cmdRequest(&cmdRequestMsg); rpc::CommandReplyBuilder cmdReplyBuilder; - Command::findCommand("createIndexes")->run(txn, cmdRequest, &cmdReplyBuilder); + Command::findCommand("createIndexes")->run(opCtx, cmdRequest, &cmdReplyBuilder); auto cmdReplyMsg = cmdReplyBuilder.done(); rpc::CommandReply cmdReply(&cmdReplyMsg); auto cmdResult = cmdReply.getCommandReply(); @@ -273,12 +273,12 @@ static WriteResult::SingleResult createIndex(OperationContext* txn, // Unlike normal inserts, it is not an error to "insert" a duplicate index. long long n = cmdResult["numIndexesAfter"].numberInt() - cmdResult["numIndexesBefore"].numberInt(); - CurOp::get(txn)->debug().ninserted += n; + CurOp::get(opCtx)->debug().ninserted += n; return {n}; } -static WriteResult performCreateIndexes(OperationContext* txn, const InsertOp& wholeOp) { +static WriteResult performCreateIndexes(OperationContext* opCtx, const InsertOp& wholeOp) { // Currently this creates each index independently. We could pass multiple indexes to // createIndexes, but there is a lot of complexity involved in doing it correctly. For one // thing, createIndexes only takes indexes to a single collection, but this batch could include @@ -287,15 +287,15 @@ static WriteResult performCreateIndexes(OperationContext* txn, const InsertOp& w // errors or stops at the first one. These could theoretically be worked around, but it doesn't // seem worth it since users that want faster index builds should just use the createIndexes // command rather than a legacy emulation. - LastOpFixer lastOpFixer(txn, wholeOp.ns); + LastOpFixer lastOpFixer(opCtx, wholeOp.ns); WriteResult out; for (auto&& spec : wholeOp.documents) { try { lastOpFixer.startingOp(); - out.results.emplace_back(createIndex(txn, wholeOp.ns, spec)); + out.results.emplace_back(createIndex(opCtx, wholeOp.ns, spec)); lastOpFixer.finishedOpSuccessfully(); } catch (const DBException& ex) { - const bool canContinue = handleError(txn, ex, wholeOp, &out); + const bool canContinue = handleError(opCtx, ex, wholeOp, &out); if (!canContinue) break; } @@ -303,22 +303,22 @@ static WriteResult performCreateIndexes(OperationContext* txn, const InsertOp& w return out; } -static void insertDocuments(OperationContext* txn, +static void insertDocuments(OperationContext* opCtx, Collection* collection, std::vector<BSONObj>::const_iterator begin, std::vector<BSONObj>::const_iterator end) { // Intentionally not using a WRITE_CONFLICT_RETRY_LOOP. That is handled by the caller so it can // react to oversized batches. - WriteUnitOfWork wuow(txn); + WriteUnitOfWork wuow(opCtx); uassertStatusOK(collection->insertDocuments( - txn, begin, end, &CurOp::get(txn)->debug(), /*enforceQuota*/ true)); + opCtx, begin, end, &CurOp::get(opCtx)->debug(), /*enforceQuota*/ true)); wuow.commit(); } /** * Returns true if caller should try to insert more documents. Does nothing else if batch is empty. */ -static bool insertBatchAndHandleErrors(OperationContext* txn, +static bool insertBatchAndHandleErrors(OperationContext* opCtx, const InsertOp& wholeOp, const std::vector<BSONObj>& batch, LastOpFixer* lastOpFixer, @@ -326,27 +326,27 @@ static bool insertBatchAndHandleErrors(OperationContext* txn, if (batch.empty()) return true; - auto& curOp = *CurOp::get(txn); + auto& curOp = *CurOp::get(opCtx); boost::optional<AutoGetCollection> collection; auto acquireCollection = [&] { while (true) { - txn->checkForInterrupt(); + opCtx->checkForInterrupt(); if (MONGO_FAIL_POINT(failAllInserts)) { uasserted(ErrorCodes::InternalError, "failAllInserts failpoint active!"); } - collection.emplace(txn, wholeOp.ns, MODE_IX); + collection.emplace(opCtx, wholeOp.ns, MODE_IX); if (collection->getCollection()) break; collection.reset(); // unlock. - makeCollection(txn, wholeOp.ns); + makeCollection(opCtx, wholeOp.ns); } curOp.raiseDbProfileLevel(collection->getDb()->getProfilingLevel()); - assertCanWrite_inlock(txn, wholeOp.ns); + assertCanWrite_inlock(opCtx, wholeOp.ns); }; try { @@ -355,7 +355,7 @@ static bool insertBatchAndHandleErrors(OperationContext* txn, // First try doing it all together. If all goes well, this is all we need to do. // See Collection::_insertDocuments for why we do all capped inserts one-at-a-time. lastOpFixer->startingOp(); - insertDocuments(txn, collection->getCollection(), batch.begin(), batch.end()); + insertDocuments(opCtx, collection->getCollection(), batch.begin(), batch.end()); lastOpFixer->finishedOpSuccessfully(); globalOpCounters.gotInserts(batch.size()); std::fill_n( @@ -379,7 +379,7 @@ static bool insertBatchAndHandleErrors(OperationContext* txn, if (!collection) acquireCollection(); lastOpFixer->startingOp(); - insertDocuments(txn, collection->getCollection(), it, it + 1); + insertDocuments(opCtx, collection->getCollection(), it, it + 1); lastOpFixer->finishedOpSuccessfully(); out->results.emplace_back(WriteResult::SingleResult{1}); curOp.debug().ninserted++; @@ -390,9 +390,9 @@ static bool insertBatchAndHandleErrors(OperationContext* txn, throw; } } - MONGO_WRITE_CONFLICT_RETRY_LOOP_END(txn, "insert", wholeOp.ns.ns()); + MONGO_WRITE_CONFLICT_RETRY_LOOP_END(opCtx, "insert", wholeOp.ns.ns()); } catch (const DBException& ex) { - bool canContinue = handleError(txn, ex, wholeOp, out); + bool canContinue = handleError(opCtx, ex, wholeOp, out); if (!canContinue) return false; } @@ -401,15 +401,15 @@ static bool insertBatchAndHandleErrors(OperationContext* txn, return true; } -WriteResult performInserts(OperationContext* txn, const InsertOp& wholeOp) { - invariant(!txn->lockState()->inAWriteUnitOfWork()); // Does own retries. - auto& curOp = *CurOp::get(txn); +WriteResult performInserts(OperationContext* opCtx, const InsertOp& wholeOp) { + invariant(!opCtx->lockState()->inAWriteUnitOfWork()); // Does own retries. + auto& curOp = *CurOp::get(opCtx); ON_BLOCK_EXIT([&] { // This is the only part of finishCurOp we need to do for inserts because they reuse the // top-level curOp. The rest is handled by the top-level entrypoint. curOp.done(); - Top::get(txn->getServiceContext()) - .record(txn, + Top::get(opCtx->getServiceContext()) + .record(opCtx, wholeOp.ns.ns(), LogicalOp::opInsert, 1 /* write locked*/, @@ -420,7 +420,7 @@ WriteResult performInserts(OperationContext* txn, const InsertOp& wholeOp) { }); { - stdx::lock_guard<Client> lk(*txn->getClient()); + stdx::lock_guard<Client> lk(*opCtx->getClient()); curOp.setNS_inlock(wholeOp.ns.ns()); curOp.setLogicalOp_inlock(LogicalOp::opInsert); curOp.ensureStarted(); @@ -430,11 +430,11 @@ WriteResult performInserts(OperationContext* txn, const InsertOp& wholeOp) { uassertStatusOK(userAllowedWriteNS(wholeOp.ns)); if (wholeOp.ns.isSystemDotIndexes()) { - return performCreateIndexes(txn, wholeOp); + return performCreateIndexes(opCtx, wholeOp); } - DisableDocumentValidationIfTrue docValidationDisabler(txn, wholeOp.bypassDocumentValidation); - LastOpFixer lastOpFixer(txn, wholeOp.ns); + DisableDocumentValidationIfTrue docValidationDisabler(opCtx, wholeOp.bypassDocumentValidation); + LastOpFixer lastOpFixer(opCtx, wholeOp.ns); WriteResult out; out.results.reserve(wholeOp.documents.size()); @@ -446,7 +446,7 @@ WriteResult performInserts(OperationContext* txn, const InsertOp& wholeOp) { for (auto&& doc : wholeOp.documents) { const bool isLastDoc = (&doc == &wholeOp.documents.back()); - auto fixedDoc = fixDocumentForInsert(txn->getServiceContext(), doc); + auto fixedDoc = fixDocumentForInsert(opCtx->getServiceContext(), doc); if (!fixedDoc.isOK()) { // Handled after we insert anything in the batch to be sure we report errors in the // correct order. In an ordered insert, if one of the docs ahead of us fails, we should @@ -458,14 +458,14 @@ WriteResult performInserts(OperationContext* txn, const InsertOp& wholeOp) { continue; // Add more to batch before inserting. } - bool canContinue = insertBatchAndHandleErrors(txn, wholeOp, batch, &lastOpFixer, &out); + bool canContinue = insertBatchAndHandleErrors(opCtx, wholeOp, batch, &lastOpFixer, &out); batch.clear(); // We won't need the current batch any more. bytesInBatch = 0; if (canContinue && !fixedDoc.isOK()) { globalOpCounters.gotInsert(); canContinue = handleError( - txn, + opCtx, UserException(fixedDoc.getStatus().code(), fixedDoc.getStatus().reason()), wholeOp, &out); @@ -478,13 +478,13 @@ WriteResult performInserts(OperationContext* txn, const InsertOp& wholeOp) { return out; } -static WriteResult::SingleResult performSingleUpdateOp(OperationContext* txn, +static WriteResult::SingleResult performSingleUpdateOp(OperationContext* opCtx, const NamespaceString& ns, const UpdateOp::SingleUpdate& op) { globalOpCounters.gotUpdate(); - auto& curOp = *CurOp::get(txn); + auto& curOp = *CurOp::get(opCtx); { - stdx::lock_guard<Client> lk(*txn->getClient()); + stdx::lock_guard<Client> lk(*opCtx->getClient()); curOp.setNS_inlock(ns.ns()); curOp.setNetworkOp_inlock(dbUpdate); curOp.setLogicalOp_inlock(LogicalOp::opUpdate); @@ -503,18 +503,18 @@ static WriteResult::SingleResult performSingleUpdateOp(OperationContext* txn, request.setUpsert(op.upsert); request.setYieldPolicy(PlanExecutor::YIELD_AUTO); // ParsedUpdate overrides this for $isolated. - ParsedUpdate parsedUpdate(txn, &request); + ParsedUpdate parsedUpdate(opCtx, &request); uassertStatusOK(parsedUpdate.parseRequest()); - ScopedTransaction scopedXact(txn, MODE_IX); + ScopedTransaction scopedXact(opCtx, MODE_IX); boost::optional<AutoGetCollection> collection; while (true) { - txn->checkForInterrupt(); + opCtx->checkForInterrupt(); if (MONGO_FAIL_POINT(failAllUpdates)) { uasserted(ErrorCodes::InternalError, "failAllUpdates failpoint active!"); } - collection.emplace(txn, + collection.emplace(opCtx, ns, MODE_IX, // DB is always IX, even if collection is X. parsedUpdate.isIsolated() ? MODE_X : MODE_IX); @@ -522,21 +522,21 @@ static WriteResult::SingleResult performSingleUpdateOp(OperationContext* txn, break; collection.reset(); // unlock. - makeCollection(txn, ns); + makeCollection(opCtx, ns); } if (collection->getDb()) { curOp.raiseDbProfileLevel(collection->getDb()->getProfilingLevel()); } - assertCanWrite_inlock(txn, ns); + assertCanWrite_inlock(opCtx, ns); auto exec = uassertStatusOK( - getExecutorUpdate(txn, &curOp.debug(), collection->getCollection(), &parsedUpdate)); + getExecutorUpdate(opCtx, &curOp.debug(), collection->getCollection(), &parsedUpdate)); { - stdx::lock_guard<Client> lk(*txn->getClient()); - CurOp::get(txn)->setPlanSummary_inlock(Explain::getPlanSummary(exec.get())); + stdx::lock_guard<Client> lk(*opCtx->getClient()); + CurOp::get(opCtx)->setPlanSummary_inlock(Explain::getPlanSummary(exec.get())); } uassertStatusOK(exec->executePlan()); @@ -544,7 +544,7 @@ static WriteResult::SingleResult performSingleUpdateOp(OperationContext* txn, PlanSummaryStats summary; Explain::getSummaryStats(*exec, &summary); if (collection->getCollection()) { - collection->getCollection()->infoCache()->notifyOfQuery(txn, summary.indexesUsed); + collection->getCollection()->infoCache()->notifyOfQuery(opCtx, summary.indexesUsed); } if (curOp.shouldDBProfile()) { @@ -560,37 +560,37 @@ static WriteResult::SingleResult performSingleUpdateOp(OperationContext* txn, const bool didInsert = !res.upserted.isEmpty(); const long long nMatchedOrInserted = didInsert ? 1 : res.numMatched; - LastError::get(txn->getClient()).recordUpdate(res.existing, nMatchedOrInserted, res.upserted); + LastError::get(opCtx->getClient()).recordUpdate(res.existing, nMatchedOrInserted, res.upserted); return {nMatchedOrInserted, res.numDocsModified, res.upserted}; } -WriteResult performUpdates(OperationContext* txn, const UpdateOp& wholeOp) { - invariant(!txn->lockState()->inAWriteUnitOfWork()); // Does own retries. +WriteResult performUpdates(OperationContext* opCtx, const UpdateOp& wholeOp) { + invariant(!opCtx->lockState()->inAWriteUnitOfWork()); // Does own retries. uassertStatusOK(userAllowedWriteNS(wholeOp.ns)); - DisableDocumentValidationIfTrue docValidationDisabler(txn, wholeOp.bypassDocumentValidation); - LastOpFixer lastOpFixer(txn, wholeOp.ns); + DisableDocumentValidationIfTrue docValidationDisabler(opCtx, wholeOp.bypassDocumentValidation); + LastOpFixer lastOpFixer(opCtx, wholeOp.ns); WriteResult out; out.results.reserve(wholeOp.updates.size()); for (auto&& singleOp : wholeOp.updates) { // TODO: don't create nested CurOp for legacy writes. // Add Command pointer to the nested CurOp. - auto& parentCurOp = *CurOp::get(txn); + auto& parentCurOp = *CurOp::get(opCtx); Command* cmd = parentCurOp.getCommand(); - CurOp curOp(txn); + CurOp curOp(opCtx); { - stdx::lock_guard<Client> lk(*txn->getClient()); + stdx::lock_guard<Client> lk(*opCtx->getClient()); curOp.setCommand_inlock(cmd); } - ON_BLOCK_EXIT([&] { finishCurOp(txn, &curOp); }); + ON_BLOCK_EXIT([&] { finishCurOp(opCtx, &curOp); }); try { lastOpFixer.startingOp(); - out.results.emplace_back(performSingleUpdateOp(txn, wholeOp.ns, singleOp)); + out.results.emplace_back(performSingleUpdateOp(opCtx, wholeOp.ns, singleOp)); lastOpFixer.finishedOpSuccessfully(); } catch (const DBException& ex) { - const bool canContinue = handleError(txn, ex, wholeOp, &out); + const bool canContinue = handleError(opCtx, ex, wholeOp, &out); if (!canContinue) break; } @@ -599,13 +599,13 @@ WriteResult performUpdates(OperationContext* txn, const UpdateOp& wholeOp) { return out; } -static WriteResult::SingleResult performSingleDeleteOp(OperationContext* txn, +static WriteResult::SingleResult performSingleDeleteOp(OperationContext* opCtx, const NamespaceString& ns, const DeleteOp::SingleDelete& op) { globalOpCounters.gotDelete(); - auto& curOp = *CurOp::get(txn); + auto& curOp = *CurOp::get(opCtx); { - stdx::lock_guard<Client> lk(*txn->getClient()); + stdx::lock_guard<Client> lk(*opCtx->getClient()); curOp.setNS_inlock(ns.ns()); curOp.setNetworkOp_inlock(dbDelete); curOp.setLogicalOp_inlock(LogicalOp::opDelete); @@ -622,17 +622,17 @@ static WriteResult::SingleResult performSingleDeleteOp(OperationContext* txn, request.setMulti(op.multi); request.setYieldPolicy(PlanExecutor::YIELD_AUTO); // ParsedDelete overrides this for $isolated. - ParsedDelete parsedDelete(txn, &request); + ParsedDelete parsedDelete(opCtx, &request); uassertStatusOK(parsedDelete.parseRequest()); - txn->checkForInterrupt(); + opCtx->checkForInterrupt(); if (MONGO_FAIL_POINT(failAllRemoves)) { uasserted(ErrorCodes::InternalError, "failAllRemoves failpoint active!"); } - ScopedTransaction scopedXact(txn, MODE_IX); - AutoGetCollection collection(txn, + ScopedTransaction scopedXact(opCtx, MODE_IX); + AutoGetCollection collection(opCtx, ns, MODE_IX, // DB is always IX, even if collection is X. parsedDelete.isIsolated() ? MODE_X : MODE_IX); @@ -640,14 +640,14 @@ static WriteResult::SingleResult performSingleDeleteOp(OperationContext* txn, curOp.raiseDbProfileLevel(collection.getDb()->getProfilingLevel()); } - assertCanWrite_inlock(txn, ns); + assertCanWrite_inlock(opCtx, ns); auto exec = uassertStatusOK( - getExecutorDelete(txn, &curOp.debug(), collection.getCollection(), &parsedDelete)); + getExecutorDelete(opCtx, &curOp.debug(), collection.getCollection(), &parsedDelete)); { - stdx::lock_guard<Client> lk(*txn->getClient()); - CurOp::get(txn)->setPlanSummary_inlock(Explain::getPlanSummary(exec.get())); + stdx::lock_guard<Client> lk(*opCtx->getClient()); + CurOp::get(opCtx)->setPlanSummary_inlock(Explain::getPlanSummary(exec.get())); } uassertStatusOK(exec->executePlan()); @@ -657,7 +657,7 @@ static WriteResult::SingleResult performSingleDeleteOp(OperationContext* txn, PlanSummaryStats summary; Explain::getSummaryStats(*exec, &summary); if (collection.getCollection()) { - collection.getCollection()->infoCache()->notifyOfQuery(txn, summary.indexesUsed); + collection.getCollection()->infoCache()->notifyOfQuery(opCtx, summary.indexesUsed); } curOp.debug().setPlanSummaryMetrics(summary); @@ -667,37 +667,37 @@ static WriteResult::SingleResult performSingleDeleteOp(OperationContext* txn, curOp.debug().execStats = execStatsBob.obj(); } - LastError::get(txn->getClient()).recordDelete(n); + LastError::get(opCtx->getClient()).recordDelete(n); return {n}; } -WriteResult performDeletes(OperationContext* txn, const DeleteOp& wholeOp) { - invariant(!txn->lockState()->inAWriteUnitOfWork()); // Does own retries. +WriteResult performDeletes(OperationContext* opCtx, const DeleteOp& wholeOp) { + invariant(!opCtx->lockState()->inAWriteUnitOfWork()); // Does own retries. uassertStatusOK(userAllowedWriteNS(wholeOp.ns)); - DisableDocumentValidationIfTrue docValidationDisabler(txn, wholeOp.bypassDocumentValidation); - LastOpFixer lastOpFixer(txn, wholeOp.ns); + DisableDocumentValidationIfTrue docValidationDisabler(opCtx, wholeOp.bypassDocumentValidation); + LastOpFixer lastOpFixer(opCtx, wholeOp.ns); WriteResult out; out.results.reserve(wholeOp.deletes.size()); for (auto&& singleOp : wholeOp.deletes) { // TODO: don't create nested CurOp for legacy writes. // Add Command pointer to the nested CurOp. - auto& parentCurOp = *CurOp::get(txn); + auto& parentCurOp = *CurOp::get(opCtx); Command* cmd = parentCurOp.getCommand(); - CurOp curOp(txn); + CurOp curOp(opCtx); { - stdx::lock_guard<Client> lk(*txn->getClient()); + stdx::lock_guard<Client> lk(*opCtx->getClient()); curOp.setCommand_inlock(cmd); } - ON_BLOCK_EXIT([&] { finishCurOp(txn, &curOp); }); + ON_BLOCK_EXIT([&] { finishCurOp(opCtx, &curOp); }); try { lastOpFixer.startingOp(); - out.results.emplace_back(performSingleDeleteOp(txn, wholeOp.ns, singleOp)); + out.results.emplace_back(performSingleDeleteOp(opCtx, wholeOp.ns, singleOp)); lastOpFixer.finishedOpSuccessfully(); } catch (const DBException& ex) { - const bool canContinue = handleError(txn, ex, wholeOp, &out); + const bool canContinue = handleError(opCtx, ex, wholeOp, &out); if (!canContinue) break; } |