Language SQL
Introduction
Le traitement automatisé des données pose le problème du stockage de celles-ci. La solution, le stockage dans des fichiers appelés "Base de Données". Pour se
faire, il existe principalement trois type de bases de données :
- Bases de données simple (Fichiers texte)
- Bases de données relationnelles (dont MySQL)
- Bases de données relationnelles orientées objet (ORACLE, PostGRESQL)
Seul SQL (Structured Query Language) permet, en tant que langage standard, de communiquer avec les bases de données. Mais chaque base de données implémente ce langage avec des spécificités.
Conservation des données de manière simple, sans base de données relationnelle, en utilisant des fichiers texte et PHP.
Base de Données Simple
La base de données simple consiste en un stockage dans un fichier texte. Ce type de stockage ne nécessite aucune gestion spéciale (comme un serveur de base de données) mais reste beaucoup moins souple en ce qui concerne le traitement des informations qu'il renferme.
Exemple : Commentaires d'Internautes
Pour mettre en place un système de commentaires d'internautes, vous aurez besoin des éléments suivants :
- Une page avec un formulaire de saisie (comment.php).
- Un script d'enregistrement (ajout.php).
- Un script de lecture (lecture.php).
- Un fichier texte pour le stockage (comment.txt).
- Structure des Fichiers
comment.php (Page d'accueil) :
- Contient le formulaire de saisie des commentaires.
- Appelle le fichier ajout.php pour enregistrer les commentaires.
- Inclut le fichier lecture.php pour afficher les commentaires existants.
<input name="nom" type="text" size="30" placeholder="Nom">
<input name="prenom" type="text" size="30" placeholder="Prénom">
<input name="courriel" type="text" size="30" placeholder="Courriel">
<textarea rows="10" cols="40" name="textemessage" placeholder="Votre message"></textarea>
<input type="submit" value="Envoyer">
</form>
<?php include 'lecture.php'; ?>
ajout.php (Script d'enregistrement) :
- Récupère les données du formulaire.
- Lit les anciens commentaires et ajoute le nouveau commentaire.
- Écrit les informations dans le fichier texte.
$date = date("d/m/Y");
$nomfichier = "comment.txt";
$nom = $_POST['nom'];
$prenom = $_POST['prenom'];
$courriel = $_POST['courriel'];
$textemessage = $_POST['textemessage'];
// Lecture des anciens commentaires
$fichier = fopen($nomfichier, "r");
$anciensmessages = fread($fichier, filesize($nomfichier));
fclose($fichier);
// Écriture des nouveaux commentaires
$fichier = fopen($nomfichier, "w");
fwrite($fichier, "<table width='100%' border='0'>");
fwrite($fichier, "<tr><td>$nom $prenom</td></tr>");
fwrite($fichier, "<tr><td>$courriel</td></tr>");
fwrite($fichier, "<tr><td>$textemessage</td></tr>");
fwrite($fichier, "<tr><td>$date</td></tr>");
fwrite($fichier, "</table><hr>");
fwrite($fichier, $anciensmessages);
fclose($fichier);
// Redirection vers la page d'accueil
header("Location: comment.php");
exit();
?>
lecture.php (Script de lecture) :
- Lit et affiche les commentaires stockés dans le fichier texte.
$nomfichier = "comment.txt";
$fichier = fopen($nomfichier, "r");
if (!$fichier) {
print("Le fichier n'existe pas !");
exit();
}
while (!feof($fichier)) {
$ligne = fgets($fichier, 1024);
print($ligne);
}
fclose($fichier);
?>
Fonctions PHP Utilisées
- fopen() : Ouvre un fichier.
- fread() : Lit le contenu d'un fichier.
- fwrite() : Écrit dans un fichier.
- fclose() : Ferme un fichier.
Explications
Récupération des Données :
- Les données du formulaire sont récupérées via la méthode POST.
- Les anciens commentaires sont lus à partir du fichier texte.
Écriture des Données :
- Les nouveaux commentaires sont ajoutés au début du fichier texte.
- Les anciens commentaires sont ajoutés après les nouveaux commentaires.
Affichage des Données :
- Les commentaires sont lus et affichés dans la page d'accueil.
Conclusion
Cette méthode de stockage simple est idéale pour des projets de petite envergure où la gestion des données n'est pas complexe. Cependant, pour des projets plus importants, l'utilisation d'une base de données relationnelle est recommandée pour une meilleure gestion et sécurité des données.
Base de données relationnelle
L'utilisation de PDO (PHP Data Objects) est recommandée pour interagir avec les bases de données en PHP, car elle offre une couche d'abstraction qui permet de travailler avec différents systèmes de gestion de bases de données (SGBD) de manière uniforme. PDO améliore également la sécurité en facilitant l'utilisation de requêtes préparées, ce qui aide à prévenir les injections SQL.
Introduction aux Bases de Données Relationnelles
Une base de données relationnelle organise les données en tables, où chaque table est une collection de champs (ou colonnes) et chaque champ contient des enregistrements (ou lignes). Les relations entre les tables sont établies à l'aide de clés, qui sont des identifiants uniques permettant de relier les enregistrements entre eux.
Exemple d'informations :
- Nom
- Prénom
- Adresse
- Téléphone
Nom et Prénom ne seront que rarement modifiés, tandis que Adresse et Téléphone peuvent l'être très souvent.
La base de données permet de modifier et surtout de consulter toutes les informations de manière associée ou dissociée, grâce à des critères de sélection et au langage SQL. Cela représente, en termes de programmation, un grand gain de temps.
Structure d'une Base de Données Relationnelle
- Base de données : Contient une ou un ensemble de tables.
- Table : Collection de champs.
- Champs : Collection des données proprement dites (enregistrements de même nature).
- Enregistrement : Les informations stockées, reliées entre elles souvent par une clé.
- Clé : Information unique permettant de relier un ensemble d'enregistrements.
Utilisation de PDO en PHP
PDO (PHP Data Objects) est une extension qui définit une interface pour accéder aux bases de données en PHP. PDO offre les avantages suivants :
- Sécurité : Utilisation de requêtes préparées pour prévenir les injections SQL.
- Portabilité : Compatibilité avec différents SGBD (MySQL, PostgreSQL, SQLite, etc.).
- Performance : Gestion efficace des connexions et des transactions.
Exemple de Connexion et d'Utilisation de PDO
Connexion à la Base de Données :
try {
// Connexion au serveur de base de données
$pdo = new PDO("mysql:host=nom-serveur;dbname=nom-base", "nom-utilisateur", "mot-de-passe");
// Définir le mode d'erreur de PDO sur Exception
$pdo->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
echo "Connexion réussie !";
} catch (PDOException $e) {
die("Connexion échouée : " . $e->getMessage());
}
?>
Requête Préparée pour Sélectionner des Données :
try {
// Préparer la requête SQL
$stmt = $pdo->prepare("SELECT * FROM utilisateurs WHERE id = :id");
// Lier les paramètres
$stmt->bindParam(':id', $id);
// Exécuter la requête
$stmt->execute();
// Récupérer les résultats
$resultats = $stmt->fetchAll(PDO::FETCH_ASSOC);
foreach ($resultats as $row) {
echo "Nom : " . $row['nom'] . " Prénom : " . $row['prenom'] . "<br>";
}
} catch (PDOException $e) {
die("Erreur lors de la requête : " . $e->getMessage());
}
?>
Insertion de Données :
try {
// Préparer la requête SQL
$stmt = $pdo->prepare("INSERT INTO utilisateurs (nom, prenom, adresse, telephone) VALUES (:nom, :prenom, :adresse, :telephone)");
// Lier les paramètres
$stmt->bindParam(':nom', $nom);
$stmt->bindParam(':prenom', $prenom);
$stmt->bindParam(':adresse', $adresse);
$stmt->bindParam(':telephone', $telephone);
// Exécuter la requête
$stmt->execute();
echo "Nouvel utilisateur ajouté avec succès !";
} catch (PDOException $e) {
die("Erreur lors de l'insertion : " . $e->getMessage());
}
?>
Fermeture de la Connexion :
// Fermeture de la connexion
$pdo = null;
?>
Conclusion
L'utilisation de PDO en PHP pour interagir avec les bases de données offre une méthode sécurisée, portable et performante. En suivant ces exemples, vous pouvez facilement vous connecter à une base de données, exécuter des requêtes préparées pour sélectionner et insérer des données, et gérer les erreurs de manière efficace.
Éléments du langage
Nom | Définition | Options |
---|---|---|
CREATE | Création d'une base de données | nom_de_la_base |
CREATE TABLE | Création de table dans une base de données | nom_de_la_table (nom_champs1 type_données options, nom_champs2 type_données options, ...) |
ALTER TABLE | Opérations sur une table | Permet d'apporter des modifications à la structure d'une table (voir plus bas) |
INSERT INTO | Insérer des données | nom_de_la_table (nom_champs1 type_données options, nom_champs2 type_données options, ...) VALUES (valeur1, valeur2, ...) |
SELECT | Sélectionner des champs dans une table avant toute opération | nom_champs1, nomchamps2 ... FROM nom_table |
UPDATE | Modifier des données existantes | nom_table SET nom_champs1=valeur1, nom_champs2=valeur2, ... WHERE numero LIKE 'valeur' |
DELETE | Supprimer des données existantes | FROM nom_table WHERE nom_champs LIKE 'valeur' |
La clause WHERE permet d'affiner la sélection, afin d'éviter une opération non désirée.
Opérations avec ALTER TABLE
Nom | Description |
---|---|
ADD nom_champs | Ajoute un nouveau champs à une table |
CHANGE nom_champs nouv_champs | Change le nom d'un champs |
DROP nom_champs | Supprime le champs spécifié |
MODIFY nom_champs | Change le nom d'un champs (MySQL 3.22.16) |
RENAME nouv_nom | Renomme la table en nouv_nom |
DROP primary key | Supprime la clé primaire de la table |
Types de données
Données numériques
Nom | Stockage | Description |
---|---|---|
tinyint | 1 bit | Stockage de nombres entre -128 et 127 (0 et 255 si unsigned) |
smallint | 2 bits | Stockage de nombres entre -215 et 215-1 (0 et 216-1 si unsigned) |
mediumint | 3 bits | Stockage de nombres entre -223 et 223-1 (0 et 224-1 si unsigned) |
int | 4 bits | Stockage de nombres entre -231 et 231-1 (0 et 232-1 si unsigned) |
bigint | 8 bits | Stockage de nombres entre -263 et 263-1 (0 et 264-1 si unsigned) |
float | 4 bits | Stockage de nombres entre 1,178494351. 10-38 et 3,402823466. 1038 |
double | 8 bits | Stockage de nombres entre 2,225073858. 10-308 et 1,7976931348. 10308 |
decimal | M bits | Stockage de nombres sous la forme de chaîne de caractères |
Données type chaîne de caractères
Nom | Stockage |
---|---|
char | De 0 à M bits |
varchar | De 0 à M bits |
tinyblob | De 0 à 255 bits |
blob | De 0 à 65 535 bits |
mediumblob | De 0 à 224 -1bit |
longblob | De 0 à 232 -1bit |
tinytext | De 0 à 287 -1bit |
text | De 0 à 216 -1bit |
mediumtext | De 0 à 224 -1bit |
longtext | De 0 à 232 -1bit |
Données type Temps et Date
Nom | Stockage | Description |
---|---|---|
date | 3 bits | Format "AAAA-MM-JJ" |
time | 3 bits | Format "HH:MM:SS" |
datetime | 8 bits | Format "AAAA-MM-JJ HH:MM:SS" |
timestamp | 4 bits | Format "AAAAMMJJHHMMSS" |
year | 1 bits | Format "AAAA" (de 1900 à 2155) |
Caractéristiques
MySQL est un serveur de bases de données relationnelles SQL développé dans un souci de performances élevées en lecture, ce qui signifie qu'il est davantage orienté vers le service de données déjà en place que vers celui de mises à jour fréquentes et fortement sécurisées. Il est multi-thread et multi-utilisateur.
C'est un logiciel libre développé sous double licence en fonction de l'utilisation qui en est faite : dans un produit libre ou dans un produit propriétaire. Dans ce dernier cas, la licence est payante, sinon c'est la licence publique générale GNU (GPL) qui s'applique. Ce type de licence double est utilisé par d'autres produits comme le framework de développement de logiciels Qt (pour les versions antérieures à la 4.5).
Systèmes d'exploitation supportés
MySQL fonctionne sur de nombreux systèmes d'exploitation différents, incluant AIX, IBM i-5, BSDi, FreeBSD, HP-UX, Linux, Mac OS X, NetWare, NetBSD, OpenBSD, OS/2 Warp, SGI IRIX, Solaris, SunOS, SCO OpenServer, SCO UnixWare, Tru64 Unix, Windows (2000, XP, Vista et 7).
Les bases de données sont accessibles en utilisant les langages de programmation C, C++, VB, VB .NET, C#, Delphi/Kylix, Eiffel, Java, Perl, PHP, Python, Ruby et Tcl ; une API spécifique est disponible pour chacun d'entre eux. Une interface ODBC appelée MyODBC est aussi disponible. En Java, MySQL peut être utilisé de façon transparente avec le standard JDO.
MySQL AB étant la propriété de Sun Microsystems, est devenu officieusement la base de données à utiliser conjointement avec le langage de programmation Java, ce qui lui donne une notoriété supplémentaire auprès des entreprises utilisant Java.
Moteurs de base de données inclus
L'une des spécificités de MySQL est de pouvoir gérer plusieurs moteurs au sein d'une seule base. Chaque table peut utiliser un moteur différent au sein d'une base. Ceci afin d'optimiser l'utilisation de chaque table.
Les différents moteurs historiques de MySQL
- MyISAM : moteur par défaut de MySQL. Il est le plus simple à utiliser et à mettre en œuvre. Il utilise plusieurs fichiers qui grandissent au fur et à mesure que la base grossit. Il ne supporte pas les transactions, ni les clefs étrangères.
- InnoDB : moteur créé et maintenu par InnoBase (racheté par Oracle le 7 octobre 2005). Il gère les transactions et les clefs étrangères (et donc une gestion d'intégrité de table). En contrepartie, les bases qui l'utilisent occupent bien plus d'espace sur le disque.
- BerkeleyDB (BDB) : moteur fourni par Sleepycat Software qui gère les transactions.
- MERGE : moteur fait pour fusionner plusieurs tables qui doivent être identiques.
- ARCHIVE : moteur adapté à l'archivage de données. Les lignes sont compressées au fur et à mesure de leur insertion. Les requêtes de recherches sont alors sensiblement plus lentes.
- MEMORY (HEAP) : moteur où les tables sont stockées uniquement en mémoire. La structure de la base est stockée sur le disque dur mais les données sont stockées dans la RAM, si la machine serveur redémarre, les données seront perdues. Cependant, étant donné qu'il n'y a plus d'accès disque, une requête de modification (UPDATE, INSERT…) s'exécutera sensiblement plus rapidement.
- CSV : moteur utilisant des fichiers textes (au format CSV) comme stockage.
- BLACKHOLE : moteur réceptionnant les données, les transférant mais ne les stockant pas. Il peut être utilisé comme répéteur ou comme filtre de données.
- ISAM : moteur d'origine de MySQL, maintenant obsolète et remplacé par MyISAM. Il est resté pour des raisons de compatibilité.
- NDB (uniquement dans la version MaxDB) : moteur de base de données réseau gérant les grappes de serveurs.
- FEDERATED : moteur permettant d'accéder à des tables d'une base de données distantes plutôt que dans les fichiers locaux.
- EXEMPLE : moteur fictif et inutilisable, mis à disposition pour les développeurs.
- FALCON : ce nouveau moteur devrait faire son apparition avec MySQL 6. Depuis le rachat de InnoBase par Oracle, MySQL AB s'est vu obligé de créer un nouveau moteur transactionnel pour ne plus dépendre de son concurrent. Il devrait remplacer petit à petit InnoDB.
- MARIA : evolution ACID de MyISAM
Des moteurs de stockages OPEN Source
- Infobright : moteur VLDB, orienté vers les applications décisionnelles
- Sphinx : moteur orienté recherche full text
- PBXT : moteur transactionnel proche des performances d'InnoDB
- Memcached : moteur orienté table de hash en mémoire
- M4q : moteur orienté gestion de file d'attente
Des moteurs de stockages commerciaux
- DB2 Moteur transactionnel copyright IBM
- SolidDB Moteur transactionnel copyright IBM
- NitroEDB Moteur VLDB copyright BrightHouse
- Tokutek Moteur VLDB
La facilité d'utilisation de plusieurs moteurs de stockage dans une seule base avec MySQL permet une énorme flexibilité dans l'optimisation de la base : on utilisera MyISAM pour stocker les données peu sensibles et nécessitant un accès rapide aux données (par exemple une liste d'utilisateurs), InnoBD pour les fonctions avancées et les données plus sensibles (par exemple pour une liste des transactions bancaires), MEMORY pour des données pouvant être perdues lors du redémarrage de la machine et souvent modifiées (par exemple une liste d'utilisateurs en ligne), ARCHIVE pour un historique (ou log) ne nécessitant que peu de lecture…