# Fichier: python_cheats/cheatsheets/introduction_mysql.txt
# Introduction MySQL (Relationnel) - Pour Grands Débutants
# Comprendre MySQL de A à Z : Architecture, Fonctionnement, Pratique

"""
[OK] INTRODUCTION : POURQUOI CE GUIDE ?

# Tu débutes avec les bases de données relationnelles et MySQL ?
# Ce guide est fait pour TOI !

# Objectif :
# Te montrer EXACTEMENT comment MySQL fonctionne "sous le capot"
# Comprendre ce qui se passe quand tu exécutes une requête SQL
# Découvrir TOUS les fichiers créés et leur rôle précis
# Maîtriser les concepts relationnels (tables, jointures, transactions)
# Aucun concept ne sera laissé dans le flou !

# Plan du guide :
# 1. Qu'est-ce qu'une base de données relationnelle et pourquoi MySQL ?
# 2. Histoire et évolution de MySQL
# 3. Installation et fichiers créés (détail complet)
# 4. Architecture interne de MySQL
# 5. Du SQL à l'exécution : voyage complet d'une requête
# 6. Moteurs de stockage (InnoDB vs MyISAM)
# 7. Types de données et modélisation
# 8. Index et optimisation de performance
# 9. Transactions ACID et verrouillage
# 10. Jointures et relations entre tables
# 11. Réplication et haute disponibilité
# 12. Procédures stockées, triggers et vues
# 13. Sécurité et gestion des utilisateurs
# 14. Monitoring et maintenance
# 15. Premiers pas pratiques
# 16. Cas d'usage réels et bonnes pratiques
"""


# [OK] PARTIE 1 : QU'EST-CE QU'UNE BASE DE DONNÉES RELATIONNELLE ?

