FAQ MySQLConsultez toutes les FAQ

Avec l'instruction LIMIT X placée en fin de requête.

Ex :

SELECT * FROM la_table LIMIT 10

Si l'identifiant est un champ auto-incrémenté : voir ici.

Autre possibilité :

SELECT * from la_table ORDER BY champ_numero desc LIMIT 1

L'opérateur LIKE permet de comparer deux chaînes de caractères. Le joker % représente n'importe quel nombre de caractères dans une chaîne. Le joker _ représente exactement un caractère dans une chaîne.

SELECT nom FROM la_table WHERE nom LIKE '%toto%'

SELECT nom FROM la_table WHERE nom LIKE 'toto%'

SELECT nom FROM la_table WHERE nom LIKE 'toto_'

SELECT nom FROM la_table WHERE nom REGEXP 'pattern'

Les fonctions ENCODE(), DECODE(), AES_ENCRYPT() et AES_DECRYPT() permettent un cryptage réversible d'une chaine de caractères.

Les données cryptées par MD5() et PASSWORD() ne sont pas décodables. Pour un test de validité de mot de passe par exemple, il faudra tester si : PASSWORD('passe_a_tester') = 'passe_crypté'

http://dev.mysql.com/doc/mysql/fr/En...functions.html

Les INSERT sont de cette forme :

INSERT INTO ma_table (mes_champs) VALUES (mes_valeurs)

INSERT ma_table SET (mes_champs = mes valeurs)

La requête suivante permet d'obtenir la liste des doublons sur une colonne identifiant (ID1) d'une table (TABLE1):

1
2
3
4
SELECT COUNT(*) AS nb_doubles, ID1 
FROM   TABLE1 
GROUP  BY ID1 
HAVING nb_doubles > 1

Prenons deux tables Objet et Categorie avec le schéma suivant:

• Objet(ID, categorie, couleur)
• Categorie(id, nom)
  

1
2
3
4
DELETE o 
FROM Objet o 
LEFT JOIN Categorie c ON o.categorie = c.id 
WHERE c.id IS NULL

En créant une colonne supplémentaire, fictive, donnant la table d'origine de chaque ligne.

Supposons que vous ayez 3 tables avec des colonnes de même type (condition indispensable pour que la clause UNION puisse fonctionner) : table1, table2 et table3. Vous souhaitez ramener les champs de même type (par exemple champ1 integer, champ2 varchar(10), champ3 date) dans une seule requête.
Mais vous voulez, pour chaque ligne renvoyée, savoir de quelle table elle provient.

Pour cela, créez une colonne "origine" dans chaque sous-requête, contenant le nom de la table d'origine des données. Ce qui donne le code suivant :

1
2
3
4
5
6
7
8
SELECT champ1, champ2, champ3, 'table1' AS origine 
FROM table1 
UNION ALL 
SELECT champ1, champ2, champ3, 'table2' AS origine 
FROM table2 
UNION ALL 
SELECT champ1, champ2, champ3, 'table3' AS origine 
FROM table3

Pour afficher un enregistrement aléatoirement, il est possible d'utiliser la fonction MySQL RAND() qui génère des nombres aléatoires.
Pour sélectionner un enregistrement aléatoirement dans la table "nom_table", il suffit d'utiliser la requête suivante :

1
2
3
4
SELECT * 
FROM nom_table 
ORDER BY RAND() 
LIMIT 1

Supposons que vous ayez une table avec un champ de type chaîne de caractères, et que vous souhaitiez trier les résultats d'une requête selon ce champ, mais dans un ordre différent de l'ordre alphabétique.
Par exemple, une table "ma_table" contient un champ "ma_chaine", de type chaîne de caractères, pouvant prendre les valeurs 'UN', 'DEUX' et 'TROIS'.

Vous souhaitez faire une requête dont les lignes sont triées selon le champ "ma_chaine", mais dans l'ordre 'UN', 'DEUX' puis 'TROIS'.
Ce tri n'est pas possible par un simple "ORDER BY ma_chaine", qui donnerait un résultat trié dans l'ordre 'DEUX', 'TROIS' puis 'UN'.

Pour cela, il faut utiliser la fonction FIELD() de MySQL dans la clause ORDER BY, comme suit :

1
2
3
SELECT * 
FROM ma_table 
ORDER BY FIELD(ma_chaine, 'UN', 'DEUX', 'TROIS')

En utilisant la syntaxe INSERT INTO table_cible SELECT...
Prenons un exemple : à partir d'une table nommée table1 et composée des champs id, categorie et valeur, vous voulez insérer dans une table nommée table2 et composée des champs id_categorie et val_max la catégorie et la valeur maximale de chaque catégorie issues de table1.
Les scripts de création de ces tables sont :

1
2
3
4
5
6
7
8
9
10
11
12
CREATE TABLE `test`.`table1` ( 
  `id` INTEGER UNSIGNED NOT NULL AUTO_INCREMENT, 
  `categorie` INTEGER UNSIGNED NOT NULL, 
  `valeur` INTEGER UNSIGNED NOT NULL, 
  PRIMARY KEY (`id`) 
) 
  
