Database and Collection Basics

MongoDB is a NoSQL database, and its structure is different from traditional relational databases like MySQL or PostgreSQL. Instead of using tables, rows, and columns, MongoDB organizes data into databases and collections, which are more flexible and scalable.

Here’s a breakdown of databases and collections in MongoDB, along with how to work with them.

1. MongoDB Database

A database in MongoDB is a container for collections. Each database has its own set of collections, indexes, and data. A MongoDB instance can contain multiple databases.

Basic Concepts

• Database Name: A database is identified by its name. Each database is created when you insert data into a collection. You don’t explicitly create databases (unless using an admin operation).
• Database Storage: A MongoDB instance can store multiple databases, but it typically stores only one active database at a time during the session.

Common Commands for Working with Databases

• Create or Switch Database: To switch to a database or create a new one, use the use command. MongoDB will automatically create the database when you insert data into it.Example:javascriptCopy codeuse myDatabase; // Switch to or create 'myDatabase'
• Show All Databases: To list all the databases in the MongoDB instance, use:javascriptCopy codeshow databases;
• Drop a Database: To delete a database, use the dropDatabase() method. This removes the database and all its collections permanently.Example:javascriptCopy codedb.dropDatabase();
• Get Current Database: To check the database you’re currently using, use:javascriptCopy codedb;

2. MongoDB Collection

A collection is a group of MongoDB documents. Collections are the MongoDB equivalent of tables in relational databases. However, unlike relational tables, MongoDB collections do not require a schema, meaning each document can have a different structure.

Basic Concepts

• Collection Name: Each collection in MongoDB is identified by a name. Collection names must be unique within a database.
• Schema-Less: Collections are schema-less, meaning you don’t have to define the structure of documents before inserting them. However, you can enforce a schema at the application level or by using tools like Mongoose (in Node.js).
• No Fixed Data Type: Each document in a collection can have different fields, data types, and structures. This provides great flexibility for handling dynamic data.

Common Commands for Working with Collections

• Create a Collection: MongoDB automatically creates a collection when you insert the first document into it. You can also explicitly create a collection using the createCollection() method.Example:javascriptCopy codedb.createCollection("users"); // Explicitly create a collection named "users"
• Show Collections: To list all collections in the current database, use:javascriptCopy codeshow collections;
• Drop a Collection: To delete a collection, use the drop() method. This deletes the collection and all of its documents.Example:javascriptCopy codedb.users.drop(); // Drop the "users" collection
• Get a Collection: To access a collection within a database, use the following syntax:javascriptCopy codedb.users; // Access the "users" collection

3. MongoDB Documents

A document is a single record in a collection. It is represented in BSON (Binary JSON) format, which is similar to JSON but allows for more data types like ObjectId, Date, and binary data.

Document Structure

• Fields: A document consists of field-value pairs. The fields can be simple key-value pairs or complex nested structures, such as arrays or embedded documents.Example document:jsonCopy code{ "_id": ObjectId("60d5f89d75c0fe3f488a3b0b"), "name": "John Doe", "email": "john.doe@example.com", "age": 29, "address": { "street": "123 Main St", "city": "Springfield" }, "tags": ["developer", "mongodb"] }
• _id Field: Each document in MongoDB has a special _id field, which serves as the primary key. If you don’t specify an _id, MongoDB will automatically generate one using ObjectId.

4. Working with Databases and Collections

Create a Database and Collection with Documents

• Switch to a database (it will be created if it doesn’t exist):javascriptCopy codeuse myDatabase;
• Insert documents into a collection (if the collection doesn’t exist, it will be created automatically):javascriptCopy codedb.users.insertOne({ name: "Alice", email: "alice@example.com", age: 30 });
• Insert multiple documents into a collection:javascriptCopy codedb.users.insertMany([ { name: "Bob", email: "bob@example.com", age: 35 }, { name: "Charlie", email: "charlie@example.com", age: 28 } ]);

Access and Query a Collection

• Find all documents in a collection:javascriptCopy codedb.users.find(); // Fetch all documents in the 'users' collection
• Find a document by a field value:javascriptCopy codedb.users.find({ name: "Alice" }); // Find users named "Alice"
• Find a document by _id:javascriptCopy codedb.users.findOne({ _id: ObjectId("60d5f89d75c0fe3f488a3b0b") });

Update a Collection

• Update a document:javascriptCopy codedb.users.updateOne( { name: "Alice" }, { $set: { age: 31 } } );
• Update multiple documents:javascriptCopy codedb.users.updateMany( { age: { $gte: 30 } }, { $inc: { age: 1 } } );

Delete Documents

• Delete a single document:javascriptCopy codedb.users.deleteOne({ name: "Alice" });
• Delete multiple documents:javascriptCopy codedb.users.deleteMany({ age: { $lt: 30 } });

5. Indexing in MongoDB

Indexes are used to improve the performance of queries by allowing MongoDB to find data more efficiently. Indexes are created on one or more fields of a collection.

Creating Indexes

• Create a simple index on a field:javascriptCopy codedb.users.createIndex({ email: 1 }); // Ascending index on the 'email' field
• Create a compound index on multiple fields:javascriptCopy codedb.users.createIndex({ name: 1, age: -1 }); // Compound index on 'name' and 'age'
• List indexes on a collection:javascriptCopy codedb.users.getIndexes();

Dropping an Index

• Drop an index:javascriptCopy codedb.users.dropIndex("email_1"); // Drop the index on 'email'

6. Naming Conventions and Limitations

• Database and Collection Names: MongoDB supports alphanumeric and underscore (_) characters in names. Database and collection names:
  • Can be up to 120 bytes in length.
  • Cannot contain the dot (.) or dollar sign ($) characters.
• Automatic Creation of Collections: Collections are automatically created when you insert the first document. However, it is also possible to create them explicitly with db.createCollection().

Conclusion

MongoDB uses a flexible and scalable structure based on databases, collections, and documents. Each database can hold multiple collections, and each collection holds documents. This NoSQL approach provides high flexibility for handling dynamic data with various data types and structures.

• Databases: Containers for collections.
• Collections: Groups of documents (similar to tables in SQL databases).
• Documents: Records in a collection (similar to rows in SQL databases).

Understanding how to work with databases and collections is fundamental when designing applications and structuring data in MongoDB.