"""
┌────────────────────────────────────────────────────────────────────────┐
│           BASES DE DONNÉES RELATIONNELLES : LES FONDATIONS             │
└────────────────────────────────────────────────────────────────────────┘

CONTEXTE HISTORIQUE :
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

AVANT 1970 : ÈRE DES FICHIERS PLATS
-> Données stockées dans des fichiers texte
-> Pas de structure standardisée
-> Accès séquentiel uniquement
-> Redondance massive
-> Pas d'intégrité des données

PROBLÈMES :
[X] Duplication des données partout
[X] Incohérences fréquentes
[X] Difficile de maintenir
[X] Pas de relations entre données
[X] Pas de contrôle d'accès

RÉVOLUTION 1970 : MODÈLE RELATIONNEL (Edgar F. Codd, IBM)
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

Edgar F. Codd publie "A Relational Model of Data for Large Shared Data Banks"

IDÉES RÉVOLUTIONNAIRES :
-> Organiser les données en TABLES (relations mathématiques)
-> Éliminer la redondance (normalisation)
-> Langage déclaratif (SQL) au lieu de procédural
-> Indépendance physique/logique
-> Intégrité référentielle

NAISSANCE DU SQL (Structured Query Language) :
-> 1974 : IBM développe SEQUEL (Structured English Query Language)
-> 1979 : Renommé SQL
-> 1986 : Standardisation ANSI SQL
-> Devient LE langage universel des bases de données


ANALOGIE : BIBLIOTHÈQUE vs PILE DE LIVRES
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

FICHIERS PLATS (pile de livres) :
┌────────────────────────────────────────────────────────────────────┐
│ [DOCS] PILE DE LIVRES EN VRAC                                          │
│                                                                    │
│ Livre 1 : "MySQL" | Auteur: Jean | Date: 2020 | Prix: 50€        │
│ Livre 2 : "Python" | Auteur: Marie | Date: 2021 | Prix: 45€      │
│ Livre 3 : "MySQL" | Auteur: Jean | Date: 2020 | Prix: 50€  <- DUP!│
│ Livre 4 : "Java" | Auteur: Pierre | Date: 2019 | Prix: 60€       │
│                                                                    │
│ Problèmes :                                                        │
│ [X] Informations dupliquées (Jean apparaît 2 fois)                  │
│ [X] Si le prix du livre MySQL change -> modifier 2 fois !            │
│ [X] Recherche lente (tout lire séquentiellement)                    │
│ [X] Pas de garantie d'intégrité                                     │
└────────────────────────────────────────────────────────────────────┘

BASE DE DONNÉES RELATIONNELLE (bibliothèque organisée) :
┌────────────────────────────────────────────────────────────────────┐
│ [DOCS] BIBLIOTHÈQUE AVEC SYSTÈME DE FICHES                             │
│                                                                    │
│ TABLE: livres                                                      │
│ ┌────┬─────────┬────────────┬──────┬───────┐                      │
│ │ id │  titre  │ auteur_id  │ date │ prix  │                      │
│ ├────┼─────────┼────────────┼──────┼───────┤                      │
│ │ 1  │ MySQL   │ 101        │ 2020 │ 50€   │                      │
│ │ 2  │ Python  │ 102        │ 2021 │ 45€   │                      │
│ │ 3  │ Java    │ 103        │ 2019 │ 60€   │                      │
│ └────┴─────────┴────────────┴──────┴───────┘                      │
│                                                                    │
│ TABLE: auteurs                                                     │
│ ┌────┬────────┬──────────────────────┐                            │
│ │ id │  nom   │       email          │                            │
│ ├────┼────────┼──────────────────────┤                            │
│ │101 │ Jean   │ jean@example.com     │                            │
│ │102 │ Marie  │ marie@example.com    │                            │
│ │103 │ Pierre │ pierre@example.com   │                            │
│ └────┴────────┴──────────────────────┘                            │
│                                                                    │
│ Avantages :                                                        │
│ [OK] Informations de Jean stockées UNE SEULE FOIS                    │
│ [OK] Relations via clés étrangères (auteur_id)                       │
│ [OK] Recherche ultra-rapide avec index                               │
│ [OK] Intégrité garantie (contraintes)                                │
│ [OK] Pas de redondance                                               │
└────────────────────────────────────────────────────────────────────┘


CONCEPTS CLÉS DU MODÈLE RELATIONNEL :
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

1. TABLE (Relation) :
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-> Structure bidimensionnelle (lignes × colonnes)
-> Représente un ensemble d'entités similaires
-> Chaque ligne = un enregistrement (tuple)
-> Chaque colonne = un attribut

Exemple :
TABLE utilisateurs
┌────┬──────────┬──────────────────────┬─────┐
│ id │   nom    │        email         │ age │
├────┼──────────┼──────────────────────┼─────┤
│ 1  │ Jean     │ jean@example.com     │ 30  │
│ 2  │ Marie    │ marie@example.com    │ 25  │
│ 3  │ Pierre   │ pierre@example.com   │ 35  │
└────┴──────────┴──────────────────────┴─────┘

2. CLÉ PRIMAIRE (Primary Key) :
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-> Identifiant UNIQUE pour chaque ligne
-> Ne peut pas être NULL
-> Immuable (ne change jamais)
-> Généralement un entier auto-incrémenté

Dans l'exemple ci-dessus : "id" est la clé primaire

RÈGLES :
[OK] Une seule clé primaire par table
[OK] Peut être composée (plusieurs colonnes)
[OK] Doit être unique
[OK] Pas de NULL

3. CLÉ ÉTRANGÈRE (Foreign Key) :
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-> Référence une clé primaire d'une autre table
-> Établit une RELATION entre tables
-> Garantit l'intégrité référentielle

Exemple :
TABLE commandes
┌────┬──────────────┬────────────┐
│ id │ utilisateur  │   montant  │
│    │     _id      │            │
├────┼──────────────┼────────────┤
│ 1  │ 1            │ 100€       │ <- Référence utilisateur id=1 (Jean)
│ 2  │ 2            │ 150€       │ <- Référence utilisateur id=2 (Marie)
│ 3  │ 1            │ 200€       │ <- Référence utilisateur id=1 (Jean)
└────┴──────────────┴────────────┘

INTÉGRITÉ RÉFÉRENTIELLE :
-> Impossible de créer une commande avec utilisateur_id = 999 (n'existe pas)
-> Impossible de supprimer un utilisateur ayant des commandes (par défaut)

4. NORMALISATION :
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-> Processus d'organisation des données
-> Éliminer la redondance
-> Minimiser les anomalies d'insertion/modification/suppression
-> Plusieurs niveaux (formes normales) : 1NF, 2NF, 3NF, BCNF, 4NF, 5NF

EXEMPLE DE DÉNORMALISATION (mauvais) :
┌────┬──────────┬──────────────────────┬────────────────┐
│ id │   nom    │        email         │  commandes     │
├────┼──────────┼──────────────────────┼────────────────┤
│ 1  │ Jean     │ jean@example.com     │ 100€, 200€     │ [X] Redondance
│ 2  │ Marie    │ marie@example.com    │ 150€           │
└────┴──────────┴──────────────────────┴────────────────┘

EXEMPLE NORMALISÉ (bon) :
TABLE utilisateurs + TABLE commandes (avec clé étrangère)

5. CONTRAINTES D'INTÉGRITÉ :
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-> Règles appliquées par le SGBD
-> Garantissent la cohérence des données

Types de contraintes :
• PRIMARY KEY : Unicité et non-nullité
• FOREIGN KEY : Intégrité référentielle
• UNIQUE : Valeur unique (mais NULL autorisé)
• NOT NULL : Valeur obligatoire
• CHECK : Validation personnalisée (ex: age >= 18)
• DEFAULT : Valeur par défaut

Exemple :
CREATE TABLE utilisateurs (
    id INT PRIMARY KEY AUTO_INCREMENT,
    nom VARCHAR(100) NOT NULL,
    email VARCHAR(255) UNIQUE NOT NULL,
    age INT CHECK (age >= 18),
    pays VARCHAR(50) DEFAULT 'France',
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);


POURQUOI MySQL ?
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

MySQL = "My" (prénom fille du co-fondateur) + "SQL"

HISTORIQUE :
-> 1995 : Créé par Michael Widenius et David Axmark (MySQL AB)
-> 2008 : Racheté par Sun Microsystems (1 milliard $)
-> 2010 : Oracle rachète Sun -> Oracle possède MySQL
-> Fork : MariaDB (2009, par Michael Widenius, 100% compatible)

VERSION ACTUELLE : MySQL 8.x (depuis 2018)

POINTS FORTS DE MySQL :
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

[OK] Open Source (GPL) + Version commerciale
[OK] Très performant (optimisé pour lecture intensive)
[OK] Facile à installer et configurer
[OK] Écosystème riche (phpMyAdmin, MySQL Workbench, etc.)
[OK] Support communautaire énorme
[OK] ACID complet (avec InnoDB)
[OK] Réplication intégrée
[OK] Multiplateforme (Linux, Windows, macOS)
[OK] Scalabilité verticale et horizontale
[OK] Compatible avec presque tous les langages (PHP, Python, Java, C#, etc.)

UTILISATION :
-> WordPress, Drupal, Joomla (CMS)
-> Facebook, Twitter, YouTube, Netflix
-> Uber, Airbnb, Booking.com
-> GitHub, Slack
-> 70% des sites web utilisant une base de données


QUI UTILISE MySQL ?
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

GÉANTS DU WEB :
-> Facebook : Stockage de métadonnées, messages
-> Twitter : Timeline, tweets
-> YouTube : Métadonnées vidéos
-> Netflix : Catalogue, recommandations
-> Uber : Géolocalisation temps réel
-> GitHub : Repositories, issues, pull requests
-> Slack : Messages, canaux

CMS ET E-COMMERCE :
-> WordPress : 43% du web
-> Shopify : E-commerce
-> Magento : E-commerce
-> PrestaShop : E-commerce


TABLEAU COMPARATIF : MySQL vs PostgreSQL vs SQLite
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
┌─────────────────────┬──────────────┬──────────────┬──────────────┐
│  Caractéristique    │    MySQL     │ PostgreSQL   │   SQLite     │
├─────────────────────┼──────────────┼──────────────┼──────────────┤
│ Type                │ Client/Serveur│Client/Serveur│ Embarqué     │
│ Licence             │ GPL + Comm.  │ PostgreSQL   │ Public Domain│
│ Performances read   │ Excellent    │ Très bon     │ Très bon     │
│ Performances write  │ Très bon     │ Excellent    │ Bon          │
│ Transactions ACID   │ Oui (InnoDB) │ Oui (natif)  │ Oui          │
│ Concurrence         │ Très bonne   │ Excellente   │ Limitée      │
│ Réplication         │ Oui (native) │ Oui (native) │ Non          │
│ JSON                │ Oui (MySQL≥5.7│Excellent JSONB│Oui (limité)│
│ Full-text search    │ Oui (InnoDB) │ Oui (avancé) │ Basique      │
│ Géospatial          │ Oui (≥5.7)   │ PostGIS (ext)│ Oui (≥3.35)  │
│ Fenêtres (Window)   │ Oui (≥8.0)   │ Oui          │ Oui (≥3.25)  │
│ CTE récursifs       │ Oui (≥8.0)   │ Oui          │ Oui (≥3.8)   │
│ Types personnalisés │ Limité       │ Excellent    │ Non          │
│ Extensibilité       │ Plugins      │ Extensions   │ Non          │
│ Complexité          │ Moyenne      │ Élevée       │ Simple       │
│ Facilité config     │ Très facile  │ Moyenne      │ Aucune       │
│ Cas d'usage         │ Web, CMS     │ Data, BI     │ Mobile, embed│
│ Taille              │ ~500 MB      │ ~300 MB      │ ~1 MB        │
└─────────────────────┴──────────────┴──────────────┴──────────────┘


MySQL vs MongoDB (Relationnel vs NoSQL) :
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
┌─────────────────────┬──────────────────────┬─────────────────────┐
│  Aspect             │       MySQL          │      MongoDB        │
├─────────────────────┼──────────────────────┼─────────────────────┤
│ Modèle              │ Relationnel (tables) │ Documents (JSON)    │
│ Schéma              │ Rigide (DDL)         │ Flexible            │
│ Langage             │ SQL                  │ MongoDB Query Lang  │
│ Normalisation       │ Obligatoire          │ Dénormalisation     │
│ Jointures           │ Natives (JOIN)       │ $lookup (limité)    │
│ Transactions        │ ACID complet         │ ACID (depuis 4.0)   │
│ Scalabilité         │ Verticale surtout    │ Horizontale native  │
│ Index               │ B-Tree, Hash, R-Tree │ B-Tree, Texte, Geo  │
│ Cohérence           │ Immédiate (CP)       │ Éventuelle (AP)     │
│ Intégrité réf.      │ Contraintes FK       │ Application         │
│ Courbe apprenti.    │ SQL universel        │ Plus douce          │
│ Cas d'usage         │ Transactionnel, ERP  │ Web évolutif, IoT   │
└─────────────────────┴──────────────────────┴─────────────────────┘

QUAND UTILISER MySQL ?
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

[OK] OUI SI :
-> Données structurées et stables
-> Relations complexes entre entités
-> Intégrité référentielle critique
-> Transactions ACID essentielles
-> Requêtes complexes avec jointures
-> Rapports et analytics (BI)
-> Application traditionnelle (CMS, e-commerce)

[X] NON SI :
-> Schéma très variable (utiliser MongoDB)
-> Besoin de scalabilité horizontale massive (utiliser MongoDB ou Cassandra)
-> Données non structurées (utiliser MongoDB)
-> Application embarquée simple (utiliser SQLite)
"""


