Revert "SERVER-19564: Vectorize index write"

This reverts commit 53559aa.

Author: ramonfm

src/mongo/db/catalog/collection.cpp

@@ -434,21 +434,20 @@ Status Collection::_insertDocuments(OperationContext* txn,
     //       under the RecordStore, this feels broken since that should be a
     //       collection access method probably
 
-    // insertRecord(s) will be vectorized in a future patch
-    std::vector<BsonRecord> bsonRecords;
+    // These will be vectorized (insertRecords, indexRecords) in a future patch
     for (vector<BSONObj>::iterator it = begin; it != end; it++) {
         StatusWith<RecordId> loc = _recordStore->insertRecord(
             txn, it->objdata(), it->objsize(), _enforceQuota(enforceQuota));
         if (!loc.isOK())
             return loc.getStatus();
-        BsonRecord bsonRecord = {loc.getValue(), &(*it)};
-        bsonRecords.push_back(bsonRecord);
-
         invariant(RecordId::min() < loc.getValue());
         invariant(loc.getValue() < RecordId::max());
-    }
 
-    return _indexCatalog.indexRecords(txn, bsonRecords);
+        Status status = _indexCatalog.indexRecord(txn, *it, loc.getValue());
+        if (!status.isOK())
+            return status;
+    }
+    return Status::OK();
 }
 
 Status Collection::aboutToDeleteCapped(OperationContext* txn,
@@ -581,10 +580,7 @@ StatusWith<RecordId> Collection::updateDocument(OperationContext* txn,
                 debug->nmoved += 1;
         }
 
-        std::vector<BsonRecord> bsonRecords;
-        BsonRecord bsonRecord = {newLocation.getValue(), &newDoc};
-        bsonRecords.push_back(bsonRecord);
-        Status s = _indexCatalog.indexRecords(txn, bsonRecords);
+        Status s = _indexCatalog.indexRecord(txn, newDoc, newLocation.getValue());
         if (!s.isOK())
             return StatusWith<RecordId>(s);
         invariant(sid == txn->recoveryUnit()->getSnapshotId());

src/mongo/db/catalog/index_catalog.cpp

@@ -1109,38 +1109,21 @@ bool isDupsAllowed(IndexDescriptor* desc) {
 }
 }
 
-Status IndexCatalog::_indexFilteredRecords(OperationContext* txn,
-                                           IndexCatalogEntry* index,
-                                           const std::vector<BsonRecord>& bsonRecords) {
+Status IndexCatalog::_indexRecord(OperationContext* txn,
+                                  IndexCatalogEntry* index,
+                                  const BSONObj& obj,
+                                  const RecordId& loc) {
+    const MatchExpression* filter = index->getFilterExpression();
+    if (filter && !filter->matchesBSON(obj)) {
+        return Status::OK();
+    }
+
     InsertDeleteOptions options;
     options.logIfError = false;
     options.dupsAllowed = isDupsAllowed(index->descriptor());
 
-    for (auto bsonRecord : bsonRecords) {
-        int64_t inserted;
-        invariant(bsonRecord.id != RecordId());
-        Status status = index->accessMethod()->insert(
-            txn, *bsonRecord.docPtr, bsonRecord.id, options, &inserted);
-        if (!status.isOK())
-            return status;
-    }
-    return Status::OK();
-}
-
-Status IndexCatalog::_indexRecords(OperationContext* txn,
-                                   IndexCatalogEntry* index,
-                                   const std::vector<BsonRecord>& bsonRecords) {
-    const MatchExpression* filter = index->getFilterExpression();
-    if (!filter)
-        return _indexFilteredRecords(txn, index, bsonRecords);
-
-    std::vector<BsonRecord> filteredBsonRecords;
-    for (auto bsonRecord : bsonRecords) {
-        if (filter->matchesBSON(*(bsonRecord.docPtr)))
-            filteredBsonRecords.push_back(bsonRecord);
-    }
-
-    return _indexFilteredRecords(txn, index, filteredBsonRecords);
+    int64_t inserted;
+    return index->accessMethod()->insert(txn, obj, loc, options, &inserted);
 }
 
 Status IndexCatalog::_unindexRecord(OperationContext* txn,
@@ -1169,11 +1152,10 @@ Status IndexCatalog::_unindexRecord(OperationContext* txn,
 }
 
 
-Status IndexCatalog::indexRecords(OperationContext* txn,
-                                  const std::vector<BsonRecord>& bsonRecords) {
+Status IndexCatalog::indexRecord(OperationContext* txn, const BSONObj& obj, const RecordId& loc) {
     for (IndexCatalogEntryContainer::const_iterator i = _entries.begin(); i != _entries.end();
          ++i) {
-        Status s = _indexRecords(txn, *i, bsonRecords);
+        Status s = _indexRecord(txn, *i, obj, loc);
         if (!s.isOK())
             return s;
     }

src/mongo/db/catalog/index_catalog.h

@@ -36,7 +36,6 @@
 #include "mongo/db/jsobj.h"
 #include "mongo/db/operation_context.h"
 #include "mongo/db/record_id.h"
-#include "mongo/db/storage/record_store.h"
 #include "mongo/platform/unordered_map.h"
 
 namespace mongo {
@@ -264,7 +263,7 @@ class IndexCatalog {
     // ----- data modifiers ------
 
     // this throws for now
-    Status indexRecords(OperationContext* txn, const std::vector<BsonRecord>& bsonRecords);
+    Status indexRecord(OperationContext* txn, const BSONObj& obj, const RecordId& loc);
 
     void unindexRecord(OperationContext* txn, const BSONObj& obj, const RecordId& loc, bool noWarn);
 
@@ -295,13 +294,10 @@ class IndexCatalog {
 
     void _checkMagic() const;
 
-    Status _indexFilteredRecords(OperationContext* txn,
-                                 IndexCatalogEntry* index,
-                                 const std::vector<BsonRecord>& bsonRecords);
-
-    Status _indexRecords(OperationContext* txn,
-                         IndexCatalogEntry* index,
-                         const std::vector<BsonRecord>& bsonRecords);
+    Status _indexRecord(OperationContext* txn,
+                        IndexCatalogEntry* index,
+                        const BSONObj& obj,
+                        const RecordId& loc);
 
     Status _unindexRecord(OperationContext* txn,
                           IndexCatalogEntry* index,

src/mongo/db/storage/record_store.h

@@ -91,11 +91,6 @@ struct Record {
     RecordData data;
 };
 
-struct BsonRecord {
-    RecordId id;
-    const BSONObj* docPtr;
-};
-
 /**
  * Retrieves Records from a RecordStore.
  *