feat: remove parallelCollectionScan helper

This command was deprecated in 4.2, and provides no actual benefit
for users on WiredTiger.

NODE-2713

Author: mbroadst

src/collection.ts

@@ -22,13 +22,7 @@ import ChangeStream = require('./change_stream');
 import WriteConcern = require('./write_concern');
 import ReadConcern = require('./read_concern');
 import { AggregationCursor, CommandCursor } from './cursor';
-import {
-  ensureIndex,
-  group,
-  parallelCollectionScan,
-  save,
-  checkForAtomicOperators
-} from './operations/collection_ops';
+import { ensureIndex, group, save, checkForAtomicOperators } from './operations/collection_ops';
 import { removeDocuments, updateDocuments } from './operations/common_functions';
 import AggregateOperation = require('./operations/aggregate');
 import BulkWriteOperation = require('./operations/bulk_write');
@@ -75,7 +69,6 @@ interface Collection {
   ensureIndex(fieldOrSpec: any, options: any, callback: any): void;
   count(query: any, options: any, callback: any): void;
   findAndRemove(query: any, sort: any, options: any, callback: any): void;
-  parallelCollectionScan(options: any, callback: any): void;
   group(
     keys: any,
     condition: any,
@@ -2131,54 +2124,6 @@ Collection.prototype.findAndRemove = deprecate(function(
 },
 'collection.findAndRemove is deprecated. Use findOneAndDelete instead.');
 
-/**
- * The callback format for results
- *
- * @callback Collection~parallelCollectionScanCallback
- * @param {MongoError} error An error instance representing the error during the execution.
- * @param {Cursor[]} cursors A list of cursors returned allowing for parallel reading of collection.
- */
-
-/**
- * Return N number of parallel cursors for a collection allowing parallel reading of entire collection. There are
- * no ordering guarantees for returned results.
- *
- * @function
- * @param {object} [options] Optional settings.
- * @param {(ReadPreference|string)} [options.readPreference] The preferred read preference (ReadPreference.PRIMARY, ReadPreference.PRIMARY_PREFERRED, ReadPreference.SECONDARY, ReadPreference.SECONDARY_PREFERRED, ReadPreference.NEAREST).
- * @param {number} [options.batchSize=1000] Set the batchSize for the getMoreCommand when iterating over the query results.
- * @param {number} [options.numCursors=1] The maximum number of parallel command cursors to return (the number of returned cursors will be in the range 1:numCursors)
- * @param {boolean} [options.raw=false] Return all BSON documents as Raw Buffer documents.
- * @param {Collection~parallelCollectionScanCallback} [callback] The command result callback
- * @returns {Promise<void>} returns Promise if no callback passed
- */
-Collection.prototype.parallelCollectionScan = deprecate(function(
-  this: any,
-  options: any,
-  callback: Function
-) {
-  if (typeof options === 'function') (callback = options), (options = { numCursors: 1 });
-  // Set number of cursors to 1
-  options.numCursors = options.numCursors || 1;
-  options.batchSize = options.batchSize || 1000;
-
-  options = Object.assign({}, options);
-  // Ensure we have the right read preference inheritance
-  options.readPreference = ReadPreference.resolve(this, options);
-
-  if (options.session) {
-    options.session = undefined;
-  }
-
-  return executeLegacyOperation(
-    this.s.topology,
-    parallelCollectionScan,
-    [this, options, callback],
-    { skipSessions: true }
-  );
-},
-'parallelCollectionScan is deprecated in MongoDB v4.1');
-
 /**
  * Run a group command across a collection
  *

src/operations/collection_ops.ts

@@ -1,5 +1,5 @@
 import ReadPreference = require('../read_preference');
-import { Code, Long } from '../bson';
+import { Code } from '../bson';
 import { MongoError } from '../error';
 import { insertDocuments, updateDocuments } from './common_functions';
 import {
@@ -285,57 +285,6 @@ function indexInformation(coll: any, options?: object, callback?: Function) {
   indexInformationDb(coll.s.db, coll.collectionName, options, callback);
 }
 
-/**
- * Return N parallel cursors for a collection to allow parallel reading of the entire collection. There are
- * no ordering guarantees for returned results.
- *
- * @function
- * @param {Collection} coll Collection instance.
- * @param {any} [options] Optional settings. See Collection.prototype.parallelCollectionScan for a list of options.
- * @param {Collection~parallelCollectionScanCallback} [callback] The command result callback
- */
-function parallelCollectionScan(coll: any, options?: any, callback?: Function) {
-  // Create command object
-  const commandObject = {
-    parallelCollectionScan: coll.collectionName,
-    numCursors: options.numCursors
-  };
-
-  // Do we have a readConcern specified
-  decorateWithReadConcern(commandObject, coll, options);
-
-  // Store the raw value
-  const raw = options.raw;
-  delete options['raw'];
-
-  // Execute the command
-  executeCommand(coll.s.db, commandObject, options, (err?: any, result?: any) => {
-    if (err) return handleCallback(callback!, err, null);
-    if (result == null)
-      return handleCallback(
-        callback!,
-        new Error('no result returned for parallelCollectionScan'),
-        null
-      );
-
-    options = Object.assign({ explicitlyIgnoreSession: true }, options);
-
-    const cursors = [];
-    // Add the raw back to the option
-    if (raw) options.raw = raw;
-    // Create command cursors for each item
-    for (let i = 0; i < result.cursors.length; i++) {
-      const rawId = result.cursors[i].cursor.id;
-      // Convert cursorId to Long if needed
-      const cursorId = typeof rawId === 'number' ? Long.fromNumber(rawId) : rawId;
-      // Add a command cursor
-      cursors.push(coll.s.topology.cursor(coll.namespace, cursorId, options));
-    }
-
-    handleCallback(callback!, null, cursors);
-  });
-}
-
 /**
  * Save a document.
  *
@@ -377,6 +326,5 @@ export {
   indexes,
   indexExists,
   indexInformation,
-  parallelCollectionScan,
   save
 };

src/sessions.ts

@@ -678,14 +678,7 @@ class ServerSessionPool {
  * @param {any} [options]
  */
 function commandSupportsReadConcern(command: any, options?: any) {
-  if (
-    command.aggregate ||
-    command.count ||
-    command.distinct ||
-    command.find ||
-    command.parallelCollectionScan ||
-    command.geoNear
-  ) {
+  if (command.aggregate || command.count || command.distinct || command.find || command.geoNear) {
     return true;
   }
 

test/functional/core/operations.test.js

@@ -349,78 +349,6 @@ describe('Operation tests', function() {
     }
   });
 
-  it('should correctly execute query against cursorId', {
-    metadata: {
-      requires: {
-        mongodb: '>=2.6.0 < 4.1.x',
-        topology: ['single', 'replicaset']
-      }
-    },
-
-    test: function(done) {
-      var self = this;
-      const config = this.configuration;
-      const server = config.newTopology();
-
-      // Add event listeners
-      server.on('connect', function(_server) {
-        // Execute the write
-        _server.insert(
-          f('%s.inserts11', self.configuration.db),
-          [{ a: 1 }, { a: 2 }, { a: 3 }],
-          {
-            writeConcern: { w: 1 },
-            ordered: true
-          },
-          function(insertErr, insertResults) {
-            expect(insertErr).to.be.null;
-            expect(insertResults.result.n).to.equal(3);
-
-            // Execute the command
-            _server.command(
-              f('%s.$cmd', self.configuration.db),
-              { parallelCollectionScan: 'inserts11', numCursors: 1 },
-              function(cmdErr, cmdRes) {
-                expect(cmdErr).to.be.null;
-                expect(cmdRes).to.not.be.null;
-
-                // Create cursor from parallel collection scan cursor id
-                var cursor = _server.cursor(
-                  f('%s.inserts11', self.configuration.db),
-                  cmdRes.result.cursors[0].cursor.id,
-                  { documents: cmdRes.result.cursors[0].cursor.firstBatch }
-                );
-
-                // Execute next
-                cursor._next(function(cursorErr, cursorD) {
-                  expect(cursorErr).to.be.null;
-                  expect(cursorD.a).to.equal(1);
-
-                  // Execute next
-                  cursor._next(function(secondCursorErr, secondCursorD) {
-                    expect(secondCursorErr).to.be.null;
-                    expect(secondCursorD.a).to.equal(2);
-
-                    cursor._next(function(thirdCursorErr, thirdCursorD) {
-                      expect(thirdCursorErr).to.be.null;
-                      expect(thirdCursorD.a).to.equal(3);
-
-                      // Destroy the server connection
-                      _server.destroy(done);
-                    });
-                  });
-                });
-              }
-            );
-          }
-        );
-      });
-
-      // Start connection
-      server.connect();
-    }
-  });
-
   it('should correctly kill command cursor', {
     metadata: {
       requires: {