# [OK] PARTIE 2 : HISTOIRE ET ÉVOLUTION DE MySQL

"""
┌────────────────────────────────────────────────────────────────────────┐
│                    CHRONOLOGIE MySQL                                   │
└────────────────────────────────────────────────────────────────────────┘

LIGNE DU TEMPS :
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

1995 : MySQL 1.0
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-> Créé par Michael "Monty" Widenius et David Axmark
-> Objectif : Base de données rapide pour le web
-> Moteur ISAM (pas de transactions)

1996 : MySQL 3.11
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-> Première version publique
-> Licence GPL (Open Source)
-> Très rapide mais fonctionnalités limitées

2000 : MySQL 3.23
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-> Support de MyISAM (remplace ISAM)
-> Full-text search
-> Réplication basique

2001 : MySQL 4.0
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-> Support InnoDB (transactions ACID !)
-> UNION
-> Query cache

2004 : MySQL 4.1
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-> Subqueries (sous-requêtes)
-> UTF-8
-> Prepared statements

2005 : MySQL 5.0
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-> Stored procedures (procédures stockées)
-> Triggers
-> Views (vues)
-> Cursors
-> Information_schema

2008 : Sun Microsystems rachète MySQL AB (1 milliard $)
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

2009 : MariaDB fork
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-> Créé par Monty Widenius (créateur original de MySQL)
-> Inquiétudes sur l'avenir de MySQL sous Oracle
-> 100% compatible MySQL
-> Plus d'innovations

2010 : Oracle rachète Sun Microsystems -> MySQL devient propriété Oracle
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

2010 : MySQL 5.5
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-> InnoDB devient moteur par défaut (au lieu de MyISAM)
-> Semi-synchronous replication
-> Performances améliorées (3-5x)

2013 : MySQL 5.6
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-> Online DDL (ALTER TABLE sans downtime)
-> GTID (Global Transaction ID) pour réplication
-> Full-text search pour InnoDB
-> Performance Schema amélioré

2015 : MySQL 5.7
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-> JSON native support [BRAVO]
-> Generated columns (colonnes calculées)
-> Performances × 3
-> sys schema (monitoring)
-> Réplication multi-source

2018 : MySQL 8.0 (version actuelle majeure)
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-> Window functions (OVER, PARTITION BY) [BRAVO]
-> CTE récursifs (WITH RECURSIVE) [BRAVO]
-> JSON enhancements (JSON_TABLE)
-> Rôles (ROLES) pour sécurité
-> Invisible indexes
-> Amélioration drastique des performances
-> Data dictionary transactionnel
-> Descending indexes
-> UTF8mb4 par défaut

2024 : MySQL 8.4 LTS (Long Term Support)
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-> Support jusqu'en 2032
-> Améliorations continues des performances


ÉDITIONS MySQL :
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

1. MySQL Community Edition (Gratuit, GPL)
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-> Totalement gratuit
-> Code source disponible
-> Toutes les fonctionnalités de base
-> Support communautaire

2. MySQL Enterprise Edition (Payant)
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-> Support Oracle 24/7
-> MySQL Enterprise Monitor (monitoring avancé)
-> MySQL Enterprise Backup (sauvegarde hot)
-> MySQL Enterprise Security (audit, chiffrement)
-> MySQL Enterprise Firewall
-> Prix : ~5000-10000$/an selon taille

3. MySQL Cluster (Haute disponibilité)
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-> Architecture distribuée
-> Auto-sharding
-> 99.999% uptime
-> Pas de single point of failure
"""


# [OK] PARTIE 3 : INSTALLATION ET FICHIERS CRÉÉS

