Lưu trữ #database

MongoDB Fundamentals 1. What is MongoDB and what are its main features? MongoDB is a NoSQL, document-oriented database that stores data in JSON-like documents with flexible schemas. It is designed to handle large volumes of data and provide high performance, high availability, […]

Tagged #database, #interview, #mongodb

1. What is MongoDB and what are its main features?

MongoDB is a NoSQL, document-oriented database that stores data in JSON-like documents with flexible schemas. It is designed to handle large volumes of data and provide high performance, high availability, and easy scalability.

Main Features:

Document-Oriented Storage: Stores data in flexible, JSON-like documents.
Indexing: Supports secondary indexes for better query performance.
Replication: Provides data redundancy and high availability with replica sets.
Sharding: Supports horizontal scaling by distributing data across multiple servers.
Aggregation: Powerful framework for data aggregation and transformation.
GridFS: Store and retrieve large files like images, videos, etc.
Ad Hoc Queries: Supports dynamic queries on documents using a rich query language.

2. How does MongoDB differ from relational databases?

Differences:

Data Model: MongoDB uses a document-oriented model (documents and collections) instead of tables and rows.
Schema Flexibility: MongoDB has a flexible schema design, allowing for different structures in the same collection. Relational databases require predefined schemas.
Scalability: MongoDB supports horizontal scaling through sharding, while relational databases typically scale vertically.
Joins: MongoDB generally avoids joins, embedding related data within documents, while relational databases use foreign keys and joins.
Transactions: MongoDB supports multi-document ACID transactions, but this was introduced later, and traditionally it had limited transactional support compared to relational databases.

3. Can you describe the structure of data in MongoDB?

Data in MongoDB is stored in BSON (Binary JSON) format within collections. A collection is a group of MongoDB documents, and a document is a set of key-value pairs.

Example:

{ "_id": "unique_id_1", "name": "Alice", "age": 29, "address": { "street": "123 Main St", "city": "Anytown", "state": "CA" }, "interests": ["reading", "hiking", "coding"] }

4. What is a Document in MongoDB?

A Document in MongoDB is a set of key-value pairs, similar to a JSON object. It is the basic unit of data in MongoDB and can hold various types of data, including other documents (embedded documents).

5. How is data stored in collections in MongoDB?

Data in MongoDB is stored in collections, which are analogous to tables in relational databases. A collection is a group of documents, and each document within a collection can have a different structure.

Example:

// Collection: users [ { "_id": "user1", "name": "Alice", "email": "alice@example.com" }, { "_id": "user2", "name": "Bob", "email": "bob@example.com", "address": { "street": "456 Maple St", "city": "Othertown", "state": "TX" } } ]

6. Describe what a MongoDB database is.

A MongoDB database is a container for collections. Each database has its own set of collections, and each collection contains documents. A MongoDB instance can host multiple databases, and databases provide logical separation for data.

7. What is the default port on which MongoDB listens?

The default port for MongoDB is 27017.

8. How does MongoDB provide high availability and disaster recovery?

MongoDB provides high availability and disaster recovery through replica sets. A replica set is a group of MongoDB servers that maintain the same data set, providing redundancy and failover capability. In a replica set, one node is the primary node that receives all write operations, and the other nodes are secondary nodes that replicate the primary’s data.

Example of setting up a replica set:

rs.initiate({ _id: "myReplicaSet", members: [ { _id: 0, host: "localhost:27017" }, { _id: 1, host: "localhost:27018" }, { _id: 2, host: "localhost:27019" } ] });

9. What are indexes in MongoDB, and why are they used?

Indexes in MongoDB are used to improve the performance of search queries by creating a special data structure that holds a subset of data from the documents. Indexes support efficient query execution and can significantly speed up read operations.

Creating an index:

db.users.createIndex({ name: 1 });

This creates an ascending index on the name field of the users collection.

10. What is the role of the id field in MongoDB documents?

The _id field in MongoDB is a unique identifier for each document within a collection. It is a required field and serves as the primary key. If not provided, MongoDB automatically generates an ObjectId for this field.

Example:

{ "_id": ObjectId("507f1f77bcf86cd799439011"), "name": "Alice", "age": 29 }

CRUD Operations

11. How do you create a new MongoDB collection?

In MongoDB, collections are typically created automatically when you insert a document. However, you can explicitly create a collection using the createCollection method.

Example:

db.createCollection("myCollection");

12. What is the syntax to insert a document into a MongoDB collection?

To insert a document into a collection, you use the insertOne or insertMany methods.

Example using insertOne:

db.myCollection.insertOne({ name: "Alice", age: 30, city: "New York" });

Example using insertMany:

db.myCollection.insertMany([ { name: "Bob", age: 25, city: "San Francisco" }, { name: "Charlie", age: 35, city: "Chicago" } ]);

13. Describe how to read data from a MongoDB collection.

To read data from a MongoDB collection, you use the find method.

Example:

// Find all documents in the collection db.myCollection.find(); // Find documents with a specific condition db.myCollection.find({ age: { $gt: 25 } });

14. Explain how to update documents in MongoDB.

To update documents, you use the updateOne, updateMany, or replaceOne methods.

Example using updateOne:

db.myCollection.updateOne( { name: "Alice" }, { $set: { age: 31 } } );

Example using updateMany:

db.myCollection.updateMany( { city: "Chicago" }, { $set: { city: "New Chicago" } } );

15. What are the MongoDB commands for deleting documents?

You can delete documents using the deleteOne or deleteMany methods.

Example using deleteOne:

db.myCollection.deleteOne({ name: "Alice" });

Example using deleteMany:

db.myCollection.deleteMany({ age: { $lt: 30 } });

16. Can you join two collections in MongoDB? If so, how?

MongoDB doesn’t support joins in the same way relational databases do, but you can perform joins using the aggregation framework with the $lookup stage.

Example:

db.orders.aggregate([ { $lookup: { from: "customers", localField: "customerId", foreignField: "_id", as: "customerDetails" } } ]);

17. How do you limit the number of documents returned by a MongoDB query?

You can use the limit method to restrict the number of documents returned.

Example:

db.myCollection.find().limit(5);

18. What is the difference between `find()` and `findOne()` in MongoDB?

find(): Returns a cursor to the documents that match the query. You can iterate over this cursor to retrieve multiple documents.
findOne(): Returns the first document that matches the query criteria.

