### 1. **Bases de données relationnelles vs NoSQL**
#### **Bases de données relationnelles (ex: MySQL, PostgreSQL)**
- **Structure** : Organisées en tables avec des lignes (enregistrements) et des colonnes (attributs).
- **Modèle relationnel** : Les données sont liées entre elles par des clés (clé primaire, clé étrangère).
- **Requêtes** : Utilisation du langage SQL (Structured Query Language).
- **Cas d’usage** : Parfait pour les systèmes ayant des relations complexes entre les données (e.g. ERP, CRM).
**Exemple (MySQL)** :
```sql
CREATE TABLE Users (
id INT AUTO_INCREMENT PRIMARY KEY,
name VARCHAR(50),
email VARCHAR(100)
);
INSERT INTO Users (name, email) VALUES ('John Doe', 'john@example.com');
```
#### **Bases de données NoSQL (ex: MongoDB, Firebase Firestore)**
- **Structure** : Non relationnelles, les données sont stockées dans des documents JSON-like.
- **Modèle flexible** : Pas besoin de schéma strict, chaque document peut avoir une structure différente.
- **Requêtes** : Utilisation de JSON pour les requêtes, pas de SQL.
- **Cas d’usage** : Utilisées pour des applications nécessitant une grande scalabilité et flexibilité (e.g. réseaux sociaux, IoT).
**Exemple (MongoDB)** :
```json
{
"_id": "1",
"name": "John Doe",
"email": "john@example.com"
}
```
### 2. **Fonctionnement de Firebase Firestore**
Firebase Firestore est une base de données NoSQL qui stocke des données sous forme de **documents** et **collections**.
- **Document** : Un document est une entrée dans une collection et contient des paires clé-valeur (comme un objet JSON).
- **Collection** : Une collection est un ensemble de documents. Par exemple, la collection `Users` peut contenir plusieurs documents représentant chaque utilisateur.
**Exemple dans Firebase :**
- Collection: `Users`
- Document: `User1` (clé: `name: "John Doe", email: "john@example.com"`)
- Document: `User2` (clé: `name: "Jane Smith", email: "jane@example.com"`)
#### Ajouter un document dans Firestore :
```javascript
db.collection("Users").add({
name: "John Doe",
email: "john@example.com"
});
```
### 3. **CRUD : Create, Read, Update, Delete**
Le CRUD représente les 4 opérations principales pour manipuler les données dans une base de données.
#### **CRUD avec MySQL :**
- **Create (Insérer un enregistrement)** :
```sql
INSERT INTO Users (name, email) VALUES ('Alice', 'alice@example.com');
```
- **Read (Lire des enregistrements)** :
```sql
SELECT * FROM Users;
```
- **Update (Mettre à jour un enregistrement)** :
```sql
UPDATE Users SET email = 'newalice@example.com' WHERE name = 'Alice';
```
- **Delete (Supprimer un enregistrement)** :
```sql
DELETE FROM Users WHERE name = 'Alice';
```
#### **CRUD avec Firebase :**
- **Create (Ajouter un document)** :
```javascript
db.collection("Users").add({
name: "Alice",
email: "alice@example.com"
});
```
- **Read (Lire un document)** :
```javascript
db.collection("Users").doc("User1").get().then((doc) => {
console.log(doc.data());
});
```
- **Update (Mettre à jour un document)** :
```javascript
db.collection("Users").doc("User1").update({
email: "newalice@example.com"
});
```
- **Delete (Supprimer un document)** :
```javascript
db.collection("Users").doc("User1").delete();
```
### 4. **Différences principales entre bases relationnelles et NoSQL** :
- **Schéma rigide vs flexible** : Les bases relationnelles nécessitent un schéma fixe (tables, colonnes définies à l'avance), alors que les bases NoSQL comme MongoDB ou Firebase sont plus flexibles et n'imposent pas de schéma rigide.
- **Scalabilité** : Les bases NoSQL sont souvent mieux adaptées pour la scalabilité horizontale, car elles sont conçues pour distribuer les données sur plusieurs serveurs.
- **Requêtes complexes** : Les bases relationnelles sont plus performantes pour les requêtes complexes impliquant des jointures entre plusieurs tables, ce qui peut être plus difficile à réaliser avec des bases NoSQL.
J’espère que ce pense-bête te sera utile !
Sign in with Wallet
Connect another wallet