NoSQLBooster - The Smartest GUI Tool and IDE for MongoDB

Usage

NoSQLBooster for MongoDB supports mongoose-like fluent query builder API that enables you to build up a query using chaining syntax, rather than specifying a JSON object. All MongoDB query, projection and aggregate stage operators have a corresponding chainable method. NoSQLBooster for MongoDB also adds a few cursor extension methods to return the translated MongoDB Query shell script(cursor.getShellScript) and saves the underlying aggregation pipeline as a MongoDB readonly view (cursor.saveAsView).

// instead of writing:
db.user.find({age:{$gte:18,$lte:65}},{name:1,age:1,_id:0}).sort({age:-1, name:1});

// we can write:
db.user.where('age').gte(18).lte(65).select('name age -_id').sort("-age name");    

// passing query conditions is permitted too
db.collection.find().where({ name: 'nosqlbooster' })

// chaining
db.collection
    .where('age').gte(18).lte(65)
    .where({ 'name': /^nosqlbooster/i })
    .where('friends').slice(10)

Chaining aggregate stage operator and use cursor.getShellScript to get translated mongo shell script. The $.xxx1().xxx2() method translates chaining MongoDB query operators method to a JSON object.

// aggregation
db.companies.aggregate() 
  .match($.where('founded_year').gte(2000).lte(2010)) //$: operator helper
  .group({_id:"$category_code",count:{$sum:1}})
  .sort('-count')
  .limit(100)
  .getShellScript() //get translated mongo shell script

Operator Helper ($)

NoSQLBooster exposes a new global variable, $, which converts chained MongoDB operator methods into a JSON object. We call it the operator helper. It upgrades the query builder(qb) from previous versions to support all MongoDB operators, not just operators for the db.collection.find methods. You can use it directly in any mongosh method. NoSQLBooster provides a large number of code templates to simplify the input of method parameters. The form of the chained method is also easier to read and error check.

Here are a few simple rules for using operator helper

Except for the $.where("field") method, all the other methods are simple and correspond to an operator of MongoDB. e.g. $.gte(xxx) -> { $gte: xxx }
If the method has only one parameter, a key-value pair is generated directly. e.g. $.gte(5) -> {$gte: 5}.
If the method has more than one parameter, the parameters is converted to an array in the generated JSON object. e.g. $.gte("$f1", 5) -> {$gte: ["$f1", 5] }

Let's take a look at some examples.

print($.gte(18).lte(65)); // Operator Helper ->  { $gte:18, $lte:65 }

print($.gte(18).lte(65).build()); // got plain JSON object, Can be used in non mongosh method,   { $gte:18, $lte:65 }

print($.gte("$age", 18)); // ->  { $gte: ["$age", 18] }