Example using findOne:

db.myCollection.findOne({ name: "Alice" });

19. How can you achieve pagination in MongoDB?

Pagination can be achieved using the skip and limit methods.

Example:

const page = 2; const pageSize = 10; db.myCollection.find() .skip((page - 1) * pageSize) .limit(pageSize);

20. What are the differences between MongoDB’s `insertOne` and `insertMany` methods?

insertOne: Inserts a single document into the collection.
insertMany: Inserts multiple documents into the collection in a single operation.

Example using insertOne:

db.myCollection.insertOne({ name: "David", age: 40, city: "Seattle" });

Example using insertMany:

db.myCollection.insertMany([ { name: "Eva", age: 29, city: "Austin" }, { name: "Frank", age: 33, city: "Denver" } ]);

Indexing & Aggreation

21. Describe a compound index in MongoDB.

A compound index in MongoDB is an index on multiple fields within a collection. Compound indexes support queries that match on multiple fields, improving query performance for those queries.

Example:

db.myCollection.createIndex({ name: 1, age: -1 });

This creates a compound index on the name field in ascending order and the age field in descending order.

22. What is the aggregation pipeline in MongoDB?

The aggregation pipeline in MongoDB is a framework for data aggregation, modeled on the concept of data processing pipelines. Documents enter a multi-stage pipeline that transforms the documents into aggregated results.

Example:

db.orders.aggregate([ { $match: { status: "A" } }, { $group: { _id: "$cust_id", total: { $sum: "$amount" } } }, { $sort: { total: -1 } } ]);

23. How can you create an index in MongoDB and when should you do it?

You create an index in MongoDB using the createIndex method. You should create indexes to improve the performance of queries that are run frequently.

Example:

db.myCollection.createIndex({ name: 1 });

Create an index on the name field in ascending order.

24. Explain how MongoDB’s `$match`, `$group`, and `$sort` operators work in an aggregation pipeline.

$match: Filters documents to pass only those that match the specified condition.
$group: Groups input documents by a specified identifier expression and applies the accumulator expression(s).
$sort: Sorts all input documents and returns them in the specified order.

Example:

db.orders.aggregate([ { $match: { status: "A" } }, { $group: { _id: "$cust_id", total: { $sum: "$amount" } } }, { $sort: { total: -1 } } ]);

25. What is the purpose of the `explain()` method?

The explain() method provides information on the execution plan of a query. It shows how MongoDB processes the query, helping to understand its performance characteristics and optimize it if necessary.

Example:

db.myCollection.find({ name: "Alice" }).explain("executionStats");

26. Can you explain MongoDB’s replication?

Replication in MongoDB is achieved through replica sets. A replica set is a group of MongoDB instances that maintain the same data set. One node is primary, receiving all write operations, while the other nodes (secondaries) replicate the primary’s data and can serve read operations.

27. Describe the purpose and components of a replica set.

A replica set provides redundancy and high availability. It consists of:

Primary Node: Handles all write operations.
Secondary Nodes: Replicate the data from the primary node and can be read from if configured.
Arbiter Nodes: Participate in elections but do not hold data.

28. What is sharding in MongoDB and when would you use it?

Sharding is a method for distributing data across multiple servers. It enables horizontal scaling by partitioning data into smaller, more manageable pieces called shards.

When to use it: When dealing with large datasets and high throughput that cannot be handled by a single server.

29. How does MongoDB perform automatic failover?

In a replica set, if the primary node fails, an automatic election process occurs among the remaining nodes to select a new primary. This ensures high availability and minimal downtime.

30. Describe the difference between horizontal scaling and vertical scaling, and how MongoDB supports them.

Horizontal Scaling: Adding more machines to handle the load. MongoDB supports this through sharding.
Vertical Scaling: Adding more resources (CPU, RAM) to an existing machine. MongoDB can benefit from this by handling more data and queries on a single node.

MongoDB supports horizontal scaling through sharding, distributing the data across multiple servers to handle larger datasets and higher loads efficiently. Vertical scaling is also possible by upgrading the hardware of existing MongoDB servers to enhance their performance.

Performance & Optimization

31. How does MongoDB handle large data volumes?

MongoDB handles large data volumes through a combination of techniques:

Sharding: Distributes data across multiple servers, allowing horizontal scaling. Each shard contains a subset of the data, making it possible to handle large datasets by adding more servers.
Indexes: Efficiently indexes data to speed up query performance, even with large datasets.
Compression: Uses data compression to reduce the storage footprint of large datasets.
Aggregation Pipeline: Allows for the efficient processing of large volumes of data within the database.

32. What strategies can you use to diagnose and address performance issues in MongoDB?

Strategies for diagnosing and addressing performance issues include:

Using explain(): Analyzes query execution plans to identify inefficiencies.
Monitoring Tools: Using tools like MongoDB Atlas, Cloud Manager, or Ops Manager to monitor database performance.
Index Optimization: Ensuring appropriate indexes are in place and regularly reviewed.
Sharding: Distributing data across multiple shards to balance the load.
Profiling: Enabling the MongoDB profiler to capture detailed information about database operations.
Resource Allocation: Ensuring sufficient resources (CPU, memory, storage) are allocated to the database.

33. How do you ensure that indexes fit into RAM?

To ensure indexes fit into RAM:

Monitor Index Size: Regularly monitor the size of your indexes using db.collection.stats().
Selective Indexing: Only create indexes on fields that are frequently queried.
Index Optimization: Periodically review and remove unused or redundant indexes.
Sufficient RAM: Ensure your server has enough RAM to accommodate your working set, including indexes.

34. Can you explain MongoDB’s write concern?

Write Concern in MongoDB specifies the level of acknowledgment requested from MongoDB for write operations to the application. It determines the guarantee of the write operation.

w: Number of nodes that must acknowledge the write.
j: Specifies whether the write operation should be acknowledged only after it has been committed to the journal.
wtimeout: Time limit for the write concern to be satisfied.

Example:

db.myCollection.insertOne({ name: "Alice" }, { writeConcern: { w: "majority", j: true, wtimeout: 5000 } });

35. What is a covered query in MongoDB?

A covered query is a query in which:

All the fields in the query are part of an index.
All the fields returned in the results are in the same index.