CREATE TABLE `test`.`table2` ( 
  `id_categorie` INTEGER UNSIGNED NOT NULL, 
  `val_max` INTEGER UNSIGNED NOT NULL, 
  PRIMARY KEY (`id`) 
)

1
2
3
4
INSERT INTO table2 (id_categorie, val_max) 
SELECT categorie, MAX(valeur) 
FROM table1 
GROUP BY categorie

La division d'une valeur par elle-même donne 1 s'il s'agit d'un nombre et NULL dans le cas contraire.
Pour trouver les valeurs non-numériques, il suffit alors de faire :

1
2
3
4
  
SELECT * 
FROM maTable 
WHERE (NomColonne / NomColonne) IS NULL

Oui, il suffit d'utiliser une variable et de l'incrémenter à chaque projection de la manière suivante :

1
2
3
4
5
6
  
SET @currentRow=0; 
SELECT @currentRow:=@currentRow+1 AS num_ligne, colonne1, colonne2, ... 
FROM nom_table 
WHERE ... 
ORDER BY colonne1, colonne2, ...

L'opérateur <=>, également appelé NULL-safe equal to operator, fonctionne exactement comme l'opérateur d'égalité =, sauf qu'il considère que NULL est égal à NULL. Autrement dit, la condition suivante :

1
2
 
a <=> b

1
2
 
(a = b OR a IS NULL AND b IS NULL)

' (apostrophe ou single quote) sert à entourer une valeur de format alphanumérique.

` (accent grave ou backtick, touches Alt Gr + 7) sert à entourer les noms des objets de la BDD (base, table, colonne), surtout lorsque ces noms peuvent être mal interprétés par MySQL :

• Noms en plusieurs mots ;
• Mots réservés de MySQL.
  

1
2
3
4
  
SELECT `Nom utilisateur` 
FROM `table` 
WHERE statut = 'actif'

• Il est fortement déconseillé de nommer des objets avec des espaces et des mots réservés, justement pour des problèmes d'interprétation si le ` est oublié.
• Les ' sont inutiles, voire déconseillés, autour des valeurs numériques en rapport avec une colonne numérique.
• phpMyAdmin a tendance à ajouter les ` systématiquement autour des noms d'objets, mais aussi des ' autour des valeurs si vous utilisez sa fonction de recherche.
  

GROUP_CONCAT est une fonction d'agrégation (comme COUNT, MAX, etc.) permettant de concaténer tous les enregistrements des groupes définis par la clause la clause GROUP BY.
En d'autres termes, GROUP_CONCAT est à CONCAT ce que SUM est à l'opérateur +.

Exemple :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
  
CREATE TABLE groupe_utilisateur ( 
     ID_GROUPE INT AUTO_INCREMENT NOT NULL, 
     LIBELLE_GROUPE VARCHAR(50), 
     PRIMARY KEY (ID_GROUPE) 
); 
CREATE TABLE utilisateur ( 
     ID_USER INT AUTO_INCREMENT NOT NULL, 
     NOM_USER VARCHAR(50) NOT NULL, 
     ID_GROUPE INT NOT NULL, 
     PRIMARY KEY (ID_USER), 
     FOREIGN KEY (ID_GROUPE) REFERENCES groupe_utilisateur (ID_GROUPE) 
); 
INSERT INTO groupe_utilisateur (LIBELLE_GROUPE) VALUES 
('utilisateurs'), ('administrateurs'); 
INSERT INTO utilisateur (NOM_USER, ID_GROUPE) VALUES 
('bob', 1), ('toto', 1), ('bibi', 1), ('superuser', 2), ('directeur', 2);

1
2
3
4
5
  
SELECT LIBELLE_GROUPE, GROUP_CONCAT(NOM_USER SEPARATOR ':' ORDER BY NOM_USER) AS LIST_USERS 
FROM utilisateur 
INNER JOIN groupe_utilisateur USING (ID_GROUPE) 
GROUP BY (utilisateur.ID_GROUPE)

1
2
3
4
5
6
7
 
+-----------------+---------------------+ 
| LIBELLE_GROUPE  | LIST_USERS          | 
+-----------------+---------------------+ 
| utilisateurs    | bibi:bob:toto       | 
| administrateurs | directeur:superuser | 
+-----------------+---------------------+

CONCAT_WS (with separator) ajoute un séparateur à la concaténation. Autrement dit, la formule suivante :

CONCAT('pommes', ' - ', 'bananes', ' - ', 'noix')

CONCAT_WS(' - ', 'pommes', 'bananes', 'noix')

1
2
SELECT CONCAT('rouge', NULL, 'bleu') -- Retourne NULL 
SELECT CONCAT_WS(',', 'rouge', NULL, 'bleu') -- Retourne 'rouge,bleu'