"""
┌────────────────────────────────────────────────────────────────────────┐
│              INSTALLATION MySQL (LINUX/MAC/WINDOWS)                    │
└────────────────────────────────────────────────────────────────────────┘

MÉTHODES D'INSTALLATION :
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
1. Package manager (apt, yum, brew)
2. Téléchargement binaires officiels
3. Docker (recommandé pour développement)
4. MySQL Installer (Windows)
5. Cloud (AWS RDS, Google Cloud SQL, Azure MySQL)


INSTALLATION UBUNTU/DEBIAN :
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

# Mettre à jour les packages
sudo apt update

# Installer MySQL Server
sudo apt install mysql-server

# Démarrer MySQL
sudo systemctl start mysql
sudo systemctl enable mysql

# Vérifier le statut
sudo systemctl status mysql

# Sécurisation (IMPORTANT !)
sudo mysql_secure_installation

Questions posées :
1. Définir un mot de passe root ? -> OUI
2. Supprimer utilisateurs anonymes ? -> OUI
3. Interdire connexion root à distance ? -> OUI (sauf si cluster)
4. Supprimer base de données test ? -> OUI
5. Recharger privilèges ? -> OUI

[ALARM_CLOCK] Durée d'installation : 2-5 minutes


INSTALLATION macOS (Homebrew) :
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

# Installer MySQL
brew install mysql

# Démarrer MySQL comme service
brew services start mysql

# Ou démarrer manuellement
mysql.server start

# Connexion
mysql -u root


INSTALLATION WINDOWS :
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

1. Télécharger MySQL Installer depuis mysql.com
2. Exécuter mysql-installer-community-x.x.xx.msi
3. Choisir "Developer Default" ou "Server only"
4. Suivre l'assistant :
   -> Type d'installation : Standalone
   -> Configuration réseau : Port 3306, TCP/IP
   -> Authentification : caching_sha2_password
   -> Mot de passe root : FORT !
   -> Windows Service : MySQL80 (démarrage automatique)
5. Installer MySQL Workbench (GUI)

Répertoire par défaut :
C:\Program Files\MySQL\MySQL Server 8.0\


INSTALLATION DOCKER (Recommandé pour développement) :
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

# Télécharger et démarrer MySQL
docker run -d \
  --name mysql \
  -p 3306:3306 \
  -v mysql_data:/var/lib/mysql \
  -e MYSQL_ROOT_PASSWORD=motdepasse123 \
  -e MYSQL_DATABASE=myapp \
  -e MYSQL_USER=appuser \
  -e MYSQL_PASSWORD=apppassword \
  mysql:8.0

# Se connecter au shell MySQL
docker exec -it mysql mysql -u root -p

# Voir les logs
docker logs mysql

Avantages Docker :
[OK] Installation propre (pas de pollution système)
[OK] Versions multiples possibles
[OK] Facile à détruire et recréer
[OK] Même environnement sur tous les OS


STRUCTURE DES FICHIERS MySQL :
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

ARBORESCENCE COMPLÈTE (Linux - /var/lib/mysql/) :
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

/var/lib/mysql/                        <- Répertoire de données (datadir)
├── auto.cnf                           <- UUID du serveur
├── binlog.000001                      <- Binary log (réplication)
├── binlog.000002
├── binlog.index                       <- Index des binary logs
├── ca-key.pem                         <- Certificat SSL (CA)
├── ca.pem
├── client-cert.pem                    <- Certificat client SSL
├── client-key.pem
├── server-cert.pem                    <- Certificat serveur SSL
├── server-key.pem
├── ib_buffer_pool                     <- InnoDB buffer pool snapshot
├── ib_logfile0                        <- InnoDB redo log (OBSOLÈTE ≥8.0.30)
├── ib_logfile1
├── ibdata1                            <- InnoDB tablespace système
├── ibtmp1                             <- InnoDB temp tablespace
├── mysql.ibd                          <- Tablespace mysql (≥8.0)
├── undo_001                           <- InnoDB undo tablespace
├── undo_002
├── #ib_16384_0.dblwr                  <- InnoDB doublewrite buffer (≥8.0.20)
├── #ib_16384_1.dblwr
├── #innodb_temp/                      <- Répertoire temporaire InnoDB
│   └── temp_1.ibt
├── #innodb_redo/                      <- InnoDB redo log (≥8.0.30)
│   ├── #ib_redo0
│   ├── #ib_redo1
│   └── #ib_redo2
├── mysql/                             <- Base système mysql
│   ├── user.ibd                       <- Table utilisateurs
│   ├── db.ibd                         <- Permissions databases
│   ├── tables_priv.ibd                <- Permissions tables
│   ├── columns_priv.ibd               <- Permissions colonnes
│   └── ...
├── performance_schema/                <- Base performance_schema
│   └── (tables mémoire uniquement)
├── sys/                               <- Base sys (vues monitoring)
│   └── (vues uniquement)
├── myapp/                             <- Base utilisateur
│   ├── users.ibd                      <- Table users
│   ├── orders.ibd                     <- Table orders
│   ├── products.ibd                   <- Table products
│   └── ...
├── mysql.sock                         <- Socket Unix (connexions locales)
└── mysqld.pid                         <- PID du processus mysqld

/etc/mysql/
├── my.cnf                             <- Configuration principale
├── conf.d/                            <- Configs additionnelles
│   └── mysql.cnf
└── mysql.conf.d/
    └── mysqld.cnf                     <- Config serveur

/var/log/mysql/
└── error.log                          <- Log des erreurs

/var/run/mysqld/
└── mysqld.sock                        <- Socket (peut être ici aussi)


DÉTAIL DE CHAQUE TYPE DE FICHIER :
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

1. FICHIERS DE DONNÉES (.ibd) - INNODB FILE-PER-TABLE
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

Exemple : myapp/users.ibd

RÔLE :
-> Contient les données ET les index d'une table
-> Un fichier .ibd par table (avec innodb_file_per_table=ON, par défaut)

STRUCTURE INTERNE :
-> Pages de 16 KB (par défaut)
-> Organisées en B+Tree
-> Compression possible (ROW_FORMAT=COMPRESSED)

TAILLE TYPIQUE :
-> 10 000 lignes de 1 KB ≈ 10 MB
-> Avec index : + 20-30%

VISUALISER LA TAILLE :
SELECT 
    table_name,
    ROUND((data_length + index_length) / 1024 / 1024, 2) AS size_mb
FROM information_schema.tables
WHERE table_schema = 'myapp';


2. ibdata1 - INNODB SYSTEM TABLESPACE
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

RÔLE CRITIQUE :
-> Data dictionary (≥8.0, avant c'était dans .frm)
-> Undo logs (historique des transactions)
-> Change buffer (optimisation insertions index)
-> Doublewrite buffer (protection corruption, <8.0.20)

TAILLE :
-> Démarre à 12 MB
-> Croît automatiquement (auto-extend)
-> NE SE RÉDUIT JAMAIS (par design !)

PROBLÈME FRÉQUENT :
-> ibdata1 peut grossir indéfiniment
-> Contient des données "zombie" de tables supprimées

SOLUTION :
-> Vider et recréer (export/import)
-> Ou utiliser innodb_file_per_table=ON (par défaut ≥5.6)


3. #innodb_redo/ - REDO LOG (WAL - Write-Ahead Log)
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

ANCIENS NOMS (≤8.0.29) : ib_logfile0, ib_logfile1
NOUVEAUX NOMS (≥8.0.30) : #innodb_redo/#ib_redo0, #ib_redo1, etc.

RÔLE CRUCIAL (Durabilité ACID) :
-> Enregistre TOUTES les modifications AVANT qu'elles soient écrites sur disque
-> Garantit la durabilité (le D dans ACID)
-> Permet la récupération après crash

FONCTIONNEMENT :
1. Transaction COMMIT
2. Écriture dans redo log (séquentielle, rapide)
3. Écriture dans buffer pool (mémoire)
4. Plus tard : flush sur disque (asynchrone)

EN CAS DE CRASH :
-> Au redémarrage : MySQL rejoue le redo log
-> Récupération de toutes les transactions validées
-> Rollback des transactions non validées (via undo log)

TAILLE PAR DÉFAUT : 48 MB × 2 = 96 MB

CONFIGURATION :
[mysqld]
innodb_redo_log_capacity = 512M  # MySQL ≥8.0.30

# Ou ancien paramètre
innodb_log_file_size = 256M       # MySQL <8.0.30
innodb_log_files_in_group = 2

IMPACT PERFORMANCE :
-> Trop petit : flush fréquents -> lent
-> Trop grand : récupération longue après crash


4. undo_001, undo_002 - UNDO TABLESPACE
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

RÔLE (MVCC - Multi-Version Concurrency Control) :
-> Stocke les ANCIENNES versions des lignes modifiées
-> Permet les lectures cohérentes sans bloquer les écritures
-> Rollback des transactions

EXEMPLE MVCC :

Transaction A commence (READ COMMITTED)
-> SELECT * FROM users WHERE id = 1;
-> Résultat : nom = "Jean", age = 30

Transaction B modifie (UPDATE)
-> UPDATE users SET age = 31 WHERE id = 1;
-> Ancienne version (age=30) sauvegardée dans undo log
-> Nouvelle version (age=31) écrite dans la table

Transaction A relit
-> SELECT * FROM users WHERE id = 1;
-> Résultat : nom = "Jean", age = 30 (ancienne version via undo)
-> Cohérence garantie !

Transaction B COMMIT
-> Ancienne version marquée pour nettoyage (purge)

PURGE :
-> Thread de purge nettoie les anciennes versions
-> Quand plus aucune transaction n'en a besoin

TAILLE :
-> 10 MB initialement
-> Croît automatiquement
-> Se réduit automatiquement (≥8.0.21)


5. binlog.000001, binlog.000002 - BINARY LOG
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

RÔLE (Réplication et Point-in-Time Recovery) :
-> Enregistre TOUTES les modifications (INSERT, UPDATE, DELETE)
-> Utilisé pour la réplication master -> slave
-> Permet la restauration à un moment précis (PITR)

FORMAT :
-> STATEMENT : Enregistre les requêtes SQL
-> ROW : Enregistre les changements de lignes (par défaut, plus sûr)
-> MIXED : Hybride

ROTATION :
-> Fichiers numérotés : binlog.000001, binlog.000002, etc.
-> Rotation quand taille max atteinte (max_binlog_size=1G par défaut)
-> Ou sur commande : FLUSH BINARY LOGS;

TAILLE :
-> 1 GB par fichier par défaut
-> Peut grossir très vite (haut volume d'écritures)

PURGE AUTOMATIQUE :
[mysqld]
expire_logs_days = 7  # Ou binlog_expire_logs_seconds = 604800

DÉSACTIVER (si pas de réplication) :
[mysqld]
skip-log-bin

ATTENTION : Sans binlog, pas de réplication ni de PITR !


6. #ib_16384_0.dblwr, #ib_16384_1.dblwr - DOUBLEWRITE BUFFER
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

RÔLE (Protection contre corruption) :
-> Résoudre le problème des "partial page writes"

PROBLÈME :
-> InnoDB écrit des pages de 16 KB
-> OS écrit généralement des secteurs de 512 bytes ou 4 KB
-> Si crash pendant écriture -> page corrompue !

SOLUTION DOUBLEWRITE :
1. InnoDB écrit d'abord dans doublewrite buffer (séquentiel, rapide)
2. Puis écrit dans les fichiers .ibd (positions réelles)
3. Si crash pendant (2) -> récupération depuis doublewrite buffer

LOCALISATION :
-> MySQL <8.0.20 : Dans ibdata1
-> MySQL ≥8.0.20 : Fichiers séparés (#ib_16384_*.dblwr)

DÉSACTIVATION (SSD avec protection) :
[mysqld]
innodb_doublewrite = 0

[ATTENTION] À ne faire que sur SSD avec protection matérielle !


7. mysql.sock - SOCKET UNIX
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

RÔLE :
-> Communication locale (même machine)
-> Plus rapide que TCP/IP
-> Utilisé par défaut quand host=localhost

EXEMPLE :
mysql -u root -p
# Équivalent à :
mysql -u root -p -h localhost -S /var/lib/mysql/mysql.sock

POUR FORCER TCP/IP :
mysql -u root -p -h 127.0.0.1


8. mysqld.pid - PROCESS ID
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

CONTENU :
-> PID (Process ID) du processus mysqld en cours

RÔLE :
-> Vérifier qu'un seul mysqld tourne
-> Scripts d'arrêt utilisent ce PID

EXEMPLE :
cat /var/lib/mysql/mysqld.pid
-> 12345

kill -SIGTERM 12345  # Arrêt gracieux


9. FICHIER DE CONFIGURATION : /etc/mysql/my.cnf
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

Format : INI (sections avec [])

EXEMPLE COMPLET :

[client]
port = 3306
socket = /var/lib/mysql/mysql.sock

[mysql]
# Configuration pour client mysql
no-auto-rehash
prompt = "\u@\h [\d]> "

[mysqld]
# ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
# GÉNÉRAL
# ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
user = mysql
pid-file = /var/run/mysqld/mysqld.pid
socket = /var/lib/mysql/mysql.sock
port = 3306
datadir = /var/lib/mysql
tmpdir = /tmp

# Bind à toutes les interfaces (ou seulement localhost pour sécurité)
bind-address = 0.0.0.0
# bind-address = 127.0.0.1  # Seulement local

# Character set
character-set-server = utf8mb4
collation-server = utf8mb4_unicode_ci

# ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
# CONNEXIONS
# ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
max_connections = 200           # Max connexions simultanées
max_connect_errors = 100000     # Éviter le blocage d'IP
wait_timeout = 28800            # 8 heures (secondes)
interactive_timeout = 28800

# ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
# INNODB - MOTEUR DE STOCKAGE
# ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
default-storage-engine = InnoDB

# Buffer Pool (cache) - 70-80% de la RAM pour serveur dédié
innodb_buffer_pool_size = 4G
innodb_buffer_pool_instances = 4    # 1 instance par GB

# Redo Log
innodb_redo_log_capacity = 512M     # MySQL ≥8.0.30
# innodb_log_file_size = 256M       # MySQL <8.0.30
# innodb_log_files_in_group = 2

# Doublewrite buffer
innodb_doublewrite = 1              # 1=ON, 0=OFF

# Flushing
innodb_flush_log_at_trx_commit = 1  # 1=ACID complet, 2=rapide mais risqué
innodb_flush_method = O_DIRECT      # Linux: évite double cache OS

# File per table
innodb_file_per_table = 1

# I/O
innodb_io_capacity = 200            # IOPS (HDD: 200, SSD: 2000+)
innodb_io_capacity_max = 2000
innodb_read_io_threads = 4
innodb_write_io_threads = 4

# Locking
innodb_lock_wait_timeout = 50       # Timeout verrou (secondes)

# ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
# QUERY CACHE (DÉPRÉCIÉ MySQL ≥8.0)
# ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
# query_cache_type = 0              # Désactivé par défaut ≥8.0
# query_cache_size = 0

# ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
# BINARY LOG (Réplication & PITR)
# ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
log-bin = /var/log/mysql/binlog
binlog_format = ROW                 # STATEMENT, ROW, MIXED
max_binlog_size = 1G
binlog_expire_logs_seconds = 604800 # 7 jours
sync_binlog = 1                     # Durabilité max (lent)

# GTID (recommandé pour réplication)
gtid_mode = ON
enforce_gtid_consistency = ON

# ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
# RÉPLICATION
# ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
server-id = 1                       # Unique par serveur
relay-log = /var/log/mysql/relay-log
relay_log_recovery = 1

# ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
# LOGS
# ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
log-error = /var/log/mysql/error.log

# Slow query log (requêtes lentes)
slow_query_log = 1
slow_query_log_file = /var/log/mysql/slow.log
long_query_time = 2                 # Logguer si > 2 secondes

# General log (TOUTES les requêtes - DEBUG UNIQUEMENT)
# general_log = 0
# general_log_file = /var/log/mysql/general.log

# ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
# SÉCURITÉ
# ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
# SSL/TLS
# require_secure_transport = ON
# ssl-ca = /etc/mysql/certs/ca.pem
# ssl-cert = /etc/mysql/certs/server-cert.pem
# ssl-key = /etc/mysql/certs/server-key.pem

# ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
# LIMITES
# ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
max_allowed_packet = 64M            # Taille max requête
max_heap_table_size = 64M
tmp_table_size = 64M

# ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
# PERFORMANCE SCHEMA (Monitoring)
# ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
performance_schema = ON
performance-schema-instrument = 'stage/%=ON'
performance-schema-consumer-events-stages-current = ON

[mysqldump]
quick
quote-names
max_allowed_packet = 64M

[mysql_safe]
log-error = /var/log/mysql/error.log
pid-file = /var/run/mysqld/mysqld.pid


10. FICHIER DE LOG : /var/log/mysql/error.log
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

CONTENU TYPIQUE :

2024-12-08T10:30:00.123456Z 0 [System] [MY-010116] [Server] /usr/sbin/mysqld (mysqld 8.0.35) starting as process 12345
2024-12-08T10:30:00.456789Z 1 [System] [MY-013576] [InnoDB] InnoDB initialization has started.
2024-12-08T10:30:01.234567Z 1 [System] [MY-013577] [InnoDB] InnoDB initialization has ended.
2024-12-08T10:30:01.567890Z 0 [Warning] [MY-010068] [Server] CA certificate ca.pem is self signed.
2024-12-08T10:30:01.890123Z 0 [System] [MY-010931] [Server] /usr/sbin/mysqld: ready for connections. Version: '8.0.35'  socket: '/var/lib/mysql/mysql.sock'  port: 3306

2024-12-08T11:45:23.456789Z 123 [Note] [MY-010914] [Server] Aborted connection 123 to db: 'myapp' user: 'appuser' host: '192.168.1.100' (Got an error reading communication packets)

FORMAT :
-> Timestamp ISO 8601
-> Thread ID
-> Niveau : System, Note, Warning, Error
-> Code erreur : MY-XXXXX
-> Subsystème : Server, InnoDB, Repl, etc.
-> Message

ROTATION DES LOGS :
# Avec logrotate
/var/log/mysql/*.log {
    daily
    rotate 14
    missingok
    create 640 mysql mysql
    compress
    sharedscripts
    postrotate
        test -x /usr/bin/mysqladmin && \
        /usr/bin/mysqladmin --defaults-file=/etc/mysql/my.cnf \
        flush-logs
    endscript
}


COMPARAISON AVEC PostgreSQL :
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
┌──────────────────────┬─────────────────────┬─────────────────────┐
│     Composant        │     PostgreSQL      │       MySQL         │
├──────────────────────┼─────────────────────┼─────────────────────┤
│ Données tables       │ base/OID/           │ database/*.ibd      │
│ Données système      │ base/OID/           │ ibdata1, mysql.ibd  │
│ WAL/Redo Log         │ pg_wal/             │ #innodb_redo/       │
│ Undo Log             │ Dans tables         │ undo_001, undo_002  │
│ Réplication log      │ pg_wal/ (même)      │ binlog.000001       │
│ Configuration        │ postgresql.conf     │ my.cnf              │
│ Logs erreurs         │ pg_log/             │ error.log           │
│ Socket               │ .s.PGSQL.5432       │ mysql.sock          │
│ PID                  │ postmaster.pid      │ mysqld.pid          │
│ Catalogue système    │ pg_catalog          │ information_schema  │
│ Moteur stockage      │ Heap/TOAST          │ InnoDB/MyISAM       │
│ Doublewrite          │ Non (WAL suffit)    │ Oui (dblwr)         │
└──────────────────────┴─────────────────────┴─────────────────────┘
"""


