Knowledge Base

This page is read only. You can view the source, but not change it. Ask your administrator if you think this is wrong.
====== MongoDB Quick Start, in Docker ======

These instructions configure a server instance named mongo-test, running MongoDB version 4.4.0 in a basic Ubuntu Bionic image. My host machine is running Ubuntu. I’m assuming you’ve already installed Docker. If not, you might want to check out [[:docker_linux|this article]].

<WRAP center round tip 60%>
You’ll probably need to sudo your docker commands.
</WRAP>

===== Basics =====

Start a server instance:

<code bash>
docker run -p 27017:27017 --name mongo-test -d mongo:4.4.0-bionic
</code>

<WRAP center round important 60%>
The port mapping (-p 27017:27017) is important. It allows you to connect to the running instance from your host machine.
</WRAP>

A running instance can stopped with this:

<code bash>
docker stop mongo-test
</code>

And then started (or restarted) with this:

<code bash>
docker restart mongo-test
</code>

Open a bash shell in the running instance:

<code bash>
docker exec -it mongo-test bash
</code>

View MongoDB log files for the running instance:

<code bash>
docker logs mongo-test
</code>

===== Running Mongo Shell =====

You can run an interactive Mongo Shell a couple of ways.

==== Inside the running instance ====

First, open a bash shell inside the instance:

<code bash>
docker exec -it mongo-test bash
</code>

Then, run Mongo Shell:

<code bash>
mongo
</code>

==== From the host machine ====

First, install the MongoDB client tools:

<code bash>
sudo apt install mongodb-clients
</code>

Then, you can do this:

<code bash>
mongo --host localhost
</code>

===== Using Mongo Shell =====

==== List Databases ====

<code>
> show dbs
admin   0.000GB
config  0.000GB
local   0.000GB
</code>

==== Use Database ====

MongoDB doesn’t provide an explicit command for creating databases. A database will automatically be created the first time you try to use it (and add data).

Use a database called 'testdb':

<code>
> use testdb
switched to db testdb
</code>

In its simplest form, a database in MongoDB consists of two items:

  - A **document**, which contains data, and,
  - A **collection**, which is a container of documents.

A document is a data structure composed of field and value pairs. It’s a JSON object that MongoDB stores on disk in binary (BSON) format.

==== Drop Database ====

If you need to drop a database that’s already been created, you switch to it ('use'), then issue a dropDatabase command:

<code>
> show dbs
admin   0.000GB
config  0.000GB
local   0.000GB
testdb  0.000GB

> use testdb
switched to db testdb

> db.dropDatabase()
{ "dropped" : "testdb", "ok" : 1 }

> show dbs
admin   0.000GB
config  0.000GB
local   0.000GB
</code>

==== Add Data ====

Let’s add some data documents to testdb, in a collection called ‘people’:

<code>
> use testdb
switched to db testdb

> db.people.insert( {firstName: 'John', lastName: 'Smith'} )
WriteResult({ "nInserted" : 1 })

> db.people.insert( {firstName: 'Bob', lastName: 'Jones'} )
WriteResult({ "nInserted" : 1 })

> db.people.find()
{ "_id" : ObjectId("5f4bc4dd54e2c67896143097"), "firstName" : "John", "lastName" : "Smith" }
{ "_id" : ObjectId("5f4bc4e354e2c67896143098"), "firstName" : "Bob", "lastName" : "Jones" }
</code>

The data in the insert commands is formatted as JSON, but quotes around key names are not required, and data can be single-quoted:

<code>
{
  firstName: 'John',
  lastName: 'Smith'
}
</code>

==== Update Data ====

To modify existing data, you pass two sets of data to update(): a filter, and an update action. The filter locates the document, and the update action specifies the data to modify.

In this example, we’ll change the “Bob Jones” record to “Robert Jones”:

<code>
> db.people.find()
{ "_id" : ObjectId("5f4bc4dd54e2c67896143097"), "firstName" : "John", "lastName" : "Smith" }
{ "_id" : ObjectId("5f4bc4e354e2c67896143098"), "firstName" : "Bob", "lastName" : "Jones" }