// instead of writing:
db.users.findOne({age:{$gte:18,$lte:65}};

// we can write:
db.users.findOne($.where("age").gte(18).lte(65));


// instead of writing:
db.users.update({_id:1}, {$set: {lastLoginTime: new Date()}, $inc: {numberOfLogins: 1}});

// we can write:
db.users.update({_id:1}, $.set({lastLoginTime: new Date()}).inc({numberOfLogins: 1}));

//instead of writing:
db.inventory.aggregate([{
    $project: {
        item: 1,
        qty: 1,
        qtyGte250Lt500: {
            $and: [{
                $gte: ["$qty", 250]
            }, {
                $lt: ["$qty", 300]
            }]
        },
        _id: 0
    }
}, {
    $limit: 1000
}])

//we can write:
db.inventory.aggregate().project({
    item: 1,
    qty: 1,
    qtyGte250Lt500: $.and($.gte("$qty",250), $.lt("$qty", 300))
    _id: 0
}).limit(1000)

//or
db.inventory.aggregate().project(
    $.where("item",1)
        .where("qty",1)
        .where("qtyGte250Lt500").and($.gte("$qty",250), $.lt("$qty", 300))
        .where("_id",0)
).limit(1000)

We can use getShellScript() method to get equivalent MongoShell Syntax

db.survey.where("results").elemMatch($.where("item").eq("b").where("score").gt(8))
    .getShellScript();

Here is the output

db.survey.find({
          	"results" : {
          		"$elemMatch" : {
          			"item" : "b",
          			"score" : {
          				"$gt" : 8
          			}
          		}
          	}
          })

Pipeline Builder ($.pipelineBuilder)

In previous versions, we have implemented chained aggregate pipeline builder, all MongoDB aggregate stage have a corresponding chainable method.

To create an aggregation pipeline, use the following syntax in the MongoDB Shell:

db.<collection>.aggregate([
  {
    <$stage1>
  },
  {
    <$stage2>
  }
  {
    <$stage3>
  }
  //...
])

We can write in NoSQLBooster:

db.<collection>.aggregate()
  .stage1()
  .stage2()
  .stage3()

In version 8+, we enhanced the use scenario of the chained methods, which you can use it to build the pipeline parameter required in some mongodb shell methods or use it in your code.

//instead of writing:
let pipeline=[
    {
        <$stage1>
    },
    {
        <$stage2>
    }
    {
        <$stage3>
    }
    //...
    ]

//we can write:
pipeline= $.pipelineBuilder.stage1().stage2().stage3()

Let's take a look at an example of creating a readonly view using $.pipelineBuilder.

//instead of writing:
db.createView(
    "firstYearsScoreDesc",
    "students",
    [ { $match: { year: 1 } }, {$sort :{score: -1}} ] //pipeline
)

//we can write:
db.createView(
    "firstYearsScoreDesc",
    "students",
    $.pipelineBuilder.match({year:1}).sort({score: -1})  //pipeline
)

Cursor Extension Methods

cursor.getShellScript()

Cursor.getShellScript() method return the MongoDB find shell script produced by the NoSQLBooster for MongoDB Fluent Query Builder.

For example:

Run the following Fluent query script in NoSQLBooster for MongoDB:

db.user.where('age').gte(18).lte(65)
       .select('name age -_id')
       .sort("-age name")
       .limit(5)
       .skip(100)
       .getShellScript()

We get the MongoDB shell find script :

db.user.find({
            "age" : {
                "$gte" : 18,
                "$lte" : 65
            }
        }, {
            "name" : 1,
            "age" : 1,
            "_id" : 0
        })
       .sort({  "age" : -1,  "name" : 1 })
       .limit(5)
       .skip(100)

Run the following aggregate Fluent Query script in NoSQLBooster for MongoDB:

db.companies.aggregate($.where('founded_year').gte(2000).lte(2010))
            .group({_id:"$category_code",count:{$sum:1}})
            .sort('-count')
            .skip(100)
            .limit(5)
            .getShellScript()

We get the MongoDB shell aggregate script :

db.companies.aggregate(
[
    {
        "$match" : {
            "founded_year" : {
                "$gte" : 2000,
                "$lte" : 2010
            }
        }
    },
    {
        "$group" : {
            "_id" : "$category_code",
            "count" : {
                "$sum" : 1
            }
        }
    },
    {
        "$sort" : {
            "count" : -1
        }
    },
    {
        "$skip" : 100
    },
    {
        "$limit" : 5
    }
])

###cursor.getAggregationPipeline() Cursor.getAggregationPipeline() returns the aggregation pipeline produced by the NoSQLBooster for MongoDB Fluent Query Builder.

db.user.where('age').gte(18).lte(65)
       .select('name age -_id')
       .sort("-age name")
       .limit(5)
       .skip(100)
       .getAggregationPipeline()

We get the following MongoDB shell aggregate pipeline:

[
    {
        "$match" : {
            "age" : {
                "$gte" : 18,
                "$lte" : 65
            }
        }
    },
    {
        "$project" : {
            "name" : 1,
            "age" : 1,
            "_id" : 0
        }
    },
    {
        "$sort" : {
            "age" : -1,
            "name" : 1
        }
    },
    {
        "$skip" : 100
    },
    {
        "$limit" : 5
    }
]

###cursor.saveAsView()

Cursor.saveAsView() method saves find/aggregate cursor as a MongoDB read-only view. The method requires MongoDB 3.4 and above.

db.user.where('age').gte(18).lte(65)
       .select('name age -_id')
       .sort("-age name")
       .limit(5)
       .skip(100)
       .saveAsView("user_view", {dropIfExists:true}) //drop view if it exists.

db.companies.aggregate($.where('founded_year').gte(2000).lte(2010))
            .group({_id:"$category_code",count:{$sum:1}})
            .sort('-count')
            .skip(100)
            .limit(5)
            .saveAsView("companies_view", {dropIfExists:true}) //drop view if it exists.

Query and Projection

###all()

Specifies a $all query condition

db.collection.where('permission').all(['read', 'write'])

MongoDB documentation

###and()

Specifies arguments for a $and condition

db.collection.and([{ color: 'green' }, { status: 'ok' }])

MongoDB documentation

###bitsAllSet()

Specifies arguments for a $bitsAllSet condition, $bitsAllSet matches documents where all of the bit positions given by the query are set (i.e., 1) in the field.

  db.collection.where("a").bitsAllSet([ 1, 5 ])

MongoDB documentation

###bitsAnySet()

Specifies arguments for a $bitsAnySet condition, $bitsAnySet matches documents where any of the bit positions given by the query are set (i.e., 1) in the field.

  db.collection.where("a").bitsAnySet([ 1, 5 ])

MongoDB documentation

###bitsAllClear()

Specifies arguments for a $bitsAllClear condition, $bitsAllClear matches documents where all of the bit positions given by the query are clear (i.e., 0) in the field.

  db.collection.where("a").bitsAllClear([ 1, 5 ])

MongoDB documentation

###bitsAnyClear()

Specifies arguments for a $bitsAnyClear condition, $bitsAnyClear matches documents where any of the bit positions given by the query are clear (i.e., 0) in the field.

  db.collection.where("a").bitsAllClear([ 1, 5 ])

MongoDB documentation

###box()

Specifies a $box condition

var lowerLeft = [40.73083, -73.99756]
var upperRight= [40.741404,  -73.988135]

db.collection.where('location').within().box(lowerLeft, upperRight)

Fluent Query Builder API

Usage

Operator Helper ($)

Pipeline Builder ($.pipelineBuilder)

Cursor Extension Methods

cursor.getShellScript()

Query and Projection

Aggregation Pipeline