Covered queries are efficient because MongoDB can fulfill the query using only the index, without having to read the documents from the collection.

Example:

// Assume there is an index on { name: 1, age: 1 } db.myCollection.find({ name: "Alice" }, { name: 1, age: 1, _id: 0 }).explain("executionStats");

36. What are the security features available in MongoDB?

Security features in MongoDB include:

Authentication: Ensures that only authorized users can access the database.
Authorization: Controls access to database resources and operations using role-based access control (RBAC).
Encryption: Provides data encryption at rest and in transit.
Auditing: Tracks database activities to ensure accountability and compliance.
Network Isolation: Uses IP whitelisting and VPNs to secure network access.

37. How do you enable authentication in MongoDB?

To enable authentication in MongoDB:

Create Admin User: Create an admin user with the necessary roles.

 use admin db.createUser({ user: "admin", pwd: "password", roles: [{ role: "userAdminAnyDatabase", db: "admin" }] });

Enable Authentication: Modify the MongoDB configuration file (mongod.conf) to enable authentication.

 security: authorization: "enabled"

Restart MongoDB: Restart the MongoDB service to apply the changes.

38. Describe role-based access control in MongoDB.

Role-Based Access Control (RBAC) in MongoDB allows you to define roles with specific privileges to control access to database resources and operations. Each user is assigned roles that grant the necessary permissions.

Example:

db.createRole({ role: "readWriteRole", privileges: [ { resource: { db: "test", collection: "" }, actions: ["find", "insert", "update", "remove"] } ], roles: [] }); db.createUser({ user: "readWriteUser", pwd: "password", roles: ["readWriteRole"] });

39. Explain how to encrypt MongoDB data.

Encrypting MongoDB data involves:

Encryption at Rest: Encrypts data stored on disk. This can be enabled in MongoDB Enterprise or MongoDB Atlas using the kmip configuration for key management.

 security: enableEncryption: true encryptionKeyFile: /path/to/keyfile kmip: serverName: "kmip-server.example.com" port: 5696 clientCertificate: /path/to/cert.pem clientCertificatePassword: "password"

Encryption in Transit: Encrypts data transmitted between MongoDB clients and servers using TLS/SSL.

 net: ssl: mode: requireSSL PEMKeyFile: /path/to/mongodb.pem CAFile: /path/to/ca.pem

MongoDB Storage Engines

41. What are the different storage engines available in MongoDB?

MongoDB supports several storage engines, each with its own characteristics and use cases:

WiredTiger: The default storage engine in MongoDB. It provides document-level concurrency, compression, and checkpointing.
MMAPv1: The original storage engine, based on memory-mapped files. It provides collection-level locking and is now deprecated.
In-Memory: A storage engine that keeps all data in-memory for fast read and write operations, useful for scenarios where data persistence is not required.
RocksDB: A high-performance storage engine optimized for fast storage hardware, available through the MongoRocks plugin.

42. How does the WiredTiger storage engine differ from MMAPv1?

WiredTiger vs. MMAPv1:

Concurrency: WiredTiger provides document-level concurrency, allowing multiple operations to be performed simultaneously on different documents. MMAPv1 provides only collection-level locking.
Compression: WiredTiger supports data compression, reducing storage costs. MMAPv1 does not support compression.
Performance: WiredTiger generally offers better performance due to its advanced concurrency and compression features.
Checkpointing: WiredTiger uses checkpointing for data durability and crash recovery. MMAPv1 relies on journaling for durability.

43. Can you switch between storage engines in a MongoDB database?

Switching storage engines requires exporting the data, changing the configuration, and then re-importing the data:

Export Data: Use mongodump to export the data.

 mongodump --db myDatabase --out /path/to/dump

Change Configuration: Modify the mongod.conf file to specify the new storage engine.

 storage: engine: wiredTiger # or mmapv1, inMemory, rocksDB

Restart MongoDB: Restart the MongoDB service to apply the changes.
Import Data: Use mongorestore to import the data back.

 mongorestore /path/to/dump

44. What is the oplog in MongoDB, and how does it work?

The oplog (operations log) is a special capped collection that keeps a rolling record of all operations that modify the data in the database. It is used for replication and ensures data consistency across replica set members.

Primary Node: Writes operations to the oplog.
Secondary Nodes: Continuously apply the operations from the oplog to maintain an up-to-date copy of the data.

45. How do you use the `$lookup` operator in MongoDB?

The $lookup operator performs a left outer join to a collection in the same database to filter in documents from the “joined” collection for processing.

Example:

db.orders.aggregate([ { $lookup: { from: "customers", localField: "customerId", foreignField: "_id", as: "customerDetails" } } ]);

46. Can you explain the role of a mongos server in a sharded MongoDB architecture?

In a sharded MongoDB architecture, mongos acts as a query router:

Routes Queries: Directs client requests to the appropriate shard.
Load Balancer: Balances the load across multiple shards.
Aggregation: Combines results from multiple shards and returns them to the client.

47. What is journaling in MongoDB and why is it important?

Journaling is a process that provides durability by recording changes to the database in a journal file. It ensures that in the event of a crash, MongoDB can recover to the last consistent state by replaying the operations from the journal.

48. Explain the GridFS specification in MongoDB.

GridFS is a specification for storing and retrieving large files, such as images, videos, and large documents, in MongoDB. It splits the file into smaller chunks and stores each chunk as a separate document. This allows MongoDB to handle files larger than its BSON document size limit (16 MB).

Example:

// Upload a file to GridFS var bucket = new Mongo().getDB("myDatabase").getBucket(); var file = new File("/path/to/largeFile"); bucket.uploadFromStream("largeFile", file); // Download a file from GridFS bucket.downloadToStreamByName("largeFile", "/path/to/downloadedFile");

Schema Design

49. How does schema design impact performance in MongoDB?

Schema design in MongoDB significantly impacts performance. A well-designed schema can optimize query performance, storage efficiency, and maintainability. Key considerations include:

Data Access Patterns: Design schemas based on how data is accessed. Embed data for read-heavy operations and reference data for write-heavy operations.
Indexing: Proper indexes improve query performance but can slow down write operations.
Document Size: Avoid excessively large documents as they can impact read and write performance.
Normalization vs. Denormalization: Balance between normalized (referenced) and denormalized (embedded) schemas based on use case.