> db.people.update({ firstName: "Bob", lastName: "Jones" }, { $set: {firstName: "Robert" } } )
WriteResult({ "nMatched" : 1, "nUpserted" : 0, "nModified" : 1 })

> db.people.find()
{ "_id" : ObjectId("5f4bc4dd54e2c67896143097"), "firstName" : "John", "lastName" : "Smith" }
{ "_id" : ObjectId("5f4bc4e354e2c67896143098"), "firstName" : "Robert", "lastName" : "Jones" }
</code>

==== Remove Data ====

To remove data, you pass a filter to remove(), specifying the document (or documents) you want to remove.

In this example, we’ll add a new document to the people collection, and then remove it.

<code>
> db.people.insert( { firstName: "To", lastName: "Remove" } )
WriteResult({ "nInserted" : 1 })

> db.people.find()
{ "_id" : ObjectId("5f4bc4dd54e2c67896143097"), "firstName" : "John", "lastName" : "Smith" }
{ "_id" : ObjectId("5f4bc4e354e2c67896143098"), "firstName" : "Robert", "lastName" : "Jones" }
{ "_id" : ObjectId("5f4bf7595402b299ee512fd8"), "firstName" : "To", "lastName" : "Remove" }

> db.people.remove( { firstName: "To", lastName: "Remove"} )
WriteResult({ "nRemoved" : 1 })

> db.people.find()
{ "_id" : ObjectId("5f4bc4dd54e2c67896143097"), "firstName" : "John", "lastName" : "Smith" }
{ "_id" : ObjectId("5f4bc4e354e2c67896143098"), "firstName" : "Robert", "lastName" : "Jones" }
</code>

==== Managing Collections ====

To see the collections in a database:

<code>
> use testdb
switched to db testdb

> show collections
people
</code>

You can also use getCollectionNames(), which returns results as BSON:

<code>
> db.getCollectionNames()
[ "people" ]
</code>

Add a collection explicitly with createCollection:

<code>
> show collections
people

> db.createCollection("things")
{ "ok" : 1 }

> show collections
people
things
</code>

Drop a collection:

<code>
> show collections
people
things

> db.things.drop()
true

> show collections
people
</code>

Count of documents in a collection:

<code>
> db.people.count()
2
</code>

==== Retrieving Data ====

We’ve already employed a simple find in our add/update/delete examples: db.<collection_name>.find().

Find also accepts two optional parameters:

  * Query filter: Describes how to filter the results, similar to a WHERE clause in SQL.
  * Projection: Specifies which key/values from the document we want to see.

A find with no arguments retrieves up to the first 20 documents in a collection:

<code>
> db.people.find()
{ "_id" : ObjectId("5f4bc4dd54e2c67896143097"), "firstName" : "John", "lastName" : "Smith" }
{ "_id" : ObjectId("5f4bc4e354e2c67896143098"), "firstName" : "Robert", "lastName" : "Jones" }
</code>

A filter with an exact match on one key looks like this:

<code>
> db.people.find( {firstName: "John"} )
{ "_id" : ObjectId("5f4bc4dd54e2c67896143097"), "firstName" : "John", "lastName" : "Smith" }
</code>

Matching on multiple keys, similar to an AND in a SQL WHERE clause, looks like this:

<code>
> db.people.find(
... {
... $and: [
... { firstName: "John" },
... { lastName: "Smith" }
... ]
... });
{ "_id" : ObjectId("5f4bc4dd54e2c67896143097"), "firstName" : "John", "lastName" : "Smith" }
</code>

MongoDB supports the following query comparison operators: $eq, $gt, $gte, $lt, $lte, $ne, $in, and $nin, along with the following logical operators: $or, $and, $not, and $nor. Regex is also supported.

Projections can be used to limit the keys returned. For example, here’s how to return just the last names:

<code>
> db.people.find( { }, { _id: 0, lastName: 1 } );
{ "lastName" : "Smith" }
{ "lastName" : "Jones" }
</code>

