SERVER-27938 Rename all OperationContext variables to opCtx

This commit is an automated rename of all whole word instances of txn,
_txn, and txnPtr to opCtx, _opCtx, and opCtxPtr, respectively in all
.cpp and .h files in src/mongo.

1 files changed, 20 insertions, 20 deletions

diff --git a/src/mongo/db/commands/index_filter_commands.cpp b/src/mongo/db/commands/index_filter_commands.cpp
index 3ec63ba635c..68230d587af 100644
--- a/src/mongo/db/commands/index_filter_commands.cpp
+++ b/src/mongo/db/commands/index_filter_commands.cpp
@@ -61,7 +61,7 @@ using namespace mongo;
 /**
  * Retrieves a collection's query settings and plan cache from the database.
  */
-static Status getQuerySettingsAndPlanCache(OperationContext* txn,
+static Status getQuerySettingsAndPlanCache(OperationContext* opCtx,
                                            Collection* collection,
                                            const string& ns,
                                            QuerySettings** querySettingsOut,
@@ -115,14 +115,14 @@ using std::unique_ptr;
 IndexFilterCommand::IndexFilterCommand(const string& name, const string& helpText)
     : Command(name), helpText(helpText) {}
 
-bool IndexFilterCommand::run(OperationContext* txn,
+bool IndexFilterCommand::run(OperationContext* opCtx,
                              const string& dbname,
                              BSONObj& cmdObj,
                              int options,
                              string& errmsg,
                              BSONObjBuilder& result) {
     const NamespaceString nss(parseNsCollectionRequired(dbname, cmdObj));
-    Status status = runIndexFilterCommand(txn, nss.ns(), cmdObj, &result);
+    Status status = runIndexFilterCommand(opCtx, nss.ns(), cmdObj, &result);
     return appendCommandStatus(result, status);
 }
 
@@ -160,17 +160,17 @@ ListFilters::ListFilters()
     : IndexFilterCommand("planCacheListFilters",
                          "Displays index filters for all query shapes in a collection.") {}
 
-Status ListFilters::runIndexFilterCommand(OperationContext* txn,
+Status ListFilters::runIndexFilterCommand(OperationContext* opCtx,
                                           const string& ns,
                                           BSONObj& cmdObj,
                                           BSONObjBuilder* bob) {
     // This is a read lock. The query settings is owned by the collection.
-    AutoGetCollectionForRead ctx(txn, NamespaceString(ns));
+    AutoGetCollectionForRead ctx(opCtx, NamespaceString(ns));
 
     QuerySettings* querySettings;
     PlanCache* unused;
     Status status =
-        getQuerySettingsAndPlanCache(txn, ctx.getCollection(), ns, &querySettings, &unused);
+        getQuerySettingsAndPlanCache(opCtx, ctx.getCollection(), ns, &querySettings, &unused);
     if (!status.isOK()) {
         // No collection - return empty array of filters.
         BSONArrayBuilder hintsBuilder(bob->subarrayStart("filters"));
@@ -228,26 +228,26 @@ ClearFilters::ClearFilters()
                          "Clears index filter for a single query shape or, "
                          "if the query shape is omitted, all filters for the collection.") {}
 
-Status ClearFilters::runIndexFilterCommand(OperationContext* txn,
+Status ClearFilters::runIndexFilterCommand(OperationContext* opCtx,
                                            const std::string& ns,
                                            BSONObj& cmdObj,
                                            BSONObjBuilder* bob) {
     // This is a read lock. The query settings is owned by the collection.
-    AutoGetCollectionForRead ctx(txn, NamespaceString(ns));
+    AutoGetCollectionForRead ctx(opCtx, NamespaceString(ns));
 
     QuerySettings* querySettings;
     PlanCache* planCache;
     Status status =
-        getQuerySettingsAndPlanCache(txn, ctx.getCollection(), ns, &querySettings, &planCache);
+        getQuerySettingsAndPlanCache(opCtx, ctx.getCollection(), ns, &querySettings, &planCache);
     if (!status.isOK()) {
         // No collection - do nothing.
         return Status::OK();
     }
-    return clear(txn, querySettings, planCache, ns, cmdObj);
+    return clear(opCtx, querySettings, planCache, ns, cmdObj);
 }
 
 // static
-Status ClearFilters::clear(OperationContext* txn,
+Status ClearFilters::clear(OperationContext* opCtx,
                            QuerySettings* querySettings,
                            PlanCache* planCache,
                            const std::string& ns,
@@ -259,7 +259,7 @@ Status ClearFilters::clear(OperationContext* txn,
     // - clear hints for single query shape when a query shape is described in the
     //   command arguments.
     if (cmdObj.hasField("query")) {
-        auto statusWithCQ = PlanCacheCommand::canonicalize(txn, ns, cmdObj);
+        auto statusWithCQ = PlanCacheCommand::canonicalize(opCtx, ns, cmdObj);
         if (!statusWithCQ.isOK()) {
             return statusWithCQ.getStatus();
         }
@@ -291,7 +291,7 @@ Status ClearFilters::clear(OperationContext* txn,
     querySettings->clearAllowedIndices();
 
     const NamespaceString nss(ns);
-    const ExtensionsCallbackReal extensionsCallback(txn, &nss);
+    const ExtensionsCallbackReal extensionsCallback(opCtx, &nss);
 
     // Remove corresponding entries from plan cache.
     // Admin hints affect the planning process directly. If there were
@@ -312,7 +312,7 @@ Status ClearFilters::clear(OperationContext* txn,
         qr->setSort(entry.sort);
         qr->setProj(entry.projection);
         qr->setCollation(entry.collation);
-        auto statusWithCQ = CanonicalQuery::canonicalize(txn, std::move(qr), extensionsCallback);
+        auto statusWithCQ = CanonicalQuery::canonicalize(opCtx, std::move(qr), extensionsCallback);
         invariantOK(statusWithCQ.getStatus());
         std::unique_ptr<CanonicalQuery> cq = std::move(statusWithCQ.getValue());
 
@@ -329,26 +329,26 @@ SetFilter::SetFilter()
     : IndexFilterCommand("planCacheSetFilter",
                          "Sets index filter for a query shape. Overrides existing filter.") {}
 
-Status SetFilter::runIndexFilterCommand(OperationContext* txn,
+Status SetFilter::runIndexFilterCommand(OperationContext* opCtx,
                                         const std::string& ns,
                                         BSONObj& cmdObj,
                                         BSONObjBuilder* bob) {
     // This is a read lock. The query settings is owned by the collection.
     const NamespaceString nss(ns);
-    AutoGetCollectionForRead ctx(txn, nss);
+    AutoGetCollectionForRead ctx(opCtx, nss);
 
     QuerySettings* querySettings;
     PlanCache* planCache;
     Status status =
-        getQuerySettingsAndPlanCache(txn, ctx.getCollection(), ns, &querySettings, &planCache);
+        getQuerySettingsAndPlanCache(opCtx, ctx.getCollection(), ns, &querySettings, &planCache);
     if (!status.isOK()) {
         return status;
     }
-    return set(txn, querySettings, planCache, ns, cmdObj);
+    return set(opCtx, querySettings, planCache, ns, cmdObj);
 }
 
 // static
-Status SetFilter::set(OperationContext* txn,
+Status SetFilter::set(OperationContext* opCtx,
                       QuerySettings* querySettings,
                       PlanCache* planCache,
                       const string& ns,
@@ -385,7 +385,7 @@ Status SetFilter::set(OperationContext* txn,
         }
     }
 
-    auto statusWithCQ = PlanCacheCommand::canonicalize(txn, ns, cmdObj);
+    auto statusWithCQ = PlanCacheCommand::canonicalize(opCtx, ns, cmdObj);
     if (!statusWithCQ.isOK()) {
         return statusWithCQ.getStatus();
     }