---
# System prepended metadata

title: Questions Base de données relationnel et noSQL

---

### 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 !