Docs Menu

Compatibility Changes with Legacy mongo Shell

On this page

  • Deprecated Methods
  • Read Preference Behavior
  • Write Preference Behavior
  • Numeric Values
  • --eval Behavior
  • Limitations on Database Calls

This page describes differences between mongosh and the legacy mongo shell. In addition to the alternatives listed here, you can use the mongocompat snippet to access to legacy mongo shell APIs. Snippets are an experimental feature, for more information, see Snippets.

snippet install mongocompact

The following shell methods are deprecated in mongosh. Instead, use the methods listed in the Alternative Resources column.

Deprecated Method
Alternative Resources
Aggregation stage: $out
No longer required. See Read Operations on a Secondary Node.

When using the legacy mongo shell to connect directly to secondary replica set member, you must run mongo.setReadPref() to enable secondary reads.

When using mongosh to connect directly to a secondary replica set member, you can read from that member if you specify a read preference of either:

To specify a read preference, you can use either:

When using mongosh to connect directly to a secondary replica set member, if your read preference is set to primaryPreferred, secondary or secondaryPreferred it is not required to run rs.secondaryOk().

The following show helper methods always use a read preference of primaryPreferred, even when a different read preference has been specified for the operation:

  • show dbs
  • show databases
  • show collections
  • show tables

In the legacy mongo shell, these operations use the specified read preference.

Retryable writes are enabled by default in mongosh. Retryable writes were disabled by default in the legacy mongo shell. To disable retryable writes, use --retryWrites=false.

The legacy mongo shell stored numerical values as doubles by default. In mongosh numbers are stored as 32 bit integers, Int32, or else as Double if the value cannot be stored as an Int32.

MongoDB Shell continues to support the numeric types that are supported in mongo shell. However, the preferred types have been updated to better align with the MongoDB drivers. See mongosh Data Types for more information.

The preferred types for numeric variables are different in MongoDB Shell than the types suggested in the legacy mongo shell. The types in mongosh better align with the types used by the MongoDB Drivers.

mongo type
mongosh type

Data types may be stored inconsistently if you connect to the same collection using both mongosh and the legacy mongo shell.

See also:

For more information on managing types, refer to the schema validation overview.

mongosh --eval does not quote object keys in its ouptut.

To get output suitable for automated parsing, use EJSON.stringify().

mongosh --quiet --host rs0/centos1104 --port 27500 \
--eval "EJSON.stringify(rs.status() \
m => ({'id':m._id, 'name', 'stateStr':m.stateStr})));" \
| jq

After parsing with jq, the output resembles this:

"id": 0,
"name": "centos1104:27500",
"stateStr": "PRIMARY"
"id": 1,
"name": "centos1104:27502",
"stateStr": "SECONDARY"
"id": 2,
"name": "centos1104:27503",
"stateStr": "SECONDARY"

EJSON has built in formatting options which may eliminate the need for a parser like jq. For example, the following code produces output that is formatted the same as above.

mongosh --quiet --host rs0/centos1104 --port 27500 \
--eval "EJSON.stringify( rs.status() \
({ _id, name, stateStr }) => ({ _id, name, stateStr })), null, 2);"

The results of database queries cannot be passed inside the following contexts:

  • Class constructor functions
  • Non-async generator functions
  • Callbacks to .sort() on an array

To access to the results of database calls, use async functions, async generator functions, or .map().

The following constructors do not work:

// This code will fail
class FindResults {
constructor() {
this.value = db.students.find();
// This code will fail
function listEntries() { return db.students.find(); }
class FindResults {
constructor() {
this.value = listEntries();

Use an async function instead:

class FindResults {
constructor() {
this.value = ( async() => {
return db.students.find();
} )();

You can also create a method that performs a database operation inside a class as an alternative to working with asynchronous JavaScript.

class FindResults {
constructor() { }
init() { this.value = db.students.find(); }

To use this class, first construct a class instance then call the .init() method.

The following generator functions do not work:

// This code will fail
function* FindResults() {
yield db.students.findMany();
// This code will fail
function listEntries() { return db.students.findMany(); }
function* findResults() {
yield listEntries();

Use an async generator function instead:

function listEntries() { return db.students.findMany(); }
async function* findResults() {
yield listEntries();

The following array sort does not work:

// This code will fail
db.getCollectionNames().sort( ( collectionOne, collectionTwo ) => {
return db[ collectionOne ].estimatedDocumentCount() - db[ collectionOne ].estimatedDocumentCount() )
} );

Use .map() instead.

db.getCollectionNames().map( collectionName => {
return { collectionName, size: db[ collectionName ].estimatedDocumentCount() };
} ).sort( ( collectionOne, collectionTwo ) => {
return collectionOne.size - collectionTwo.size;
} ).map( collection => collection.collectionName);

This approach to array sort is often more performant than the equivalent unsupported code.

←  ReferenceData Types →
Give Feedback
© 2022 MongoDB, Inc.


  • Careers
  • Investor Relations
  • Legal Notices
  • Privacy Notices
  • Security Information
  • Trust Center
© 2022 MongoDB, Inc.