# [OK] PARTIE 4 : ARCHITECTURE INTERNE DE MySQL

"""
┌────────────────────────────────────────────────────────────────────────┐
│                   ARCHITECTURE MySQL - VUE D'ENSEMBLE                  │
└────────────────────────────────────────────────────────────────────────┘

ARCHITECTURE EN COUCHES :
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

┌─────────────────────────────────────────────────────────────────────┐
│                       SERVEUR MySQL (mysqld)                        │
│                                                                     │
│  ┌────────────────────────────────────────────────────────────────┐ │
│  │                   COUCHE CONNEXION                             │ │
│  │  - Authentification (caching_sha2_password)                    │ │
│  │  - Thread per connection                                       │ │
│  │  - Connection pooling                                          │ │
│  │  - SSL/TLS                                                     │ │
│  └────────────────────────────────────────────────────────────────┘ │
│                              v                                      │
│  ┌────────────────────────────────────────────────────────────────┐ │
│  │                   COUCHE SQL                                   │ │
│  │                                                                │ │
│  │  ┌──────────┐  ┌──────────┐  ┌───────────┐  ┌──────────┐    │ │
│  │  │  Parser  │-> │Optimizer │-> │ Executor  │-> │  Cache   │    │ │
│  │  │  (Lexer/ │  │  (Cost-  │  │ (Execute  │  │ (Query   │    │ │
│  │  │   Yacc)  │  │   Based) │  │   Plan)   │  │  Cache)  │    │ │
│  │  └──────────┘  └──────────┘  └───────────┘  └──────────┘    │ │
│  │                                                                │ │
│  │  ┌─────────────────────────────────────────────────────────┐ │ │
│  │  │  Privilege System (GRANT, REVOKE)                       │ │ │
│  │  └─────────────────────────────────────────────────────────┘ │ │
│  └────────────────────────────────────────────────────────────────┘ │
│                              v                                      │
│  ┌────────────────────────────────────────────────────────────────┐ │
│  │              COUCHE MOTEUR DE STOCKAGE (Pluggable)            │ │
│  │                                                                │ │
│  │  ┌──────────────────┐  ┌──────────────────┐  ┌────────────┐ │ │
│  │  │     InnoDB       │  │     MyISAM       │  │   MEMORY   │ │ │
│  │  │  (Transactionnel)│  │ (Non-trans.)     │  │  (Heap)    │ │ │
│  │  │  - ACID          │  │  - Rapide lecture│  │  - RAM     │ │ │
│  │  │  - Row locking   │  │  - Table locking │  │  - Temp    │ │ │
│  │  │  - MVCC          │  │  - Full-text     │  │            │ │ │
│  │  │  - Foreign keys  │  │  - Compression   │  │            │ │ │
│  │  └──────────────────┘  └──────────────────┘  └────────────┘ │ │
│  │                                                                │ │
│  │  ┌──────────────────┐  ┌──────────────────┐  ┌────────────┐ │ │
│  │  │     CSV          │  │     ARCHIVE      │  │   FEDERATED│ │ │
│  │  │  (Fichiers CSV)  │  │  (Compression)   │  │  (Remote)  │ │ │
│  │  └──────────────────┘  └──────────────────┘  └────────────┘ │ │
│  └────────────────────────────────────────────────────────────────┘ │
│                              v                                      │
│  ┌────────────────────────────────────────────────────────────────┐ │
│  │                   FICHIERS SUR DISQUE                          │ │
│  │  - Tables (.ibd)                                               │ │
│  │  - Index (dans .ibd)                                           │ │
│  │  - Redo Log (#innodb_redo/)                                   │ │
│  │  - Undo Log (undo_001, undo_002)                              │ │
│  │  - Binary Log (binlog.000001)                                 │ │
│  └────────────────────────────────────────────────────────────────┘ │
└─────────────────────────────────────────────────────────────────────┘


DÉTAIL DES COUCHES :
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

1. COUCHE CONNEXION (Connection Layer)
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

RÔLE :
-> Gérer les connexions clients
-> Authentification
-> Thread management
-> Gestion SSL/TLS

PROTOCOLE :
-> Protocole MySQL (propriétaire, binaire)
-> Port par défaut : 3306
-> Socket Unix pour connexions locales

CONNEXION TYPIQUE :
1. Client ouvre connexion TCP vers port 3306
2. Handshake MySQL (échange de versions, capabilities)
3. Authentification :
   - Ancienne méthode : mysql_native_password (hash SHA1)
   - Nouvelle (≥8.0) : caching_sha2_password (hash SHA2-256)
   - Support x.509 (certificats SSL)
   - Support LDAP, Kerberos (Enterprise)
4. Connexion établie

MODÈLE THREAD-PER-CONNECTION :
-> Chaque connexion = 1 thread dédié
-> Thread pool disponible (Enterprise/Percona)

EXEMPLE (mysql client) :
mysql -h localhost -u root -p
-> Connexion via socket Unix

mysql -h 192.168.1.100 -u appuser -p myapp
-> Connexion TCP/IP

VOIR LES CONNEXIONS :
SHOW PROCESSLIST;

+----+------+-----------+------+---------+------+-------+------------------+
| Id | User | Host      | db   | Command | Time | State | Info             |
+----+------+-----------+------+---------+------+-------+------------------+
|  5 | root | localhost | NULL | Query   |    0 | init  | show processlist |
| 10 | app  | 10.0.0.1  | mydb | Sleep   |  120 |       | NULL             |
+----+------+-----------+------+---------+------+-------+------------------+

TUER UNE CONNEXION :
KILL 10;


2. COUCHE SQL (SQL Layer)
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

C'est le CERVEAU de MySQL !

A) PARSER (Analyseur syntaxique)
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

RÔLE :
-> Analyser la requête SQL
-> Vérifier la syntaxe
-> Construire un arbre de syntaxe abstraite (AST)

ÉTAPES :
1. Lexical Analysis (Tokenisation)
   SELECT id, nom FROM users WHERE age > 18;
   ->
   [SELECT] [id] [,] [nom] [FROM] [users] [WHERE] [age] [>] [18] [;]

2. Syntax Analysis (Parsing)
   -> Vérifier que la grammaire SQL est respectée
   -> Construction de l'AST (Abstract Syntax Tree)

EXEMPLE AST (simplifié) :
SELECT
├── Columns
│   ├── id
│   └── nom
├── FROM
│   └── Table: users
└── WHERE
    └── Condition: age > 18

3. Vérification sémantique
   -> La table "users" existe-t-elle ?
   -> La colonne "age" existe-t-elle ?
   -> L'utilisateur a-t-il les droits SELECT sur cette table ?

EN CAS D'ERREUR :
ERROR 1064 (42000): You have an error in your SQL syntax; check the manual that corresponds to your MySQL server version for the right syntax to use near '...' at line 1


B) OPTIMIZER (Optimiseur de requêtes)
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

RÔLE CRUCIAL :
-> Transformer la requête en PLAN D'EXÉCUTION optimal
-> Choisir les index à utiliser
-> Ordre des jointures
-> Algorithme de jointure

TYPES D'OPTIMISATIONS :
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

1. Optimisation algébrique (rule-based)
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-> Simplification de l'AST
-> Constant folding : WHERE 1+1 = 2 -> WHERE TRUE
-> Predicate pushdown : descendre les WHERE avant les JOIN

2. Optimisation basée sur les coûts (cost-based)
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-> Estimer le coût de chaque plan possible
-> Choisir le plan avec le coût le plus faible

FACTEURS DE COÛT :
-> Nombre de lignes (cardinalité)
-> Sélectivité des index
-> Taille des tables
-> Coût I/O disque vs mémoire
-> Coût CPU

EXEMPLE :

Requête :
SELECT u.nom, c.montant
FROM users u
JOIN commandes c ON u.id = c.user_id
WHERE u.age > 25 AND c.status = 'completed';

PLANS POSSIBLES :

PLAN A : Table scan users + Table scan commandes + Join
-> Coût : 1000 (lecture 10k lignes users) + 5000 (50k commandes) + 500M (join)
-> Total : Très élevé [X]

PLAN B : Index scan users(age) + Index scan commandes(status) + Join
-> Coût : 100 (lecture 1k lignes via index) + 500 (5k commandes) + 5M (join)
-> Total : Moyen

PLAN C : Index scan users(age) + Nested loop join avec index commandes(user_id)
-> Coût : 100 + 1000 × log(50000) ≈ 16000
-> Total : Optimal [OK]

L'optimiseur choisit PLAN C !

STATISTIQUES :
-> MySQL collecte des statistiques sur les tables (ANALYZE TABLE)
-> Nombre de lignes, distribution des valeurs, cardinalité des index
-> Utilisé pour estimer les coûts

VOIR LE PLAN :
EXPLAIN SELECT u.nom, c.montant
FROM users u
JOIN commandes c ON u.id = c.user_id
WHERE u.age > 25;

+----+-------------+-------+------+---------------+------+---------+------+------+-----------------------------+
| id | select_type | table | type | possible_keys | key  | key_len | ref  | rows | Extra                       |
+----+-------------+-------+------+---------------+------+---------+------+------+-----------------------------+
|  1 | SIMPLE      | u     | ref  | age_idx       | age  | 4       | NULL | 1000 | Using where; Using index    |
|  1 | SIMPLE      | c     | ref  | user_id_idx   | user | 4       | u.id | 5    | Using where                 |
+----+-------------+-------+------+---------------+------+---------+------+------+-----------------------------+

COLONNES IMPORTANTES :
-> type : ALL(scan complet), index, range, ref, eq_ref, const
-> possible_keys : Index candidats
-> key : Index réellement utilisé
-> rows : Estimation nombre de lignes examinées
-> Extra : Infos additionnelles (Using temporary, Using filesort, etc.)


C) EXECUTOR (Exécuteur)
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

RÔLE :
-> Exécuter le plan d'exécution
-> Appeler le moteur de stockage (InnoDB, MyISAM, etc.)
-> Gérer les verrous
-> Retourner les résultats au client

ÉTAPES :
1. Ouvrir les tables (via moteur de stockage)
2. Acquérir les verrous nécessaires
3. Lire les données (via API du moteur)
4. Appliquer les filtres WHERE
5. Effectuer les jointures
6. Trier si ORDER BY
7. Limiter si LIMIT
8. Retourner les résultats

ALGORITHMES DE JOINTURE :
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

1. Nested Loop Join
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
FOR each row in table1:
    FOR each row in table2:
        IF join_condition:
            return row

Coût : O(n × m)
-> Bon si table2 a un index sur join_column

2. Block Nested Loop Join (BNL)
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-> Charger table1 en mémoire (join buffer)
-> Scanner table2 une seule fois
-> Comparer en mémoire

3. Hash Join (MySQL ≥8.0.18)
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-> Construire une table de hachage de table1
-> Sonder table2 avec la table de hachage

Coût : O(n + m)
-> Très efficace pour grandes tables


D) QUERY CACHE (Cache de requêtes) - DÉPRÉCIÉ ≥8.0
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

ANCIEN FONCTIONNEMENT (≤5.7) :
-> Cache les résultats complets des SELECT
-> Invalidé à chaque UPDATE/INSERT/DELETE sur les tables concernées

POURQUOI DÉPRÉCIÉ ?
[X] Verrou global (contention)
[X] Invalidation trop fréquente (inutile pour écritures fréquentes)
[X] Alternative : cache applicatif (Redis, Memcached)

DÉSACTIVÉ PAR DÉFAUT depuis MySQL 8.0 !


E) PRIVILEGE SYSTEM (Système de privilèges)
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

RÔLE :
-> Vérifier les droits de l'utilisateur
-> À chaque opération (SELECT, INSERT, UPDATE, DELETE, etc.)

NIVEAUX DE PRIVILÈGES :
1. GLOBAL : Sur tout le serveur
2. DATABASE : Sur une base spécifique
3. TABLE : Sur une table spécifique
4. COLUMN : Sur une colonne spécifique
5. ROUTINE : Sur une procédure/fonction stockée

STOCKAGE :
-> Table mysql.user (privilèges globaux)
-> Table mysql.db (privilèges base)
-> Table mysql.tables_priv (privilèges table)
-> Table mysql.columns_priv (privilèges colonne)

EXEMPLE :
GRANT SELECT, INSERT ON myapp.users TO 'appuser'@'localhost';


3. COUCHE MOTEUR DE STOCKAGE (Storage Engine Layer)
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

ARCHITECTURE PLUGGABLE :
-> MySQL sépare la couche SQL de la couche stockage
-> Permet de changer de moteur sans modifier le code SQL

API UNIFORME :
-> Open table, Close table
-> Read row, Write row
-> Start transaction, Commit, Rollback
-> Create index, Drop index

VOIR LES MOTEURS DISPONIBLES :
SHOW ENGINES;

+--------------------+---------+----------------------------------------------------------------+--------------+------+------------+
| Engine             | Support | Comment                                                        | Transactions | XA   | Savepoints |
+--------------------+---------+----------------------------------------------------------------+--------------+------+------------+
| InnoDB             | DEFAULT | Supports transactions, row-level locking, and foreign keys     | YES          | YES  | YES        |
| MyISAM             | YES     | MyISAM storage engine                                          | NO           | NO   | NO         |
| MEMORY             | YES     | Hash based, stored in memory, useful for temporary tables      | NO           | NO   | NO         |
| CSV                | YES     | CSV storage engine                                             | NO           | NO   | NO         |
| ARCHIVE            | YES     | Archive storage engine                                         | NO           | NO   | NO         |
| BLACKHOLE          | YES     | /dev/null storage engine (anything you write disappears)       | NO           | NO   | NO         |
| FEDERATED          | NO      | Federated MySQL storage engine                                 | NULL         | NULL | NULL       |
| PERFORMANCE_SCHEMA | YES     | Performance Schema                                             | NO           | NO   | NO         |
+--------------------+---------+----------------------------------------------------------------+--------------+------+------------+


COMPARAISON InnoDB vs MyISAM :
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
┌─────────────────────┬──────────────────────┬─────────────────────┐
│  Caractéristique    │       InnoDB         │      MyISAM         │
├─────────────────────┼──────────────────────┼─────────────────────┤
│ Transactions ACID   │ OUI [OK]               │ NON [X]              │
│ Verrous             │ Row-level (ligne)    │ Table-level (table) │
│ Clés étrangères     │ OUI [OK]               │ NON [X]              │
│ Crash recovery      │ OUI [OK]               │ NON [X]              │
│ MVCC                │ OUI [OK]               │ NON [X]              │
│ Full-text search    │ OUI (≥5.6)           │ OUI                 │
│ Compression         │ OUI (InnoDB)         │ OUI (MyISAM)        │
│ Geospatial          │ OUI                  │ OUI                 │
│ Performance lecture │ Très bon             │ Excellent           │
│ Performance écriture│ Très bon             │ Moyen (table lock)  │
│ Utilisation mémoire │ Plus (buffer pool)   │ Moins               │
│ Cas d'usage         │ Défaut (tout)        │ Logs, archives      │
│ Statut              │ Défaut depuis 5.5    │ Legacy (éviter)     │
└─────────────────────┴──────────────────────┴─────────────────────┘

RECOMMANDATION : TOUJOURS UTILISER InnoDB !
"""


# Continuer dans la prochaine partie...

# PARTIE 5 à 16 suivront avec le même niveau de détail...
# Faut-il que je continue tout de suite ou veux-tu voir cette première partie ?