eolas/Databases/MongoDB/Introduction.md

tags
Databases mongo_db

MongoDB: Introduction

MongoDB is not a relational database system like SQL, instead it is document-based which means you do not neeed to design database tables and schema, you are simply storing data as JSON and there is no transformation of the data.

Most of the notes on Mongo will introduce it within the context of Node.js backend. We will be sending Javascript objects and arrays to Mongo and returning them as JSON.

Setting-up a MongoDB database

First create a direc## Mongoose tory for the database and set permissions:

$ mkdir /data/db
$ sudo chown -R `id -un` /data/db

Then start the Mongo daemon

mongod

This will run continuously in the terminal and should say somewhere that it is waiting for connections on port 27017. This command must be executed before you run any backend that interacts with the Mongo database.

MongoDB Compass

Compass is a graphical interface for viewing and interacting with the data in your Mongo database. It will automatically load to the default Mongo port: 27017.

Arch Linux troublshooting

Most times any problems will be a result of a Mongo process that is already running. Resolve with:

# Kill running Mongo process...
# Identify PID
sudo lsof -iTCP -sTCP:LISTEN -n -P
sudo kill [pid]

Otherwise try the below.

# Check that the systemd service is runnign for Mongo
sudo systemctl status mongodb

# If not, enable and start service (only need to do this once for machine)
sudo systemctl enable --now mongodb
sudo systemctl start --now mongodb

# If issues with Mongo daemon...
# Remove the current socket
rm /tmp/mongodb-27017.sock

MongoDB data hierarchy: databases, collections, documents

Although Mongo is not a relational database it has a structure that we can understand in relation to that paradigm. A database is obviously the overall structure. It comprises collections which are organised sets of data that are analagous to tables in RDBs. Within each collection are a series of documents which we can think of as being equivalent to rows in RDB table: units that comprise the collection.

A document is a container comprising key-value pairs in the manner of an object.

Connecting to our database with Mongoose

Now that we have installed and configured MongoDB, we need to connect from it via Node.js.Mongoose is a simple API for interacting with a Mongo database via Node.

With this installed we can connect to a database. We don't have any Mongo databases yet beyond the defaults but the following Mongoose connection logic will create and connect to a new database called playground:

mongoose
  .connect("mongodb://127.0.0.1/playground")
  .then(() => console.log("Connected to MongoDB"))
  .catch((err) => console.error(err));

Creating collections and documents

In order start adding collections and documents to our database, we use Mongoose's schema structure. (This is specific to the Mongoose wrapper and is not a structure that is a part of Mongo in general.)

We use a schema to define the shape of documents in a MongoDB collection. To do this we instantiate an instance of the Mongoose Schema class and set our properties:

Creating a schema

const courseSchema = new mongoose.Schema({
  name: String,
  author: String,
  tags: [String],
  data: {type: Date, default: Date.now}, // if unspecified, entry will default to current date
  isPublished: Boolean
});

This is just like defining an interace or type within TypeScript.

Available data types

The following data types are available:

• String
• Number
• Boolean
• Array
• Date
• Buffer
• ObjectID (for UUIDs)

Models

Once we have established our schema we can then create a model of it. A model is basically a class representation of the interface we define in the schema:

const Course = mongoose.model("Course", courseSchema);

With this in place, we can then create instances of the model. This stands in relation to the model as an object does to a class:

const course = new Course({
  name: "Node.js Course",
  author: "Ozzy Osbourne",
  tags: ["node", "backend"],
  isPublished: true 
});

Having created a database, connected to it with Mongoose, and created a model we will see our collection reflected in Compass:

Adding a document

We have our database (lllplayground) and collection (courses) established. We now need to add documents to our collection. We will move our previous code into a function since this will be an asynchronous process:

const nodeCourse = new Course({
  name: "Node.js Course",
  author: "Ozzy Osbourne",
  tags: ["node", "backend"],
  isPublished: true,
});

async function addCourseDocToDb(courseDocument) {
  const result = await courseDocument.save();
  console.log(result);
}

addCourseDocToDb(nodeCourse);

When we run this we have the Mongo document outputted to the console:

{
  name: 'Python Course',
  author: 'Terry Ogleton',
  tags: [ 'node', 'backend' ],
  isPublished: true,
  _id: new ObjectId("62f4ac989d2fec2f01596b9b"),
  date: 2022-08-11T07:15:36.978Z,
  __v: 0
}