50. Compare embedding vs. linking documents in MongoDB.

Embedding Documents:
Pros:
- Faster read operations as related data is stored together.
- Fewer queries required to fetch related data.
Cons:
- Can lead to large documents and possible duplication of data.
- Updates can be complex if embedded data changes frequently.
Linking Documents (Referencing):
Pros:
- Reduces data duplication and maintains data consistency.
- More flexible for frequently changing data.
Cons:
- Requires additional queries to fetch related data.
- Slower read performance due to multiple lookups.

Example of Embedding:

{ name: "Alice", address: { street: "123 Main St", city: "Anytown" } }

Example of Linking:

// users collection { _id: ObjectId("507f1f77bcf86cd799439011"), name: "Alice", addressId: ObjectId("507f1f77bcf86cd799439012") } // addresses collection { _id: ObjectId("507f1f77bcf86cd799439012"), street: "123 Main St", city: "Anytown" }

51. What factors do you consider when designing a schema for MongoDB?

Factors to consider include:

Application Workload: Determine if the application is read-heavy, write-heavy, or balanced.
Data Access Patterns: Design schemas based on how data is accessed (read vs. write operations).
Document Size: Ensure documents are not excessively large to avoid performance degradation.
Indexing Needs: Plan indexes to optimize query performance.
Data Relationships: Decide between embedding and referencing based on the nature of data relationships.
Scalability: Consider sharding if the dataset is large or expected to grow significantly.
Flexibility: Leverage MongoDB’s flexible schema to accommodate evolving data requirements.

52. How do you handle one-to-many relationships in MongoDB data modeling?

One-to-many relationships can be handled in several ways:

Embedding: Embed the related documents if the related data is not frequently updated and is often accessed together.

 { _id: ObjectId("507f1f77bcf86cd799439011"), name: "Alice", orders: [ { item: "book", quantity: 2 }, { item: "pen", quantity: 5 } ] }

Referencing: Use references if the related data is frequently updated or accessed independently.

 // users collection { _id: ObjectId("507f1f77bcf86cd799439011"), name: "Alice" } // orders collection { userId: ObjectId("507f1f77bcf86cd799439011"), item: "book", quantity: 2 }

53. How do you perform backups in MongoDB?

Backups in MongoDB can be performed using various methods:

mongodump: Utility to create binary exports of the database.

 mongodump --out /path/to/backup

Snapshots: Use file system snapshots for faster and more consistent backups, especially for large databases.
MongoDB Atlas: Built-in automated backups for databases hosted on MongoDB Atlas.

54. What techniques can be used to restore a MongoDB database?

Restoring a MongoDB database can be done using:

mongorestore: Utility to restore data from a binary backup created by mongodump.

 mongorestore /path/to/backup

Restoring Snapshots: Use file system snapshots to restore the database to a previous state.

55. How would you monitor the performance of a MongoDB instance?

Monitoring the performance of a MongoDB instance involves:

MongoDB Monitoring Tools: Use MongoDB Atlas, Cloud Manager, or Ops Manager for real-time monitoring and alerting.
mongostat and mongotop: Command-line tools to monitor database operations and performance.

 mongostat mongotop

Performance Metrics: Monitor key metrics like CPU usage, memory usage, disk I/O, network I/O, and query performance.
Logs and Profiler: Analyze MongoDB logs and use the profiler to identify slow queries.

56. What factors would lead you to defragment a MongoDB collection?

Factors leading to defragmentation include:

High Fragmentation: Frequent updates and deletions can cause fragmentation, impacting performance.
Large Document Growth: Documents that grow significantly in size can cause fragmentation if not initially allocated enough space.
Performance Degradation: Noticeable slowdowns in read/write operations due to fragmented data.

Defragmentation can be achieved by running the compact command or by performing a data export and import.

db.runCommand({ compact: "myCollection" });

Working with Data Types

57. What are the different data types supported in MongoDB?

MongoDB supports a variety of data types, including:

String: Textual data.
Integer: Numeric data, can be 32-bit or 64-bit.
Double: Floating-point numbers.
Boolean: True or False values.
Date: Date and time.
Array: Lists of values.
Object: Embedded documents.
ObjectId: Unique identifier for documents.
Binary data: Data in binary format.
Code: JavaScript code.
Regular expression: Regular expression patterns.
Timestamp: Special internal type for MongoDB.

58. How does MongoDB store different types of numerical data?

MongoDB stores numerical data using different BSON types:

Integer: Stored as int32 (32-bit integer) or int64 (64-bit integer).
Double: Stored as double (64-bit floating-point).

Example:

{ "smallInt": 42, // int32 "largeInt": NumberLong("9223372036854775807"), // int64 "floatingPoint": 3.14 // double }

59. How does MongoDB handle DateTime data types?

MongoDB handles DateTime data using the BSON Date type, which represents the number of milliseconds since the Unix epoch (January 1, 1970).

Example:

{ "createdAt": new Date() }

You can also use the ISODate function to specify dates:

{ "createdAt": ISODate("2023-06-05T17:00:00Z") }

60. Can you store multimedia files directly in MongoDB?

Yes, you can store multimedia files directly in MongoDB using GridFS. GridFS is a specification for storing and retrieving large files, such as images, audio files, and videos, by dividing them into smaller chunks.

Example:

// Upload a file to GridFS var bucket = new Mongo().getDB("myDatabase").getBucket(); var file = new File("/path/to/largeFile"); bucket.uploadFromStream("largeFile", file); // Download a file from GridFS bucket.downloadToStreamByName("largeFile", "/path/to/downloadedFile");

61. How do you connect to a MongoDB database from a Python script?

To connect to a MongoDB database from a Python script, you can use the pymongo library.

Example:

from pymongo import MongoClient # Create a connection to the MongoDB server client = MongoClient("mongodb://localhost:27017/") # Access the database db = client.myDatabase # Access a collection collection = db.myCollection # Perform an operation (e.g., find one document) document = collection.find_one({"name": "Alice"}) print(document)

62. What is Mongoose and how does it relate to MongoDB?

Mongoose is an Object Data Modeling (ODM) library for MongoDB and Node.js. It provides a higher-level abstraction for interacting with MongoDB, offering schema validation, model-based data access, and more.

Example:

const mongoose = require('mongoose'); // Connect to MongoDB mongoose.connect('mongodb://localhost/myDatabase', { useNewUrlParser: true, useUnifiedTopology: true }); // Define a schema const userSchema = new mongoose.Schema({ name: String, age: Number, email: String }); // Create a model const User = mongoose.model('User', userSchema); // Create a new user const newUser = new User({ name: 'Alice', age: 30, email: 'alice@example.com' }); newUser.save((err) => { if (err) return console.error(err); console.log('User saved!'); });

63. Can you create and use stored procedures in MongoDB?

MongoDB does not support stored procedures in the same way as traditional relational databases. However, you can store JavaScript functions on the server side using the db.system.js collection and execute them.

Example:

// Define a stored function db.system.js.save({ _id: "myFunction", value: function (x, y) { return x + y; } }); // Call the stored function db.eval("myFunction(5, 3)");

64. Describe how to use the Mongo Shell for database operations.

The Mongo Shell is an interactive JavaScript interface to MongoDB. It allows you to perform database operations, such as querying and updating data, managing collections, and more.

Example Commands:

Connecting to a Database:

 mongo myDatabase

Inserting a Document:

 db.myCollection.insert({ name: "Alice", age: 30, city: "New York" });

Querying Documents:

 db.myCollection.find({ age: { $gt: 25 } });

Updating Documents:

 db.myCollection.update({ name: "Alice" }, { $set: { age: 31 } });

Deleting Documents:

 db.myCollection.remove({ name: "Alice" });

Drivers and ODMs

65. What is the purpose of MongoDB ODM / ORM frameworks?

Object-Document Mappers (ODMs) and Object-Relational Mappers (ORMs) provide an abstraction layer between MongoDB and the application code. They help developers interact with MongoDB in a more intuitive, object-oriented manner. The primary purposes of ODMs/ORMs are:

Schema Management: Define and enforce schemas within the application code.
Data Validation: Automatically validate data before saving to the database.
Query Simplification: Provide methods for building and executing queries using object-oriented syntax.
Model Relationships: Simplify the management of relationships between different models (e.g., one-to-many, many-to-many).
Code Reusability: Encourage reuse of code by defining data models as classes.

66. How can you perform MongoDB operations using Node.js?

To perform MongoDB operations using Node.js, you can use the official MongoDB driver for Node.js.

Example:

const { MongoClient } = require('mongodb'); // Connection URI const uri = "mongodb://localhost:27017"; // Create a new MongoClient const client = new MongoClient(uri); async function run() { try { // Connect to the MongoDB server await client.connect(); // Access the database const database = client.db('myDatabase'); // Access a collection const collection = database.collection('myCollection'); // Insert a document const result = await collection.insertOne({ name: "Alice", age: 30, city: "New York" }); console.log(`Document inserted with _id: ${result.insertedId}`); // Query for a document const document = await collection.findOne({ name: "Alice" }); console.log('Document found:', document); } finally { // Close the connection await client.close(); } } run().catch(console.dir);

67. List some popular libraries for integrating MongoDB with web applications.

Some popular libraries for integrating MongoDB with web applications include:

Mongoose: An ODM for MongoDB and Node.js.
MongoJS: A minimalist driver for MongoDB in Node.js.
Mongorito: An ORM for MongoDB with a focus on simplicity and productivity.
Spring Data MongoDB: A part of the Spring Data project, providing MongoDB integration for Spring applications.
PyMongo: The official MongoDB driver for Python.
MongoEngine: An ODM for MongoDB in Python.

68. How is MongoDB used in big data analytics?

MongoDB is used in big data analytics by providing scalable and flexible data storage, allowing for the efficient handling of large volumes of structured, semi-structured, and unstructured data. Key features include:

Aggregation Framework: Powerful tools for data processing and transformation.
Sharding: Horizontal scaling to handle large datasets.
Real-Time Analytics: Support for real-time data processing and analysis.
Integration with Big Data Tools: Integration with Hadoop, Spark, and other big data processing frameworks.

Example of Aggregation Pipeline:

db.sales.aggregate([ { $match: { status: "A" } }, { $group: { _id: "$customerId", total: { $sum: "$amount" } } }, { $sort: { total: -1 } } ]);

69. Can MongoDB handle real-time analytics workloads?

Yes, MongoDB can handle real-time analytics workloads through:

Real-Time Data Ingestion: Support for high-speed data ingestion.
Change Streams: Allows applications to subscribe to real-time changes in the database.
Aggregation Framework: Enables complex data processing and transformation in real-time.
In-Memory Storage Engine: Offers low-latency data access for real-time analytics.

Example of Change Streams:

const changeStream = db.collection('myCollection').watch(); changeStream.on('change', (next) => { console.log('Change detected:', next); });

70. How do you stream large quantities of data into and out of MongoDB?

Streaming large quantities of data into and out of MongoDB can be achieved using several methods:

Bulk Write Operations: Use bulk operations to insert, update, or delete large amounts of data efficiently.

 const bulkOps = [ { insertOne: { document: { name: "Alice", age: 30 } } }, { insertOne: { document: { name: "Bob", age: 25 } } }, { updateOne: { filter: { name: "Alice" }, update: { $set: { age: 31 } } } }, ]; collection.bulkWrite(bulkOps);

MongoDB Streaming API: Use the MongoDB Node.js driver’s cursor streaming API for efficient data streaming.

 const cursor = collection.find({}).stream(); cursor.on('data', (doc) => { console.log(doc); }); cursor.on('end', () => { console.log('All documents have been streamed.'); });

Data Import and Export Tools: Use mongoimport and mongoexport for bulk data transfer.

 # Export data to a JSON file mongoexport --db myDatabase --collection myCollection --out myCollection.json # Import data from a JSON file mongoimport --db myDatabase --collection myCollection --file myCollection.json

Internals & Deployment

71. How does MongoDB handle locking and concurrency?

MongoDB uses various mechanisms to handle locking and concurrency:

Document-Level Locking (WiredTiger): MongoDB’s WiredTiger storage engine uses document-level locking, allowing multiple operations to occur concurrently on different documents within the same collection. This improves performance and concurrency.
Global, Database, and Collection Locks (MMAPv1): The older MMAPv1 storage engine used global, database, and collection-level locks, which limited concurrency and impacted performance.
Optimistic Concurrency Control: MongoDB uses a form of optimistic concurrency control, particularly for sharding, to handle concurrent operations and minimize lock contention.

72. What is the relationship between BSON and MongoDB?

BSON (Binary JSON) is a binary representation of JSON-like documents. BSON extends the JSON model to provide additional data types and to be efficient for encoding and decoding within MongoDB.

Data Storage: MongoDB stores data in BSON format.
Efficiency: BSON is designed to be efficient in space and speed, which helps in optimizing storage and retrieval operations.

73. Can you explain the concept of a cursor in MongoDB?

A cursor in MongoDB is an object that allows you to iterate over the results of a query. When you perform a find operation, MongoDB returns a cursor pointing to the documents that match the query criteria.

Example:

// Retrieve all documents in the collection const cursor = db.myCollection.find(); // Iterate over the cursor cursor.forEach(doc => { printjson(doc); });

74. How does MongoDB manage memory?

MongoDB manages memory through a combination of its storage engine and the operating system’s virtual memory management:

WiredTiger Cache: WiredTiger uses an internal cache to manage in-memory data and uses the OS’s file system cache for data not in WiredTiger’s cache.
Memory-Mapped Files (MMAPv1): The MMAPv1 storage engine maps database files to virtual memory, relying on the OS to manage memory.
Journaling: MongoDB uses memory for journaling to ensure data durability.
Page Eviction: WiredTiger performs page eviction to free up memory for new data when the cache becomes full.

75. What are some best practices for securing a MongoDB instance?

Best practices for securing a MongoDB instance include:

Authentication: Enable authentication to require valid credentials for accessing the database.
Authorization: Implement role-based access control (RBAC) to restrict access to data and operations based on user roles.
Encryption:
In Transit: Use TLS/SSL to encrypt data transmitted between clients and the MongoDB server.
At Rest: Enable encryption for data stored on disk.
Network Security: Use network isolation techniques such as IP whitelisting, firewalls, and VPNs to limit access to the MongoDB server.
Auditing: Enable auditing to track access and modifications to the database.
Update Regularly: Keep MongoDB and its dependencies up to date with the latest security patches.

76. How do you scale a MongoDB deployment?

Scaling a MongoDB deployment involves:

Vertical Scaling: Adding more resources (CPU, RAM, storage) to existing servers.
Horizontal Scaling (Sharding): Distributing data across multiple servers (shards). Sharding allows you to scale out by adding more servers to handle increased load and larger datasets.
Shard Key: Select an appropriate shard key to distribute data evenly across shards.
Configuration Server: Manage metadata and routing information.
Mongos Router: Route client requests to the appropriate shard.

Example:

// Enable sharding for a database sh.enableSharding("myDatabase"); // Shard a collection sh.shardCollection("myDatabase.myCollection", { shardKey: 1 });

77. What is Ops Manager in MongoDB?

Ops Manager is a management platform provided by MongoDB for deploying, monitoring, and backing up MongoDB deployments. It provides a comprehensive suite of tools to manage MongoDB clusters, including:

Automation: Automate deployment, configuration, and scaling of MongoDB clusters.
Monitoring: Monitor performance metrics and set up alerts for critical issues.
Backup: Perform and manage backups, including point-in-time recovery.
Alerting: Configure and receive alerts for various operational metrics.
Performance Optimization: Analyze performance and provide recommendations for optimization.

Errors and Troubleshooting

78. How do you troubleshoot a slow-running query in MongoDB?

To troubleshoot a slow-running query in MongoDB, follow these steps:

Use explain(): Analyze the query execution plan to understand how MongoDB processes the query.

 db.myCollection.find({ field: "value" }).explain("executionStats");

Check Indexes: Ensure appropriate indexes are in place for the fields used in the query.

 db.myCollection.createIndex({ field: 1 });

Analyze Query Patterns: Optimize query patterns to reduce the amount of data processed.
Profile the Query: Use the MongoDB profiler to capture slow queries and analyze their performance.

 db.setProfilingLevel(2);

Hardware Resources: Ensure that the server has adequate hardware resources (CPU, RAM, Disk I/O).
Query Optimization: Rewrite the query to make it more efficient, possibly breaking it into smaller, more manageable parts.

79. What could cause a MongoServerError: E11000 duplicate key error?

The E11000 duplicate key error occurs when an attempt is made to insert a document with a value that violates a unique index constraint. This can happen due to:

Attempting to insert a document with a duplicate _id value.
Inserting a document with a value that already exists in a field with a unique index.
Bulk operations that include duplicate values for a unique index field.

Example:

// Create a unique index on the 'username' field db.users.createIndex({ username: 1 }, { unique: true }); // Insert a document db.users.insertOne({ username: "alice" }); // Attempt to insert another document with the same username db.users.insertOne({ username: "alice" }); // This will cause E11000 duplicate key error

80. How would you handle a scenario where the MongoDB service won’t start?

To handle a scenario where the MongoDB service won’t start, follow these steps:

Check Logs: Examine the MongoDB log file (mongod.log) for error messages and clues about why the service won’t start.

 tail -n 100 /var/log/mongodb/mongod.log

Verify Configuration: Ensure the MongoDB configuration file (mongod.conf) is correct and free of syntax errors.

 storage: dbPath: /var/lib/mongodb net: bindIp: 127.0.0.1 port: 27017

Check Disk Space: Ensure there is enough disk space on the server.

 df -h

Permissions: Verify that MongoDB has the necessary permissions to access its data files and directories.

 chown -R mongodb:mongodb /var/lib/mongodb

Port Availability: Ensure the configured port is not being used by another process.

 netstat -tuln | grep 27017

Reinstall MongoDB: If all else fails, consider reinstalling MongoDB to ensure all files are intact.

81. What are some MongoDB cloud-hosted solutions?

Some MongoDB cloud-hosted solutions include:

MongoDB Atlas: A fully managed cloud database service provided by MongoDB, Inc.
Amazon DocumentDB: A managed MongoDB-compatible database service provided by Amazon Web Services (AWS).
Azure Cosmos DB: A fully managed NoSQL database service by Microsoft Azure, which offers MongoDB API compatibility.
Google Cloud Firestore: A managed NoSQL document database service by Google Cloud, with MongoDB API compatibility.

82. How does MongoDB Atlas enhance MongoDB capabilities?

MongoDB Atlas enhances MongoDB capabilities by providing:

Fully Managed Service: Automated infrastructure provisioning, setup, and maintenance.
Scalability: Easy scaling of resources (CPU, RAM, storage) and data through sharding.
Global Distribution: Deploy databases in multiple regions for global low-latency access.
Automated Backups: Regular, automated backups with point-in-time recovery.
Monitoring and Alerts: Built-in monitoring and alerting for database performance and health.
Security Features: Advanced security features, including encryption at rest and in transit, VPC peering, and role-based access control.
Integration: Integration with other cloud services and tools for analytics, monitoring, and CI/CD.

83. Describe the use of Compass in MongoDB.

MongoDB Compass is a graphical user interface (GUI) for MongoDB. It provides tools for:

Visualizing Data: Browse and visualize your data, understand its structure, and perform ad-hoc queries.
Schema Exploration: Inspect the schema of your collections to understand the data distribution and types.
Query Building: Build queries using a visual query builder or directly with MongoDB query syntax.
Index Management: Create, modify, and analyze indexes to optimize query performance.
Performance Analysis: Monitor the performance of your queries and get insights into how to optimize them.
Aggregation Pipeline: Build and execute aggregation pipelines with a visual editor.

84. Explain the use of Robo 3T (formerly Robomongo).

Robo 3T (formerly Robomongo) is a free, open-source GUI for MongoDB. It provides features such as:

Interactive Shell: Integrated MongoDB shell for executing commands and scripts.
Query Building: Visual query editor for building and executing queries.
Data Management: Browse, edit, and manage your collections and documents.
Connection Management: Manage connections to multiple MongoDB instances and clusters.
Aggregation Editor: Build and run aggregation pipelines with a visual editor.
SSH Tunneling: Securely connect to remote MongoDB instances using SSH tunneling.

85. Can you work with MongoDB using the command line? If so, how?

Yes, you can work with MongoDB using the command line through the Mongo Shell. The Mongo Shell provides an interactive JavaScript interface to MongoDB, allowing you to perform database operations, query data, and manage collections.

Example Commands:

Connecting to a Database:

 mongo myDatabase

Inserting a Document:

 db.myCollection.insert({ name: "Alice", age: 30, city: "New York" });

Querying Documents:

 db.myCollection.find({ age: { $gt: 25 } });

Updating Documents:

 db.myCollection.update({ name: "Alice" }, { $set: { age: 31 } });

Deleting Documents:

 db.myCollection.remove({ name: "Alice" });

Considerations & Update

86. What factors to consider when deploying MongoDB in a containerized environment?

When deploying MongoDB in a containerized environment, consider the following factors:

Data Persistence: Ensure data persistence using persistent volumes to avoid data loss when containers are restarted or moved.
Networking: Properly configure networking to ensure that containers can communicate securely and efficiently.
Resource Allocation: Allocate sufficient CPU and memory resources to MongoDB containers to handle expected workloads.
Security: Implement security best practices, including using secrets for credentials, enabling authentication, and configuring network policies.
Scalability: Use orchestration tools like Kubernetes to manage scaling and ensure high availability.
Monitoring and Logging: Set up monitoring and logging to track performance and troubleshoot issues.
Backup and Restore: Ensure that backup and restore mechanisms are in place for data protection.
Environment Configuration: Use environment variables and configuration files to manage configuration settings.

87. How does MongoDB work with microservices architectures?

MongoDB works well with microservices architectures by providing:

Decentralized Data Management: Each microservice can have its own database, allowing for data ownership and independent scaling.
Flexible Schema: The flexible schema of MongoDB allows each microservice to evolve its data model without impacting others.
High Performance: MongoDB’s performance capabilities support real-time data processing required by microservices.
Replication and Sharding: MongoDB’s replication and sharding features ensure high availability and scalability for microservices.
Change Streams: Real-time change streams enable microservices to react to data changes efficiently.

88. What are change streams in MongoDB?

Change Streams in MongoDB provide a way to watch for real-time changes on a collection, database, or deployment. They enable applications to receive notifications of changes, such as inserts, updates, and deletes.

Example:

const changeStream = db.collection('myCollection').watch(); changeStream.on('change', (next) => { console.log('Change detected:', next); });

89. What major features were added in the latest MongoDB release?

The major features added in the latest MongoDB release (as of my knowledge cutoff date in 2023) can include improvements in:

Query Performance: Enhancements in the query execution engine.
Aggregation Framework: New operators and expressions in the aggregation framework.
Data Security: Additional security features like improved encryption.
Cloud Integration: Enhanced integration with cloud services.
Scalability and Resilience: Improvements in sharding and replication mechanisms.
Developer Experience: Enhanced tools and drivers for developers.

For the most current features, refer to the MongoDB release notes on their official website.

90. How does MongoDB handle version upgrades in a production environment?

MongoDB handles version upgrades in a production environment through:

Rolling Upgrades: Upgrade replica set members one at a time to minimize downtime.
Backups: Ensure backups are taken before starting the upgrade process.
Compatibility Checks: Use the featureCompatibilityVersion to ensure compatibility between different versions.
Testing: Test the upgrade process in a staging environment before applying it to production.
Documentation: Follow the official MongoDB upgrade documentation for step-by-step instructions.

Example of Rolling Upgrade:

Upgrade Secondary Nodes: Upgrade each secondary node one at a time.

 sudo service mongod stop sudo apt-get update sudo apt-get install -y mongodb-org=4.4.0 sudo service mongod start

Upgrade the Primary Node: Step down the primary node and upgrade it.

 rs.stepDown()

91. In what scenarios is MongoDB favored over a relational database?

MongoDB is favored over relational databases in scenarios where:

Flexible Schema: Applications require a flexible schema to handle evolving data models.
Large Scale: Handling large volumes of unstructured or semi-structured data.
High Throughput: Applications require high write and read throughput.
Geospatial Data: Applications need advanced geospatial queries.
Real-Time Analytics: Real-time data processing and analytics are needed.
Cloud-Native Applications: Applications designed for cloud environments with horizontal scaling needs.

92. What are some common patterns of data access in applications that use MongoDB?

Common patterns of data access in applications that use MongoDB include:

CRUD Operations: Standard create, read, update, and delete operations on documents.
Aggregation: Using the aggregation framework for data processing and analysis.

 db.orders.aggregate([ { $match: { status: "A" } }, { $group: { _id: "$cust_id", total: { $sum: "$amount" } } }, { $sort: { total: -1 } } ]);

Indexing: Creating indexes to improve query performance.

 db.myCollection.createIndex({ field: 1 });

Text Search: Using text indexes for full-text search capabilities.

 db.myCollection.createIndex({ field: "text" });

Geospatial Queries: Storing and querying geospatial data.

 db.places.createIndex({ location: "2dsphere" }); db.places.find({ location: { $near: { $geometry: { type: "Point", coordinates: [ -73.9667, 40.78 ] }, $maxDistance: 1000 } } });

Change Streams: Watching for real-time changes in collections.

 const changeStream = db.collection('myCollection').watch(); changeStream.on('change', (next) => { console.log('Change detected:', next); });

Optimizations

93. How can you prevent slow queries in MongoDB?

To prevent slow queries in MongoDB, you can follow these practices:

Indexing: Create appropriate indexes to speed up query execution.

 db.myCollection.createIndex({ field: 1 });

Query Optimization: Use efficient query patterns to reduce the amount of data processed.

 db.myCollection.find({ field: "value" }).projection({ field1: 1, field2: 1 });

Use Covered Queries: Ensure that queries can be satisfied using only the index.

 db.myCollection.find({ field: "value" }, { field: 1, _id: 0 });

Limit and Skip: Use limit and skip to reduce the number of documents processed.

 db.myCollection.find().limit(10).skip(20);

Shard Data: Use sharding to distribute data across multiple servers.

 sh.shardCollection("myDatabase.myCollection", { shardKey: 1 });

Monitor and Profile: Regularly monitor query performance and profile slow queries.

 db.setProfilingLevel(2);

94. Explain the role of the Profiler in MongoDB.

The MongoDB Profiler collects detailed information about database operations, including queries, inserts, updates, and deletes. It helps in identifying and diagnosing performance issues.

Enable Profiling: Set the profiling level.

 db.setProfilingLevel(2); // 0: Off, 1: Slow operations, 2: All operations

Analyze Profiler Output: Retrieve profiler data.

 db.system.profile.find().sort({ ts: -1 });

Example:

 db.setProfilingLevel(2); db.system.profile.find().sort({ millis: -1 }).limit(10);

95. How are B-tree indexes implemented in MongoDB?

MongoDB uses B-tree indexes (more specifically, B+-trees) to maintain the order of indexed fields and allow for efficient search, insertion, and deletion operations.

Balanced Tree Structure: Ensures that all leaf nodes are at the same depth.
Node Splitting: When a node becomes too full, it splits, ensuring balanced growth.
Ordered: Maintains order of keys, allowing for range queries and sorting.

Example of Creating an Index:

db.myCollection.createIndex({ field: 1 }); // Creates a B-tree index on 'field'

96. How do you handle complex transactions in MongoDB?

MongoDB supports multi-document ACID transactions, allowing you to perform complex transactions across multiple documents and collections.

Start a Session: Begin a session to initiate a transaction.

 const session = db.getMongo().startSession(); session.startTransaction();

Perform Operations: Execute multiple operations within the transaction.

 try { db.collection1.insertOne({ field: "value1" }, { session }); db.collection2.updateOne({ field: "value2" }, { $set: { field: "newValue" } }, { session }); session.commitTransaction(); } catch (error) { session.abortTransaction(); } finally { session.endSession(); }

97. Explain the MongoDB MapReduce operation.

MapReduce is a data processing paradigm for processing large data sets with a parallel, distributed algorithm. In MongoDB, MapReduce allows you to perform complex aggregation and data transformation.

Map Function: Processes each input document and emits key-value pairs.
Reduce Function: Processes the emitted key-value pairs and reduces them to a single result per key.

Example:

db.collection.mapReduce( function() { emit(this.category, this.amount); }, // Map function function(key, values) { return Array.sum(values); }, // Reduce function { out: "resultCollection" // Output collection } );

98. Can you perform text searches in MongoDB?

Yes, MongoDB supports text searches using text indexes.

Create a Text Index: Enable text search on a collection.

 db.myCollection.createIndex({ field: "text" });

Perform Text Search: Use the $text operator to perform text searches.

 db.myCollection.find({ $text: { $search: "search term" } });

Example:

db.myCollection.createIndex({ content: "text" }); db.myCollection.find({ $text: { $search: "MongoDB" } });

99. How can you integrate MongoDB with third-party applications?

Integration of MongoDB with third-party applications can be achieved through:

Drivers and SDKs: Use MongoDB drivers for various programming languages (Node.js, Python, Java, etc.) to interact with MongoDB.
REST APIs: Expose MongoDB operations through RESTful APIs.
GraphQL: Use GraphQL to interact with MongoDB data.
ETL Tools: Use Extract, Transform, Load (ETL) tools to integrate MongoDB with data warehouses and other databases.
Message Queues: Integrate with message queues like Kafka, RabbitMQ to handle data streaming.

Example with Node.js:

const { MongoClient } = require('mongodb'); const express = require('express'); const app = express(); const uri = "mongodb://localhost:27017"; const client = new MongoClient(uri); app.get('/data', async (req, res) => { try { await client.connect(); const database = client.db('myDatabase'); const collection = database.collection('myCollection'); const data = await collection.find().toArray(); res.json(data); } finally { await client.close(); } }); app.listen(3000, () => { console.log('Server is running on port 3000'); });

100. Describe how to synchronize data between SQL databases and MongoDB.

Data synchronization between SQL databases and MongoDB can be achieved through various methods:

ETL Processes: Use ETL tools to extract data from SQL databases, transform it as needed, and load it into MongoDB.
Change Data Capture (CDC): Use CDC tools to capture changes in SQL databases and replicate them to MongoDB in real-time.
Custom Scripts: Write custom scripts to periodically sync data between SQL databases and MongoDB.
Data Integration Platforms: Use platforms like Apache NiFi, Talend, or Informatica for data integration and synchronization.

Example with Apache NiFi:

Extract Data: Use a processor to read data from a SQL database.
Transform Data: Use processors to convert data formats and structure.
Load Data: Use a processor to write data to MongoDB.

Phá Kén

Thẻ: #database

100 MongoDB interview questions