Some helpful resources:
6- Table: The term "table" is typically associated with relational databases. In a relational database management system (RDBMS), data is organized into tables, each of which has a predefined schema with columns and data types.
Collection: The term "collection" is commonly used in the context of NoSQL databases, especially document-oriented databases like MongoDB. In MongoDB, data is stored in collections, and each document within a collection can have a different structure.
Sara jouma , Musab Sakhreyah , Malak Jabr
1-What is the difference between SQL and NoSQL?
2-What is referencing and what is embedding in MongoDB?
Embedding: Stores related data directly within a single document as nested subdocuments. All data is kept together in one collection.
Referencing: Involves storing the identifier (usually the _id field) of one document within another document. Think of it like a foreign key in a relational database. Documents are stored in separate collections.
3-Why should we embed more than referencing when we can in MongoDB?
Performance:
Faster reads: Retrieving related data is significantly faster with embedding since all the information is in one document, requiring only one query. This reduces roundtrip traffic between the application and database, boosting responsiveness.
Reduced complexity for join operations: Joins are typically computationally expensive, especially for complex relationships. Embedding eliminates the need for joins entirely when accessing frequently used related data, improving query performance.
Data consistency:
Atomic updates: You can update the parent document and its embedded subdocuments in a single atomic operation. This ensures data consistency and avoids potential synchronization issues that can arise with separate collections and referencing.
Simplicity and maintainability:
Easier schema design: Embedding can keep your schema simpler, especially for one-to-one or one-to-few relationships. This reduces complexity and makes it easier to understand and maintain.
Reduced code complexity: Your application code can be simpler as you don't need to perform explicit joins or handle references and foreign keys.
4-When should we prefer referencing over nesting in MongoDB?
Complex Relationships:
Many-to-many relationships: When a document can belong to multiple collections or vice versa, referencing allows better representation and flexibility. Nesting would lead to duplicated data and complex structures.
Independent updates and queries: If you frequently need to update or query the related data independently of the parent document, referencing allows separation of concerns and avoids unnecessary updates to the entire nested structure.
Data Management:
Large data sets: Nesting large subdocuments within parent documents can significantly increase document size, impacting performance and potentially exceeding document size limits. Referencing keeps documents smaller and more manageable.
Frequently changing data: If the related data changes frequently, embedding it can lead to unnecessary updates of the entire document, affecting performance and consistency. Referencing allows independent updates, improving maintenance and efficiency.
Flexibility and Scalability:
Data reusability: If the same related data is used by multiple documents, referencing avoids duplication and allows efficient data reuse across the schema. Nesting would lead to redundant storage and potential inconsistencies.
Evolving schema: Referencing provides greater flexibility for future schema changes, especially as relationships evolve or new entities are added. Nesting can become rigid and limit adaptability.
5-What are ORMs? Why we use them? Give an example of an SQL request with and without using ORM.
ORM stands for Object-Relational Mapping, which is a technique that allows developers to interact with a database using an object-oriented paradigm. ORMs abstract away the complexity of interfacing with a database and allow developers to write code in the language they are already using. ORMs can speed up development time, decrease the cost of development, handle the logic required to interact with databases, and improve security by eliminating the possibility of SQL injection attacks. However, learning how to use ORM tools can be time-consuming, and they may not perform better weps documents smaller and more manageable.
Frequently changing data: If the related data changes frequently, embedding it can lead to unnecessary updates of the entire document, affecting performance and consistency. Referencing allows independent updates, improving maintenance and efficiency.
5-What are ORMs? Why we use them? Give an example of an SQL request with and without using ORM.
ORM stands for Object-Relational Mapping, which is a technique that allows developers to interact with a database using an object-oriented paradigm. ORMs abstract away the complexity of interfacing with a database and allow developers to write code in the language they are already using. ORMs can speed up development time, decrease the cost of development, handle the logic required to interact with databases, and improve security by eliminating the possibility of SQL injection attacks. However, learning how to use ORM tools can be time-consuming, and they may not perform better when very complex queries are involved.
Example of an SQL request to retrieve information about a particular user:
SELECT * FROM users WHERE id = 123;
Example of the same request using an ORM:
User.find(123)hen very complex queries are involved.
Example of an SQL request to retrieve information about a particular user:
SELECT * FROM users WHERE id = 123;
Example of the same request using an ORM:
User.find(123)
6-What is the difference between a table and a collection?
Gorgees , Ammar, Lubna
Embedded documents are an efficient and clean way to store related data, especially data that’s regularly accessed together. In general, when designing schemas for MongoDB, you should prefer embedding by default, and use references and application-side or database-side joins only when they’re worthwhile. The more often a given workload can retrieve a single document and have all the data it needs, the more consistently high-performance your application will be.
MongoDB applications use one of two methods to relate documents: Manual references save the _id field of one document in another document as a reference. Your application runs a second query to return the related data. These references are simple and sufficient for most use cases.
Referencing is how you acknowledge the source of the information you have used (referred to) in your work. It helps to make clear to the reader how you have used the work of others to develop your own ideas and arguments.
Object Relational Mapping a library that makes it easier to communicate with a database in code. It is basically a technique to query or perform CRUD (Create, Read, Update, Delete) operations to the database, mainly RDBMS (Relational Databases), using an object-oriented paradigm. With the help of ORM, you don"t actually need to use SQL at all. You can directly interact with the database and perform queries in the same language you are using for your back-end code
tables have a fixed schema and adding new columns requires modifying the entire table, collections can contain documents with different structures.
Example:
const mysql = require("mysql");
const conn = mysql.createConnection({
host: "localhost",
user: "your_username",
password: "you_password",
database: "mydb",
});
conn.connect(function (error) {
if (error) {
console.log(error);
} else {
console.log("Connected!");
let sql = "INSERT INTO Users (username, password) VALUES ('john-doe', 'randompassword')";
conn.query(sql, function (error, result) {
if (error) {
console.log(error);
} else {
console.log(result);
}
});
}
});
Using Sequelize, the same code would become:
const Sequelize = require("sequelize");
const sequelize = new Sequelize("mydb1", "your_username", "your_password", {
dialect: "mysql",
});
//Defining User model
const User = sequelize.define("User", {
username: Sequelize.STRING,
password: Sequelize.STRING,
});
sequelize.sync();
User.create({
username: "john-doe",
password: "randompassword",
}).then(function (user) {
console.log(user);
});
Jana AbuHaltam, Raneem AlHamarneh, Mohamad Alchehabi, Hala Qitouqa
Q1
SQL are relational databases and NoSQL are non-relational databases
SQL databases are vertically scalable, NoSQL databases are horizontally scalable
SQL are table-based, NoSQL could be key-value pairs, document-based, graph databases or wide-column stores
Examples of SQL databases: Oracle, MySQL
Examples of noSQL databases: MongoDB and CouchDB
Q2 Embedded Documents:
Used for one-to-many relationships with a "contains" or "has a" association.
Example: Blog posts containing multiple comments. All comments are embedded within the blog post document.
Pros: Better performance for read and update operations as everything is in a single document.
Cons: Risk of data duplication and limited by the maximum document size of 16MB.
References (Manual References):
Used for many-to-many relationships and complex hierarchical data.
Example: Blog posts and comments stored in separate collections; comments reference the blog post’s _id.
Pros: Avoids data duplication and is effective for complex relationships.
Cons: Slower read performance due to the need for multiple queries to join related data.
Q3 Referencing saves space and allows for more scalability, but it can be slower due to multiple queries and can be complex to maintain data consistency. Choosing between them depends on your specific needs regarding performance, data size, and complexity.
Q4 use referencing when dealing with large, complex, frequently changing, or interrelated datasets where embedding would be impractical or inefficient.
Q5 1-Simplifies Code
2-Enhances Maintainability
3-Database Abstraction
4-Reduces Boilerplate
Without ORM (Using Raw SQL in Node.js):
the code in JS
const mysql = require('mysql');
// Create connection
const connection = mysql.createConnection({
host: 'localhost',
user: 'your_username',
password: 'your_password',
database: 'your_database'
});
// Connect to MySQL
connection.connect();
// Execute query
connection.query('SELECT * FROM users WHERE age > 30', (error, results, fields) => {
if (error) throw error;
// results is an array of records
const users_over_30 = results;
console.log(users_over_30);
});
// Close connection
connection.end();
With ORM (Using an ORM in Node.js):
const { Sequelize, Model, DataTypes } = require('sequelize');
// Connect to a database
const sequelize = new Sequelize('your_database', 'your_username', 'your_password', {
host: 'localhost',
dialect: 'mysql' // or 'sqlite', 'postgres', 'mssql'
});
class User extends Model {}
User.init({
// Assuming a model structure, modify as needed
age: DataTypes.INTEGER
}, { sequelize, modelName: 'user' });
async function getUsersOver30() {
const users_over_30 = await User.findAll({
where: {
age: {
[Sequelize.Op.gt]: 30
}
}
});
return users_over_30;
}
getUsersOver30().then(users => console.log(users));
Q6 table is structured collection of data organized in rows and columns
in collections, data is organized in documents
mohmmad smadi , nour kayyali , hakeema alzaidanin , ahmad juma
1-SQL databases are relational, and NoSQL databases are non-relational
2-SQL databases use structured query language (SQL) and have a predefined schema. NoSQL databases have dynamic schemas for unstructured data
3-SQL databases are vertically scalable, while NoSQL databases are horizontally scalable.
Embedding: Stores related data directly within a single document, nesting it as subdocuments.
Referencing : Stores a reference (usually the _id field) to a related document in a separate collection.
Similar to foreign keys in relational databases.
Reduced Number of Queries, Faster Access to Data
The typical rule is:
What you use together, store together.
5)ORM (Object Relational Mapping) is a library that makes it easier to communicate with a database in code.
It is basically a technique to query or perform CRUD (Create, Read, Update, Delete) operations to the database, mainly RDBMS (Relational Databases), using an object-oriented paradigm. it makes CRUD operations faster.
ex: without using ORM :
const mysql = require("mysql");
const conn = mysql.createConnection({
host: "localhost",
user: "your_username",
password: "you_password",
database: "mydb",
});
conn.connect(function (error) {
if (error) {
console.log(error);
} else {
console.log("Connected!");
let sql = "INSERT INTO Users (username, password) VALUES ('john-doe', 'randompassword')";
conn.query(sql, function (error, result) {
if (error) {
console.log(error);
} else {
console.log(result);
}
});
}
});
with using ORM:
const Sequelize = require("sequelize");
const sequelize = new Sequelize("mydb1", "your_username", "your_password", {
dialect: "mysql",
});
//Defining User model
const User = sequelize.define("User", {
username: Sequelize.STRING,
password: Sequelize.STRING,
});
sequelize.sync();
User.create({
username: "john-doe",
password: "randompassword",
}).then(function (user) {
console.log(user);
});
collections is a group of documents , a document is like a table in relational database