Contexte : des milliers/millions de données à manipuler.
Problème : les manipuler "à la main" est...
  • chronophage : 35 jours pour un million de données (1 donnée/s et 8h/j).
  • source d'erreurs : données comptées en double, sautées, etc.
  • incomplet : données stockées à plusieurs endroits différents, certaines perdues.
Besoins : un logiciel permettant d'efficacement...
  • stocker et organiser les données.
  • manipuler les données : ajouter/modifier/supprimer des données.
  • requêter les données : e.g. compter le nombre de ventes.
Solution : les Systèmes de Gestion de Bases de Données (SGBD) :
  • créer, stocker, manipuler et requêter des bases de données.
  • cohérence des données : garantie l'absence de données invalides.
  • robustesse : résister aux pannes.
  • contrôle d'accès : qui peut faire quoi sur quelles données ?
  • logs : que s'est-il passé ? qui a fait quoi et quand ?
  • accès concurrent : modifications simultanées de données.
SQL (Structured Query Language) : langage pour manipuler des SGBD.
Exemples de SGBD SQL :
  • SQLite : léger (utilisé en TP)
    • 1 base de donnée = 1 fichier.
    • utilisation locale.
    • pas d'accès concurrents.
  • PostgreSQL, MySQL, et MariaDB : plus complets.
⚠ SQL est normalisé (ISO/CEI 9075) mais quelques différences entre SGBD.
Les SGBD (sauf SQLite) suivent une architecture client-serveur :
  • serveur : stocke les données et exécute les requêtes.
  • client : envoie les requêtes et réceptionne les résultats.
Plusieurs types de clients :
  • API utilisée dans le langage de programmation de votre choix.
  • application en ligne de commandes (e.g. psgl, mysql).
  • interface graphique de gestion de bases de données (e.g. pgAdmin).
  • interface graphique de requêtage (e.g. ???).
Une base de donnée est composée de tables SQL (tableau contenant les données) :
ID Nom Prenom Age
1 Doe John 32
2 Durand John 64
  • lignes : les entrées (ou enregistrements) ;
  • colonnes : les propriétés des entrées.

💡 base de données ≈ fichier tableur ; tables ≈ feuilles de calculs.

💡 Les tables sont aussi appelées relations, d'où les bases de données relationnelles.
Schéma de table : décrit la structure de la table, e.g. le type des colonnes :
  • : une chaîne de caractère (e.g. / ).
  • / : un nombre entier.
  • : un nombre décimal.
  • : des données binaires.
  • : accepte n'importe quelle valeur.

💡 Par défaut, chaque type accepte la valeur (= absence de données).

💡 D'autres types disponibles en fonction du SGBD utilisé.
💡 Vous trouver plus amples documentations via les liens suivants :
Plusieurs types de commandes SQL pour différent types d'actions :
  • : lire des données ;
  • : modifier des entrées ;
  • : insérer des entrées ;
  • : supprimer des entrées.
💡 Nous allons nous concentrer sur et verrons les autres par la suite.
  • : nom de la table SQL à requêter.
  • : liste des colonnes à récupérer (séparées par ",").
    💡 correspond à l'ensemble des colonnes.
⚠ Le nom de la colonne entre guillemets si caractères non-alphanumériques.
⚠ Ne récupérer que les colonnes nécessaires (réduire les données transférées).
💡 : donner (temporairement) un alias à une colonne :
  • trier les lignes.
    • Par ordre croissant () ou décroissant () ;
    • Pour trier sur plusieurs colonnes, les séparer par une virgule.
Problème : retourne toutes les entrées.
  • des milliers/millions d'entrées (pas forcément toutes pertinentes).
  • consommation excessive de ressources Internet, processeur, RAM, disque, etc.
Solution : réduire la quantité d'entrées retournées.
  • Filtrer ;
  • Supprimer les doublons ;
  • Limiter le nombre de lignes.
: les entrées où est vrai sont retournées.
  • Opérateurs de comparaison : , , , , , ;
  • Opérateurs logiques : , , ;
  • ⚠ Ne JAMAIS chaîner les opérateurs de comparaisons.
    • soit ;
    • soit .
  • 💡 Vous pouvez aussi utiliser des parenthèses.
  • : la valeur est [n'est pas] dans la liste .
  • : la valeur [n'est pas] est pas entre et (inclus).
    💡 Équivalant à .
    ⚠ Comportement peut varier selon SGBD, e.g. et non-inclus.
  • : la valeur [ne] correspond [pas] à .
    • n'importe quel caractère.
    • nombre indéterminé de .
  • : la valeur [n'est pas] est nulle nulle.
    ⚠ En SQL est généralement évalué à .
  • : supprime les doublons.
  • : récupère les premières entrées.
    • 💡 Avec la clause génère des tops.
Problème :
  • Récupérer et afficher des milliers de lignes => coûteux.
Solution :
  • Découper la liste en plusieurs pages (e.g. lignes/page).
    • : entrées par requêtes.
    • : récupérer à partir de la -ième entrée (avec , la page).
  1. Indentez vos requêtes (e.g. aligner les clauses), + lisible + facile à modifier.
  2. Fermez immédiatement parenthèses/guillemets/etc. avant de les remplir.
  3. Évitez autant que possible d'écrire à la main :
    1. Utilisez l'auto-complétion (touche de tabulation ).
    2. Utilisez (/) pour remonter l'historique et (/) pour modifier une requête.
    3. Utilisez les copier/coller (/).
  4. Ne jamais tout écrire d'un coup, mais procédez par étapes :
    1. basique.
    2. afficher les colonnes pertinentes.
    3. ajoutez et testez les clauses une par une.
    4. idem pour les expressions, ajoutez les opérations au fur et à mesure.
Avantages :
  • écriture + simple, rigoureux et méthodique.
  • 1 problème complexe => petits problèmes simples.
  • debug + simple : origine problème tout de suite connu.
  1. Récupère la table ().
  2. Alias de colonnes.
  3. Filtre les entrées ().
  4. Groupe les entrées ().
  5. Alias de colonnes d'agrégats.
  6. Filtre les lignes agrégées ().
  7. Supprime les doublons ().
  8. Trie les lignes ().
  9. Limite les lignes (/).
SELECT DISTINCT Date, Ref, Q as N
          FROM Produits
          WHERE Ref = "Gomme"
          ORDER BY Q
          LIMIT 2;