The numeric values indicate whether to include (1) or exclude (0) a given field. The _id field is always returned, unless specifically excluded.

Results can also be sorted:

<code>
> db.people.find( { }, { } ).sort( { lastName: 1 });
{ "_id" : ObjectId("5f4bc4e354e2c67896143098"), "firstName" : "Robert", "lastName" : "Jones" }
{ "_id" : ObjectId("5f4bc4dd54e2c67896143097"), "firstName" : "John", "lastName" : "Smith" }
</code>

The numeric value controls whether to sort ascending (1) or descending (-1).

For large result sets, the number of results to return can be specified:

<code>
> db.people.find( { }, { } ).limit( 1 );
{ "_id" : ObjectId("5f4bc4dd54e2c67896143097"), "firstName" : "John", "lastName" : "Smith" }
</code>

===== MongoDB in .NET (C#) =====

Data in MongoDB can be accessed and manipulated in .NET (Standard and Core) applications using MongoDB.Driver. This is a simple introduction to connecting to MongoDB, retrieving data, and displaying it.

Create a .NET Core console application:

<code bash>
dotnet new console -o DotMongo
</code>

Add a reference to MongoDB.Driver:

<code bash>
cd DotMongo
 
dotnet add package MongoDB.Driver --version 2.11.1
</code>

Open Program.cs in your editor of choice, and replace the contents with this:

<WRAP prewrap>
<file csharp Program.cs>
using System;
using MongoDB.Driver;
using MongoDB.Bson;
 
namespace DotMongo
{
	class Program
	{
		static void Main(string[] args)
		{
			try
			{
				var databaseName = "testdb";
 
				// Get database reference.
				var mongoDatabase = GetDatabaseReference("localhost", 27017, databaseName);
				Console.WriteLine($"Connected to database {databaseName}");
 
				// Get a reference to the "people" collection inside testdb.
				var collection = mongoDatabase.GetCollection<BsonDocument>("people");
 
				// We're retrieving all documents in the collection,
				// but we still need an empty filter.
				var filter = new BsonDocument();
				var count = 0;
 
				// Open a cursor with all the matching documents.
				using (var cursor = collection.FindSync<BsonDocument>(filter))
				{
					// Iterate through the cursor
					while (cursor.MoveNext())
					{
						// Get documents at the current cursor location.
						var batch = cursor.Current;
 
						foreach (var document in batch)
						{
							// Get values from the current document, then display them.
							var firstName = document.GetElement("firstName").Value.ToString();
							var lastName = document.GetElement("lastName").Value.ToString();
 
							Console.WriteLine($"Full name: {firstName} {lastName}");
							count++;
						}
					}
				}
				Console.WriteLine($"Total records: {count}");
 
			}
			catch (Exception ex)
			{
				Console.WriteLine(ex.Message);
			}
		}
 
		public static IMongoDatabase GetDatabaseReference(string hostName, int portNumber, string databaseName)
		{
			string connectionString = $"mongodb://{hostName}:{portNumber}";
 
			// Connect to MongoDB
			var mongoClient = new MongoClient(connectionString);
 
			// Get a reference to the specified database
			var mongoDatabase = mongoClient.GetDatabase(databaseName);
 
			return mongoDatabase;
		}
 
 
	}
}
</file>
</WRAP>

Run the application:

<code bash>
dotnet run
</code>

You should see output that looks like this:

<code>
Connected to database testdb
Full name: John Smith
Full name: Robert Jones
Total records: 2
</code>

You can find the full project [[https://github.com/jfcarr/mongodb-dotnet-quick-start|here]].

===== Learn More =====

[[https://www.mongodb.com/|MongoDB home page]]

[[https://github.com/mongodb/mongo|MongoDB on GitHub]]

[[https://hub.docker.com/_/mongo|MongoDB on Docker Hub]]

[[https://www.syncfusion.com/ebooks/mongodb_3_succinctly|MongoDB 3 Succinctly]]

{{tag>database docker}}