1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
|
/**
* Copyright (C) 2018-present MongoDB, Inc.
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the Server Side Public License, version 1,
* as published by MongoDB, Inc.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* Server Side Public License for more details.
*
* You should have received a copy of the Server Side Public License
* along with this program. If not, see
* <http://www.mongodb.com/licensing/server-side-public-license>.
*
* As a special exception, the copyright holders give permission to link the
* code of portions of this program with the OpenSSL library under certain
* conditions as described in each individual source file and distribute
* linked combinations including the program with the OpenSSL library. You
* must comply with the Server Side Public License in all respects for
* all of the code used other than as permitted herein. If you modify file(s)
* with this exception, you may extend this exception to your version of the
* file(s), but you are not obligated to do so. If you do not wish to do so,
* delete this exception statement from your version. If you delete this
* exception statement from all source files in the program, then also delete
* it in the license file.
*/
#pragma once
#include <atomic>
#include <memory>
#include <set>
#include "mongo/bson/simple_bsonobj_comparator.h"
#include "mongo/db/field_ref.h"
#include "mongo/db/index/index_descriptor.h"
#include "mongo/db/index/multikey_metadata_access_stats.h"
#include "mongo/db/jsobj.h"
#include "mongo/db/operation_context.h"
#include "mongo/db/record_id.h"
#include "mongo/db/sorter/sorter.h"
#include "mongo/db/storage/sorted_data_interface.h"
#include "mongo/db/yieldable.h"
namespace mongo {
class BSONObjBuilder;
class MatchExpression;
struct UpdateTicket;
struct InsertDeleteOptions;
class SortedDataIndexAccessMethod;
struct CollectionOptions;
/**
* An IndexAccessMethod is the interface through which all the mutation, lookup, and
* traversal of index entries is done. The class is designed so that the underlying index
* data structure is opaque to the caller.
*
* IndexAccessMethods for existing indices are obtained through the system catalog.
*
* We assume the caller has whatever locks required. This interface is not thread safe.
*
*/
class IndexAccessMethod {
IndexAccessMethod(const IndexAccessMethod&) = delete;
IndexAccessMethod& operator=(const IndexAccessMethod&) = delete;
public:
using KeyHandlerFn = std::function<Status(const KeyString::Value&)>;
using RecordIdHandlerFn = std::function<Status(const RecordId&)>;
IndexAccessMethod() = default;
virtual ~IndexAccessMethod() = default;
static std::unique_ptr<IndexAccessMethod> make(OperationContext* opCtx,
const NamespaceString& nss,
const CollectionOptions& collectionOptions,
IndexCatalogEntry* entry,
StringData ident);
/**
* Equivalent to (but shorter and faster than): dynamic_cast<SortedDataIndexAccessMethod*>(this)
*/
virtual SortedDataIndexAccessMethod* asSortedData() {
return nullptr;
}
virtual const SortedDataIndexAccessMethod* asSortedData() const {
return nullptr;
}
//
// Lookup, traversal, and mutation support
//
/**
* Informs the index of inserts, updates, and deletes of records from the indexed collection.
*/
virtual Status insert(OperationContext* opCtx,
SharedBufferFragmentBuilder& pooledBufferBuilder,
const CollectionPtr& coll,
const std::vector<BsonRecord>& bsonRecords,
const InsertDeleteOptions& options,
int64_t* numInserted) = 0;
virtual void remove(OperationContext* opCtx,
SharedBufferFragmentBuilder& pooledBufferBuilder,
const CollectionPtr& coll,
const BSONObj& obj,
const RecordId& loc,
bool logIfError,
const InsertDeleteOptions& options,
int64_t* numDeleted,
CheckRecordId checkRecordId) = 0;
virtual Status update(OperationContext* opCtx,
SharedBufferFragmentBuilder& pooledBufferBuilder,
const BSONObj& oldDoc,
const BSONObj& newDoc,
const RecordId& loc,
const CollectionPtr& coll,
const InsertDeleteOptions& options,
int64_t* numInserted,
int64_t* numDeleted) = 0;
// ------ index level operations ------
/**
* initializes this index
* only called once for the lifetime of the index
* if called multiple times, is an error
*/
virtual Status initializeAsEmpty(OperationContext* opCtx) = 0;
/**
* Validates the index. If 'full' is false, only performs checks which do not traverse the
* index. If 'full' is true, additionally traverses the index and validates its internal
* structure.
*/
virtual IndexValidateResults validate(OperationContext* opCtx, bool full) const = 0;
/**
* Returns the number of keys in the index, traversing the index to do so.
*/
virtual int64_t numKeys(OperationContext* opCtx) const = 0;
/**
* Add custom statistics about this index to BSON object builder, for display.
*
* 'scale' is a scaling factor to apply to all byte statistics.
*
* Returns true if stats were appended.
*/
virtual bool appendCustomStats(OperationContext* opCtx,
BSONObjBuilder* result,
double scale) const = 0;
/**
* @return The number of bytes consumed by this index.
* Exactly what is counted is not defined based on padding, re-use, etc...
*/
virtual long long getSpaceUsedBytes(OperationContext* opCtx) const = 0;
/**
* The number of unused free bytes consumed by this index on disk.
*/
virtual long long getFreeStorageBytes(OperationContext* opCtx) const = 0;
/**
* Attempt compaction to regain disk space if the indexed record store supports
* compaction-in-place.
*/
virtual Status compact(OperationContext* opCtx) = 0;
/**
* Fetches the Ident for this index.
*/
virtual std::shared_ptr<Ident> getSharedIdent() const = 0;
/**
* Sets the Ident for this index.
*/
virtual void setIdent(std::shared_ptr<Ident> newIdent) = 0;
virtual Status applyIndexBuildSideWrite(OperationContext* opCtx,
const CollectionPtr& coll,
const BSONObj& operation,
const InsertDeleteOptions& options,
KeyHandlerFn&& onDuplicateKey,
int64_t* keysInserted,
int64_t* keysDeleted) = 0;
//
// Bulk operations support
//
class BulkBuilder {
public:
virtual ~BulkBuilder() = default;
/**
* Insert into the BulkBuilder as-if inserting into an IndexAccessMethod.
*
* 'saveCursorBeforeWrite' and 'restoreCursorAfterWrite' will be used to save and restore
* the cursor around any constraint violation side table write that may occur, in case a WCE
* occurs internally that would otherwise unposition the cursor.
*
* Note: we pass the cursor down into this insert function so we can limit cursor
* save/restore to around constraints violation side table writes only. Otherwise, we would
* have to save/restore around each insert() call just in case there is a side table write.
*/
virtual Status insert(OperationContext* opCtx,
const CollectionPtr& collection,
const BSONObj& obj,
const RecordId& loc,
const InsertDeleteOptions& options,
const std::function<void()>& saveCursorBeforeWrite,
const std::function<void()>& restoreCursorAfterWrite) = 0;
/**
* Call this when you are ready to finish your bulk work.
* @param dupsAllowed - If false and 'dupRecords' is not null, append with the RecordIds of
* the uninserted duplicates.
* @param yieldIterations - The number of iterations run before each yielding. Will not
* yield if zero.
* @param onDuplicateKeyInserted - Will be called for each duplicate key inserted into the
* index.
* @param onDuplicateRecord - If not nullptr, will be called for each RecordId of uninserted
* duplicate keys.
*/
virtual Status commit(OperationContext* opCtx,
const CollectionPtr& collection,
bool dupsAllowed,
int32_t yieldIterations,
const KeyHandlerFn& onDuplicateKeyInserted,
const RecordIdHandlerFn& onDuplicateRecord) = 0;
virtual const MultikeyPaths& getMultikeyPaths() const = 0;
virtual bool isMultikey() const = 0;
/**
* Persists on disk the keys that have been inserted using this BulkBuilder.
*/
virtual IndexStateInfo persistDataForShutdown() = 0;
protected:
static void countNewBuildInStats();
static void countResumedBuildInStats();
static SorterFileStats* bulkBuilderFileStats();
static SorterTracker* bulkBuilderTracker();
/**
* Abandon the current snapshot and release then reacquire locks. Tests that target the
* behavior of bulk index builds that yield can use failpoints to stall this yield.
*/
static void yield(OperationContext* opCtx,
const Yieldable* yieldable,
const NamespaceString& ns);
};
/**
* Starts a bulk operation.
* You work on the returned BulkBuilder and then call bulk->commit().
* This can return NULL, meaning bulk mode is not available.
*
* It is only legal to initiate bulk when the index is new and empty, or when resuming an index
* build.
*
* maxMemoryUsageBytes: amount of memory consumed before the external sorter starts spilling to
* disk
* stateInfo: the information to use to resume the index build, or boost::none if starting a
* new index build.
*/
virtual std::unique_ptr<BulkBuilder> initiateBulk(
size_t maxMemoryUsageBytes,
const boost::optional<IndexStateInfo>& stateInfo,
StringData dbName) = 0;
};
/**
* Updates are two steps: verify that it's a valid update, and perform it.
* prepareUpdate fills out the UpdateStatus and update actually applies it.
*/
struct UpdateTicket {
bool _isValid{false};
KeyStringSet oldKeys;
KeyStringSet newKeys;
KeyStringSet newMultikeyMetadataKeys;
KeyStringSet removed;
KeyStringSet added;
RecordId loc;
bool dupsAllowed;
// Holds the path components that would cause this index to be multikey as a result of inserting
// 'newKeys'. The 'newMultikeyPaths' vector remains empty if this index doesn't support
// path-level multikey tracking.
MultikeyPaths newMultikeyPaths;
};
/**
* Flags we can set for inserts and deletes (and updates, which are kind of both).
*/
struct InsertDeleteOptions {
// If there's an error, log() it.
bool logIfError = false;
// Are duplicate keys allowed in the index?
bool dupsAllowed = false;
// Only an index builder is allowed to insert into the index while it is building, so only the
// index builder should set this to 'true'.
bool fromIndexBuilder = false;
/**
* Specifies whether getKeys should relax the index constraints or not, in order of most
* permissive to least permissive.
*/
enum class ConstraintEnforcementMode {
// Relax all constraints.
kRelaxConstraints,
// Relax all constraints on documents that don't apply to a partial index.
kRelaxConstraintsUnfiltered,
// Enforce all constraints.
kEnforceConstraints
};
// Should we relax the index constraints?
ConstraintEnforcementMode getKeysMode = ConstraintEnforcementMode::kEnforceConstraints;
};
/**
* Provides implementations for many functions in the IndexAccessMethod interface that will be
* shared across concrete implementations.
*
* IndexCatalogEntry owns an instance of IndexAccessMethod; an IndexCatalogEntry is also required
* for the initialization and core functionality of this abstract class. To avoid any circular
* dependencies, it is important that IndexAccessMethod remain an interface.
*/
class SortedDataIndexAccessMethod : public IndexAccessMethod {
SortedDataIndexAccessMethod(const SortedDataIndexAccessMethod&) = delete;
SortedDataIndexAccessMethod& operator=(const SortedDataIndexAccessMethod&) = delete;
public:
//
// SortedData-specific functions
//
/**
* Splits the sets 'left' and 'right' into two sets, the first containing the elements that
* only appeared in 'left', and the second containing only elements that appeared in 'right'.
*
* Note this considers objects which are not identical as distinct objects. For example,
* setDifference({BSON("a" << 0.0)}, {BSON("a" << 0LL)}) would result in the pair
* ( {BSON("a" << 0.0)}, {BSON("a" << 0LL)} ).
*/
static std::pair<KeyStringSet, KeyStringSet> setDifference(const KeyStringSet& left,
const KeyStringSet& right);
SortedDataIndexAccessMethod(const IndexCatalogEntry* btreeState,
std::unique_ptr<SortedDataInterface> btree);
/**
* Specifies whether getKeys is being used in the context of creating new keys, deleting
* or validating existing keys.
*/
enum class GetKeysContext { kRemovingKeys, kAddingKeys, kValidatingKeys };
/**
* Fills 'keys' with the keys that should be generated for 'obj' on this index.
* Based on 'mode', it will honor or ignore index constraints, e.g. duplicated key, key too
* long, and geo index parsing errors. The ignoring of constraints is for replication due to
* idempotency reasons. In those cases, the generated 'keys' will be empty.
*
* If the 'multikeyPaths' pointer is non-null, then it must point to an empty vector. If this
* index type supports tracking path-level multikey information, then this function resizes
* 'multikeyPaths' to have the same number of elements as the index key pattern and fills each
* element with the prefixes of the indexed field that would cause this index to be multikey as
* a result of inserting 'keys'.
*
* If the 'multikeyMetadataKeys' pointer is non-null, then the function will populate the
* BSONObjSet with any multikey metadata keys generated while processing the document. These
* keys are not associated with the document itself, but instead represent multi-key path
* information that must be stored in a reserved keyspace within the index.
*
* If any key generation errors are encountered and suppressed due to the provided GetKeysMode,
* 'onSuppressedErrorFn' is called.
*/
using OnSuppressedErrorFn = std::function<void(
Status status, const BSONObj& obj, const boost::optional<RecordId>& loc)>;
void getKeys(OperationContext* opCtx,
const CollectionPtr& collection,
SharedBufferFragmentBuilder& pooledBufferBuilder,
const BSONObj& obj,
InsertDeleteOptions::ConstraintEnforcementMode mode,
GetKeysContext context,
KeyStringSet* keys,
KeyStringSet* multikeyMetadataKeys,
MultikeyPaths* multikeyPaths,
const boost::optional<RecordId>& id,
OnSuppressedErrorFn&& onSuppressedError = nullptr) const;
/**
* Inserts the specified keys into the index. Does not attempt to determine whether the
* insertion of these keys should cause the index to become multikey. The 'numInserted' output
* parameter, if non-nullptr, will be reset to the number of keys inserted by this function
* call, or to zero in the case of either a non-OK return Status or an empty 'keys' argument.
*/
Status insertKeys(
OperationContext* opCtx,
const CollectionPtr& coll,
const KeyStringSet& keys,
const InsertDeleteOptions& options,
KeyHandlerFn&& onDuplicateKey,
int64_t* numInserted,
IncludeDuplicateRecordId includeDuplicateRecordId = IncludeDuplicateRecordId::kOff);
/**
* Inserts the specified keys into the index. and determines whether these keys should cause the
* index to become multikey. If so, this method also handles the task of marking the index as
* multikey in the catalog, and sets the path-level multikey information if applicable.
*/
Status insertKeysAndUpdateMultikeyPaths(
OperationContext* opCtx,
const CollectionPtr& coll,
const KeyStringSet& keys,
const KeyStringSet& multikeyMetadataKeys,
const MultikeyPaths& multikeyPaths,
const InsertDeleteOptions& options,
KeyHandlerFn&& onDuplicateKey,
int64_t* numInserted,
IncludeDuplicateRecordId includeDuplicateRecordId = IncludeDuplicateRecordId::kOff);
/**
* Analogous to insertKeys above, but remove the keys instead of inserting them.
* 'numDeleted' will be set to the number of keys removed from the index for the provided keys.
*/
Status removeKeys(OperationContext* opCtx,
const KeyStringSet& keys,
const InsertDeleteOptions& options,
int64_t* numDeleted);
/**
* Gets the keys of the documents 'from' and 'to' and prepares them for the update.
* Provides a ticket for actually performing the update.
*/
void prepareUpdate(OperationContext* opCtx,
const CollectionPtr& collection,
const BSONObj& from,
const BSONObj& to,
const RecordId& loc,
const InsertDeleteOptions& options,
UpdateTicket* ticket) const;
/**
* Perform a validated update. The keys for the 'from' object will be removed, and the keys
* for the object 'to' will be added. Returns OK if the update succeeded, failure if it did
* not. If an update does not succeed, the index will be unmodified, and the keys for
* 'from' will remain. Assumes that the index has not changed since prepareUpdate was
* called. If the index was changed, we may return an error, as our ticket may have been
* invalidated.
*
* 'numInserted' will be set to the number of keys inserted into the index for the document.
* 'numDeleted' will be set to the number of keys removed from the index for the document.
*/
Status doUpdate(OperationContext* opCtx,
const CollectionPtr& coll,
const UpdateTicket& ticket,
int64_t* numInserted,
int64_t* numDeleted);
RecordId findSingle(OperationContext* opCtx,
const CollectionPtr& collection,
const BSONObj& key) const;
/**
* Returns an unpositioned cursor over 'this' index.
*/
std::unique_ptr<SortedDataInterface::Cursor> newCursor(OperationContext* opCtx,
bool isForward = true) const;
/**
* Given the set of keys, multikeyMetadataKeys and multikeyPaths generated by a particular
* document, return 'true' if the index should be marked as multikey and 'false' otherwise.
*/
virtual bool shouldMarkIndexAsMultikey(size_t numberOfKeys,
const KeyStringSet& multikeyMetadataKeys,
const MultikeyPaths& multikeyPaths) const;
/**
* Provides direct access to the SortedDataInterface. This should not be used to insert
* documents into an index, except for testing purposes.
*/
SortedDataInterface* getSortedDataInterface() const {
return _newInterface.get();
}
//
// Implementations of general IndexAccessMethod API.
//
SortedDataIndexAccessMethod* asSortedData() final {
return this;
}
const SortedDataIndexAccessMethod* asSortedData() const final {
return this;
}
Status insert(OperationContext* opCtx,
SharedBufferFragmentBuilder& pooledBufferBuilder,
const CollectionPtr& coll,
const std::vector<BsonRecord>& bsonRecords,
const InsertDeleteOptions& options,
int64_t* numInserted) final;
void remove(OperationContext* opCtx,
SharedBufferFragmentBuilder& pooledBufferBuilder,
const CollectionPtr& coll,
const BSONObj& obj,
const RecordId& loc,
bool logIfError,
const InsertDeleteOptions& options,
int64_t* numDeleted,
CheckRecordId checkRecordId) final;
Status update(OperationContext* opCtx,
SharedBufferFragmentBuilder& pooledBufferBuilder,
const BSONObj& oldDoc,
const BSONObj& newDoc,
const RecordId& loc,
const CollectionPtr& coll,
const InsertDeleteOptions& options,
int64_t* numInserted,
int64_t* numDeleted) final;
Status initializeAsEmpty(OperationContext* opCtx) final;
IndexValidateResults validate(OperationContext* opCtx, bool full) const final;
int64_t numKeys(OperationContext* opCtx) const final;
bool appendCustomStats(OperationContext* opCtx,
BSONObjBuilder* result,
double scale) const final;
long long getSpaceUsedBytes(OperationContext* opCtx) const final;
long long getFreeStorageBytes(OperationContext* opCtx) const final;
Status compact(OperationContext* opCtx) final;
std::shared_ptr<Ident> getSharedIdent() const final;
void setIdent(std::shared_ptr<Ident> newIdent) final;
Status applyIndexBuildSideWrite(OperationContext* opCtx,
const CollectionPtr& coll,
const BSONObj& operation,
const InsertDeleteOptions& options,
KeyHandlerFn&& onDuplicateKey,
int64_t* keysInserted,
int64_t* keysDeleted) final;
std::unique_ptr<BulkBuilder> initiateBulk(size_t maxMemoryUsageBytes,
const boost::optional<IndexStateInfo>& stateInfo,
StringData dbName) final;
protected:
/**
* Perform some initial validation on the document to ensure it can be indexed before calling
* the implementation-specific 'doGetKeys' method.
*/
virtual void validateDocument(const CollectionPtr& collection,
const BSONObj& obj,
const BSONObj& keyPattern) const;
/**
* Fills 'keys' with the keys that should be generated for 'obj' on this index.
*
* If the 'multikeyPaths' pointer is non-null, then it must point to an empty vector. If this
* index type supports tracking path-level multikey information, then this function resizes
* 'multikeyPaths' to have the same number of elements as the index key pattern and fills each
* element with the prefixes of the indexed field that would cause this index to be multikey as
* a result of inserting 'keys'.
*
* If the 'multikeyMetadataKeys' pointer is non-null, then the function will populate the
* BSONObjSet with any multikey metadata keys generated while processing the document. These
* keys are not associated with the document itself, but instead represent multi-key path
* information that must be stored in a reserved keyspace within the index.
*/
virtual void doGetKeys(OperationContext* opCtx,
const CollectionPtr& collection,
SharedBufferFragmentBuilder& pooledBufferBuilder,
const BSONObj& obj,
GetKeysContext context,
KeyStringSet* keys,
KeyStringSet* multikeyMetadataKeys,
MultikeyPaths* multikeyPaths,
const boost::optional<RecordId>& id) const = 0;
const IndexCatalogEntry* const _indexCatalogEntry; // owned by IndexCatalog
const IndexDescriptor* const _descriptor;
private:
class BulkBuilderImpl;
/**
* Removes a single key from the index.
*
* Used by remove() only.
*/
void removeOneKey(OperationContext* opCtx, const KeyString::Value& keyString, bool dupsAllowed);
/**
* While inserting keys into index (from external sorter), if a duplicate key is detected
* (when duplicates are not allowed), 'onDuplicateRecord' will be called if passed, otherwise a
* DuplicateKey error will be returned.
*/
Status _handleDuplicateKey(OperationContext* opCtx,
const KeyString::Value& dataKey,
const RecordIdHandlerFn& onDuplicateRecord);
Status _indexKeysOrWriteToSideTable(OperationContext* opCtx,
const CollectionPtr& coll,
const KeyStringSet& keys,
const KeyStringSet& multikeyMetadataKeys,
const MultikeyPaths& multikeyPaths,
const BSONObj& obj,
const InsertDeleteOptions& options,
int64_t* keysInsertedOut);
void _unindexKeysOrWriteToSideTable(OperationContext* opCtx,
const NamespaceString& ns,
const KeyStringSet& keys,
const BSONObj& obj,
bool logIfError,
int64_t* keysDeletedOut,
InsertDeleteOptions options,
CheckRecordId checkRecordId);
const std::unique_ptr<SortedDataInterface> _newInterface;
};
} // namespace mongo
|