Cette requête donne la taille (en Mo) occupée par les tables d'une base de données, de la plus à la moins volumineuse.
Cette requête ne fonctionne qu'avec une version de MySQL possédant un catalogue (version 5.0.2 ou postérieure).
CREATE TABLE `ma_base`.`ELEMENT` (
`id_element` INTEGER UNSIGNED NOT NULL AUTO_INCREMENT,
`nom_element` VARCHAR(45) NOT NULL,
`id_categorie` INTEGER UNSIGNED NOT NULL,
PRIMARY KEY (`id_element`),
CONSTRAINT `FK_ELT_CAT` FOREIGN KEY `FK_ELT_CAT` (`id_categorie`)
REFERENCES `categorie` (`id_categorie`)
ON DELETE CASCADE
ON UPDATE CASCADE
)
ENGINE = InnoDB;
Le but de la requête est de ramener les n premiers éléments de chaque catégorie par ordre d'identifiant. Pour cela, on fait ce qu'on appelle une division relationnelle, comme suit :
SELECT
e.id_element, e.nom_element, c.id_categorie, c.nom_categorie
FROM
ELEMENT e
INNER JOIN
CATEGORIE c ON e.id_categorie = c.id_categorie
WHERE (
SELECT COUNT(*)
FROM ELEMENT e1
WHERE e1.id_categorie = e.id_categorie
AND e1.id_element < e.id_element
) < n
Il suffit de remplacer n par la valeur souhaitée.
Pour obtenir les n derniers éléments de chaque catégorie, il suffit d'inverser le sens de l'inégalité dans la sous-requête :
SELECT
e.id_element, e.nom_element, c.id_categorie, c.nom_categorie
FROM
ELEMENT e
INNER JOIN
CATEGORIE c ON e.id_categorie = c.id_categorie
WHERE (
SELECT COUNT(*)
FROM ELEMENT e1
WHERE e1.id_categorie = e.id_categorie
AND e1.id_element > e.id_element
) < n
Attention, cette requête ne fonctionne qu'avec une version de MySQL supportant les sous-requêtes (version 4.1 ou postérieure).
Cette fonction prend en paramètre deux valeurs de type DATE et retourne le nombre de jours entre ces deux valeurs.
Il est possible de passer des valeurs de type TIMESTAMP et l'ordre n'est pas important.
Exemple d'utilisation
SELECT days_between('2008-9-06', '2008-11-08');
Nous obtenons en sortie
63
Un peu d'explications
Ici nous voulons calculer le nombre de jours entre le 6 septembre 2008 et le 8 novembre 2008.
Nombre de jours en septembre = 30.
Nombre de jours en octobre = 31.
Nous obtenons donc (30 - 6) + 31 + 8 soit 63 jours.
Cette fonction prend en paramètre deux valeurs de type DATE et retourne le nombre de mois entre ces deux valeurs.
Il est possible de passer des valeurs de type TIMESTAMP et l'ordre n'est pas important.
L'écriture de cette fonction a été fortement inspirée par celle de Nathan Bunker.
Exemple d'utilisation
SELECT months_between('2008-11-08', '2009-2-06');
Nous obtenons en sortie
2
Un peu d'explications
Ici nous voulons calculer le nombre de mois entre le 8 novembre 2008 et le 6 septembre 2009.
Liste des mois complets = decembre 2008, janvier 2008.
Ensuite entre le 8 et le 6 de deux mois il n'y a pas un mois complet (à deux jours près).
Nous obtenons donc 2 mois.
Un index est efficace si il est placé sur une colonne possédant peu de doublons (NULLs compris). En effet le SGBD indexe les valeurs, ce qui implique que la présence de doublons réduit le nombre d'index.
Autrement dit, un index est performant si la différence entre le nombre de tuples total et le nombre de valeurs distinctes tend vers 0.
Nous chercherons donc à calculer le ratio du nombre de valeurs distinctes sur le nombre total de tuples, plus ce ratio est proche de 1, et plus l'index est performant.
Cette requête ne fonctionne qu'avec une version de MySQL possédant un catalogue (version 5.0.2 ou postérieure).
Le but de cette fonction est de convertir tous les caractères accentués vers leurs équivalents (non accentués) et de remplacer les espaces par des tirets.
SELECT translate('Une très bonne initiative et à bientôt', 'ÁÀÂÄÃÅÇÉÈÊËÍÏÎÌÑÓÒÔÖÕÚÙÛÜÝáàâäãåçéèêëíìîïñóòôöõúùûüýÿ', 'AAAAAACEEEEIIIINOOOOOUUUUYaaaaaaceeeeiiiinooooouuuuyy');
Nous obtenons en sortie
+------------------------------------------------------------+
| translate('Une très bonne initiative et à bientôt', ...... |
-------------------------------------------------------------+
| Une tres bonne initiative et a bientot |
+------------------------------------------------------------+
Rappel des règles de comptages
I = 1
V = 5
X = 10
L = 50
C = 100
D = 500
M = 1000
Lorsque les symboles sont semblables on les additionne : CC = 200
Lorsque le symbole de gauche est plus petit que celui de droite on effectue une soustraction : IX = 9
Il n'est pas autorisé d'avoir plus de trois symboles semblables à la suite : IIII n'existe pas.
Compte tenu de ces règles, on ne peut compter seulement que jusqu'à MMMCMXCIX soit 3999.
Cette fonction reçoit en paramètre un chiffre arabe et retourne le chiffre romain correspondant. Si le paramètre n'est pas encodable (non compris entre 0 et 4000) elle retourne le marqueur NULL.
Cette fonction prend en paramètre deux valeurs de type TIMESTAMP et retourne le nombre de secondes entre ces deux valeurs.
Il est possible de passer des valeurs de type DATE et l'ordre n'est pas important.
Exemple d'utilisation
SELECT seconds_between('2008-11-06 02:10:13', '2008-11-07 02:11:15');
Nous obtenons en sortie
86462
Un peu d'explications
Ici nous avons un écart d'un jour, une minute et deux secondes.
Un jour = 60 secondes * 60 minutes * 24 heures soit 86400 secondes.
Une minute = 60 secondes.
Nous obtenons donc 86400 + 60 + 2 soit 86462 secondes.
Cette fonction prend en paramètre deux valeurs de type TIMESTAMP et retourne le nombre de minutes entre ces deux valeurs.
Il est possible de passer des valeurs de type DATE et l'ordre n'est pas important.
Attention, cette fonction réutilise la fonction seconds_between, il est donc nécessaire d'avoir créé cette dernière, sans quoi une erreur sera retournée. Si vous préférez créer seulement minutes_between, une version équivalente est disponible.
Exemple d'utilisation
SELECT minutes_between('2008-11-06 02:10:13', '2008-11-07 02:11:15');
Nous obtenons en sortie
1441
Un peu d'explications
Ici nous avons un écart d'un jour, une minute et deux secondes.
Un jour = 60 minutes * 24 heures soit 1440 minutes.
Nous obtenons donc 1440 + 1 soit 1441 minutes.
Cette fonction prend en paramètre deux valeurs de type TIMESTAMP et retourne le nombre d'heures entre ces deux valeurs.
Il est possible de passer des valeurs de type DATE et l'ordre n'est pas important.
Attention, cette fonction réutilise la fonction minutes_between, il est donc nécessaire d'avoir créé cette dernière sans quoi une erreur sera retournée. Si vous préférez créer seulement hours_between, une version équivalente est disponible.
Exemple d'utilisation
SELECT hours_between('2008-11-06 02:10:13', '2008-11-08 05:11:15');
Nous obtenons en sortie
51
Un peu d'explications
Ici nous avons un écart de deux jours, trois heures, une minute et deux secondes.
Deux jours = 24 heures * 2 jours soit 48 heures.
Nous obtenons donc 48 + 3 soit 51 heures.
Cette fonction prend en paramètre deux valeurs de type DATE et retourne le nombre d'années entre ces deux valeurs.
Il est possible de passer des valeurs de type TIMESTAMP et l'ordre n'est pas important.
Attention, cette fonction réutilise la fonction months_between, il est donc nécessaire d'avoir créé cette dernière, faute de quoi une erreur sera retournée. Si vous préférez créer seulement years_between, une version équivalente est disponible.
Exemple d'utilisation
SELECT years_between('2008-9-06', '2012-11-08');
MySQL n'a pas de fonction pour agréger par produit. Toutefois, il est possible de le faire avec les fonctions EXP et LN.
Si, par exemple, vous avez la table suivante
CREATE TABLE Exemple (
forme varchar(20),
dimension varchar(10),
facteur float NOT NULL
) ;
Et le jeu de données suivant
INSERT INTO Exemple VALUES('parallélépipède', 'largeur', 10);
INSERT INTO Exemple VALUES('parallélépipède', 'longueur', 30);
INSERT INTO Exemple VALUES('parallélépipède', 'hauteur', 15);
INSERT INTO Exemple VALUES('pyramide', 'base', 20);
INSERT INTO Exemple VALUES('pyramide', 'hauteur', 30);
INSERT INTO Exemple VALUES('pyramide', 'constante', 1/3);
On veut calculer le volume de chaque forme, et donc faire quelque chose comme :
-- erreur de syntaxe
SELECT forme, Produit(facteur) AS Volume
FROM Exemple
GROUP BY forme
Cette requête n'est pas valide parce que la fonction Produit() n'existe pas.
on la remplacera donc par l'exponentiel d'une somme de logarithmes :
SELECT forme, EXP(SUM(LN(facteur))) AS Volume
FROM Exemple
GROUP BY forme
