MongoDB Tutorial

Handling DataBases

use blog

Inserting (Objects) in MongoDB

• To insert one data item in a collection issue:

  >db.myCollection.insertOne(
    {
      "name": "navindu",
      "age": 22
    }
  )

• To insert several comma-separated data items in a collection issue:

  db.myCollection.insertMany([
    {
    "name": "navindu",
    "age": 22
    },
    {
    "name": "kavindu",
    "age": 20
    },
  
    {
    "name": "john doe",
    "age": 25,
    "location": "colombo"
    }
  ])

• The insert() method is similar to the insertMany() method.

Special Index and Collection Types*

Introduction to the Aggregation Framework*

Updating Documents

To update one or several documents we often rely on $set. Actually, we construct an object where $set is the key and the intended values are $set's value, as in:

{$set: {"my_key": my_value}

Updating documents can be done in three ways in MongoDB:

• update(): updates one or many documents matching the criteria, based on the value set for the boolean parameter multi. If multi is false, the query updates only one record.
• updateOne(): updates the first document found with the matching criteria
• updateMany(): updates all the documents that match the specified criteria

A very simple example

To update someone's age issue: db.myCollection.update({age : 20}, {$set: {age: 23}})

A worked example

Suppose we want to update the exam score to 35 in some document that we inserted above. The query is as follows:

db.grades.updateOne({_id: 1, "scores.type": 'exam'},\

                    {$set:{'scores.$.score': 35}})

Note that the scores field is an array/object, so we use the dot operator to access the fields. To update the value, we need to use the positional operator ($). If the document is updated successfully, you will get an acknowledgement:

{
  acknowledged: true,
  insertedId: null,
  matchedCount: 1,
  modifiedCount: 1,
  upsertedCount: 0
}

Note the parameter upsertedCount. MongoDB uses an optional parameter known as ‘upsert', the value of which can be a boolean (true/false). While writing the update query, if upsert is set to true, the document is inserted if it doesn't exist.

An example with upset set to true

For example, let's try to update a document with _id as 10000 (which doesn't exist), with upsert as true:

db.grades.update(
   { student_id: 10000 },
   { $set:
      {
         class_id: 180, "scores.type": "exam", "scores.score" : 50
      }
   },
   { upsert: true }
)

db.grades.update({_id: 1}, {$unset: {"scores.score": ""}}),\

db.grades.update({_id: 111}, {$inc: {"scores.score": -1}}),\

Deleting/Removing Documents

Analogously to other operations, MongoDB provides deleteOne() and deleteMany() options.

Some common cases:

• To remove a document fulfilling a simple key-value condition, issue: db.myCollection.remove({name: "navindu"});
• To remove just a property (i.e. a key-value pair), issue: db.myCollection.update({name: "navindu"}, {$unset: age});

To remove whole collections you have a choice:

• To remove a whole collection, issue: db.myCollection.remove({});.
• To remove all the documents in a collection, issue: db.myCollection.drop();.

Outputing to and Inputing from a File

You can log all the shell session if you invoked the shell with tee command: mongo | tee session.txt. Or you can use the --eval switch like so: mongo localhost:27017/dbname --eval "printjson(db.MyCollection.find().pretty())" > sample.json.

MongoDB Schema Validation

By default MongoDB has a flexible schema, unlike Relational DataBases. This means that there is no strict schema validation set up initially.

Schema validation rules can be created in order to ensure that all documents in a collection share a similar structure.

MongoDB supports JSON Schema validation. The $jsonSchema operator allows us to define our document structure.

db.createCollection("posts", {
  validator: {
    $jsonSchema: {
      bsonType: "object",
      required: [ "title", "body" ],
      properties: {
        title: {
          bsonType: "string",
          description: "Title of post - Required."
        },
        body: {
          bsonType: "string",
          description: "Body of post - Required."
        },
        category: {
          bsonType: "string",
          description: "Category of post - Optional."
        },
        likes: {
          bsonType: "int",
          description: "Post like count. Must be an integer - Optional."
        },
        tags: {
          bsonType: ["string"],
          description: "Must be an array of strings - Optional."
        },
        date: {
          bsonType: "date",
          description: "Must be a date - Optional."
        }
      }
    }
  }
})

This will create the posts collection in the current database and specify the JSON Schema validation requirements for the collection.

Inputing from a File with mongoimport

Switches --db, --collections, --fields, --fieldFile, --jsonArray are the same as with mongoexport.

Command mongoimport has some ingest switches, too:

--drop

drop collection before inserting documents

--ignoreBlanks

ignore fields with empty values in CSV and TSV

--maintainInsertionOrder

insert documents in the order of their appearance in the input source

-j, --numInsertionWorkers=<number>

number of insert operations to run concurrently (defaults to 1) (default: 1)

--stopOnError

stop importing at first insert/upsert error

--mode=[insert|upsert|merge]

insert: insert only; upsert: insert or replace existing documents; merge: insert or modify existing documents; defaults to insert

--upsertFields=<field>[,<field>]*

comma-separated fields for the query part when --mode is set to upsert or merge

--writeConcern=<write-concern-specifier>

write concern options e.g. --writeConcern majority, --writeConcern '{w: 3, wtimeout: 500, fsync: true, j: true}'

--bypassDocumentValidation

bypass document validation