Toute table a son début logique et sa fin logique. En outre, toute table est constituée de données qui sont souvent, et dans le cas des bases de données dans une plus large mesure, dispersées. Comme indiqué dans la première entrée concernant SQL et les bases de données, des données peuvent être ajoutées régulièrement tout au long du cycle de vie des bases de données. Pendant ce temps, plus d'une douzaine de données peuvent être saisies. En SQL, comme dans tout le reste et dans tous logiciels d'ordinateur, vous pouvez trier les données. Cela se fait par commande COMMANDÉ PAR. Il y a deux arguments pour cette commande.

• ASC définit l'ordre dans l'ordre croissant (du plus petit au plus grand)
• DESC - décroissant (du plus grand au plus petit)

En général, l'ordre par défaut dans SQL est croissant (du plus petit au plus grand).
Essayons de trier le tableau des débiteurs par nom de famille - colonne Sname - par ordre décroissant

Débiteurs

Numéro	mois	année	Le nom de	Ville	Adresse	Peine	Dette
0001	Juillet	2012	Ivanov	Stavropol	Stavropolskaïa, 1	4891.00	50000
0002	Décembre	2019	Kononov	tatar	Zagorodnaïa, 254	19565.00	684068
0003	Peut	2013	Yamshin	Mikhaïlovsk	Campagne, 48	9868.00	165840
0004	Août	2012	preny	Stavropol	Centrale, 16	4659.00	46580
...	...	...	...	...	...	...	...
9564	Mars	2015	Ouliev	Démino	internationale, 156	6846.00	435089
9565	Octobre	2012	Pavlova	Stavropol	Gare, 37	685.00	68059
9566	Janvier	2012	Uryupa	Mikhaïlovsk	Fontannaya, 19 ans	1235.00	51238
9567	Novembre	2017	Valetov	tatar	Sortie, 65	13698.00	789654

Exécuter la requête
SÉLECTIONNER*
DE Débiteurs
ORDER BY Nom DESC ;

Débiteurs

Numéro	mois	année	Le nom de	Ville	Adresse	Peine	Dette
0003	Peut	2013	Yamshin	Mikhaïlovsk	Campagne, 48	9868.00	165840
9566	Janvier	2012	Uryupa	Mikhaïlovsk	Fontannaya, 19 ans	1235.00	51238
9564	Mars	2015	Ouliev	Démino	internationale, 156	6846.00	435089
0004	Août	2012	preny	Stavropol	Centrale, 16	4659.00	46580
9565	Octobre	2012	Pavlova	Stavropol	Gare, 37	685.00	68059
0002	Décembre	2019	Kononov	tatar	Zagorodnaïa, 254	19565.00	684068
0001	Juillet	2012	Ivanov	Stavropol	Stavropolskaïa, 1	4891.00	50000
9567	Novembre	2017	Valetov	tatar	Sortie, 65	13698.00	789654

Le classement peut également être effectué dans des données groupées à l'aide de la commande . Mais dans ce cas, la commande ORDER BY dans la requête doit être la dernière, c'est-à-dire
SÉLECTIONNER*
DE Débiteurs
GROUP BY Nom
ORDER BY Nom DESC ;

S'il y a des cellules avec des valeurs vides (NULL) dans les champs ordonnés, alors, selon les programmes travaillant avec la base de données, ces cellules peuvent être situées soit à la fin de la liste, soit au début.
Il existe une autre astuce pour effectuer le classement des données. Envisagez une requête
SELECT Numéro, Année, Prénom
DE Débiteurs
ORDRE PAR 2 DESC ;
Ici, deux signifie le numéro ordinal de la colonne de la chaîne "SELECT Num, Year, Sname" et c'est cette colonne qui sera utilisée pour classer par ordre décroissant à la fin

Débiteurs

Comme vous pouvez le voir, les valeurs sont triées par la colonne Année, avec la dernière date au début de la liste.
Ainsi, la commande en SQL a les mêmes principes de classement que dans n'importe quel programme informatique. Tout dépend de l'administrateur de la base de données et de ses besoins pour telle ou telle information qu'il souhaite recevoir.

SQL - Instruction SELECT

Le nom SQL (Structured Query Language) reflète le fait que les requêtes sont l'élément le plus couramment utilisé de SQL. Une requête est une instruction qui envoie une commande à un système de gestion de base de données (SGBD) pour manipuler ou afficher certaines informations. Toutes les requêtes de sélection de données en SQL sont construites à l'aide de l'instruction SELECT. Il vous permet d'effectuer des contrôles et des traitements de données assez complexes.

Une requête peut afficher les données d'une colonne spécifique ou de toutes les colonnes d'une table. Pour créer la requête SELECT la plus simple, vous devez spécifier le nom de la colonne et le nom de la table.

Syntaxe de l'instruction SELECT

SELECT liste_colonnes FROM nom_table

SÉLECTIONNER Un mot clé qui indique à la base de données que l'instruction est une requête. Toutes les requêtes commencent par ce mot, suivi d'un espace.

Column_list Liste des colonnes de table sélectionnées par la requête. Les colonnes non spécifiées dans l'instruction ne seront pas incluses dans le résultat. Si vous devez afficher les données de toutes les colonnes, vous pouvez utiliser la notation abrégée. Un astérisque (*) signifie la liste complète des colonnes.

FROM nom_table Mot-clé qui doit être présent dans chaque requête. Il est suivi d'un espace séparé par le nom de la table qui est la source de données.

Le code entre parenthèses est facultatif dans une instruction SELECT. Il est nécessaire pour une définition plus précise de la demande.

Il faut aussi dire que le code SQL est insensible à la casse. Cela signifie que l'entrée SELECT peut être écrite comme select. Le SGBD ne fera pas la distinction entre ces deux entrées, mais il est conseillé d'écrire toutes les instructions SQL en majuscules afin qu'elles puissent être facilement distinguées des autres codes.

Jetons un coup d'œil à la table Salespeople du didacticiel SQL classique de Martin Graber pour obtenir des exemples.
Voici le code MySQL pour créer une table de test :

CREATE TABLE `salespeople` (`snum` INTEGER(11) NOT NULL AUTO_INCREMENT, `sname` VARCHAR(20) COLLATE cp1251_general_ci DEFAULT NULL, `city` VARCHAR(20) COLLATE cp1251_general_ci DEFAULT NULL, `comm` DOUBLE(15,3) DEFAULT NULL, PRIMARY KEY (`snum`))ENGINE=jeu de caractères InnoDB "cp1251" COLLATE "cp1251_general_ci" COMMENT="InnoDB libre : 5120 ko" ; INSERT INTO `salespeople` (`snum`, `sname`, `city`, `comm`) VALUES (1001,"Peel","London",0.120), (1002,"Serres","San Jose",0.130 ), (1003,"Axelrod","New York",0.100), (1004,"Motika","Londres",0.110), (1007,"Rifkin","Barcelone",0.150); COMMETTRE;

Le tableau ressemble à ceci :

Exemple d'instruction SELECT

1. Il faut afficher une liste de vendeurs, et afficher leurs noms (sname)

SELECT sname FROM Vendeurs

Résultat:

Ici, après l'instruction SELECT, les colonnes à afficher sont répertoriées. Les noms de colonne sont séparés par des virgules.

3. Il faut afficher tout le tableau

Pour ce faire, vous pouvez utiliser une syntaxe différente pour l'écriture des requêtes. Nous listons chaque colonne après l'instruction SELECT :

SELECT snum , sname , ville , comm FROM Vendeurs

Ou vous pouvez obtenir le même résultat en utilisant la notation abrégée :

SELECT * FROM Vendeurs Résultat :

merde	Le nom de	ville	communication
1001	Peler	Londres	0,12
1002	Serrès	San José	0,13
1003	Axelrod	New York	0,1
1004	Motika	Londres	0,11
1007	Rifkin	Barcelone	0,15

Je veux aussi te donner un petit conseil. Pour faciliter le débogage des requêtes, certaines personnes écrivent une liste de colonnes qui doivent être affichées sur une ligne distincte. Cela facilite le commentaire du code. La syntaxe pour commenter le code en SQL est /* code commenté */ . Exemple : SELECT snum ,sname , city , comm FROM Salespeople

Cela affichera 4 colonnes, cependant, avec un tel enregistrement, vous pouvez facilement commenter une colonne inutile. Par exemple comme ceci :

SELECT /* snum , */ sname , ville , comm FROM Vendeurs

Maintenant, la colonne snum ne sera pas affichée car elle est commentée. Très rapide et pratique. Comment écrire du code SQL dépend de vous, bien sûr, mais savoir de telles choses est parfois utile.

Utilisation d'expressions dans une instruction SELECT

De nombreux SGBD fournissent des fonctionnalités spéciales pour gérer les résultats des requêtes. L'ensemble de ces fonctionnalités dans différents SGBD est différent, mais il existe certaines fonctionnalités standard, telles que les expressions. Par exemple, vous souhaiterez peut-être effectuer des opérations mathématiques simples sur les données pour les présenter de manière plus pratique ou insérer du texte supplémentaire dans le résultat d'une requête. SQL vous permet de placer des expressions scalaires et des constantes parmi les colonnes sélectionnées qui peuvent compléter ou remplacer les colonnes dans les clauses SELECT. Prenons un exemple.

4. Il est nécessaire d'afficher les commissions (comm) des vendeurs sous forme de pourcentages et non de nombres décimaux

SELECT snum, sname, ville, comm * 100 FROM Vendeurs

Résultat:

merde	Le nom de	ville	communication
1001	Peler	Londres	12
1002	Serrès	San José	13
1003	Axelrod	New York	10
1004	Motika	Londres	11
1007	Rifkin	Barcelone	15

Dans la dernière colonne, toutes les données reçues sont multipliées par 100 et affichées sous forme de pourcentage.

Cette colonne n'a pas de nom, car elle ne contient pas de données modifiées et est donc nommée à la discrétion du SGBD (par exemple, MySQL nomme la colonne comm * 100, dans les exemples de M. Grabber, la colonne porte le nom 4, c'est-à-dire son numéro).

Dans de tels cas, il est pratique d'utiliser nommage des colonnes. Par exemple, vous pouvez nommer la dernière colonne pourcentage. Pour cela, après le nom de la colonne, vous devez spécifier le mot-clé AS puis le nom de la colonne dans la page résultante.

SELECT snum, sname, city, comm * 100 AS "percent" FROM Vendeurs Résultat :

merde	Le nom de	ville	pour cent
1001	Peler	Londres	12
1002	Serrès	San José	13
1003	Axelrod	New York	10
1004	Motika	Londres	11
1007	Rifkin	Barcelone	15

À la suite de la requête, la dernière colonne est nommée la chaîne "pourcentage", ce qui facilite la compréhension.

Puisque le nombre est affiché en pourcentage, il serait bien de l'indiquer dans le résultat. La capacité SQL vient à la rescousse ajouter du texte au résultat. Il ressemble à ceci :

SELECT snum, sname, city, comm * 100 AS percent , "%" FROM Vendeurs Résultat :

merde	Le nom de	ville	pour cent	%
1001	Peler	Londres	12	%
1002	Serrès	San José	13	%
1003	Axelrod	New York	10	%
1004	Motika	Londres	11	%
1007	Rifkin	Barcelone	15	%

On peut voir qu'après la sortie de la ligne de la base de données, une nouvelle colonne est apparue, remplie d'un signe de pourcentage (%).

Si vous n'êtes pas satisfait de la sortie des données et du texte complémentaire dans différentes colonnes, vous pouvez utiliser les fonctions spéciales de votre SGBD pour fusionner en une seule colonne.

MySQL utilise la fonction CONCAT . Voici sa définition tirée du manuel :

CONCAT(str1,str2,...)
Renvoie une chaîne résultant de la concaténation des arguments. Si au moins un des arguments est NULL, NULL est renvoyé. Peut prendre plus de 2 arguments. L'argument numérique est converti en sa forme de chaîne équivalente.

Exemple : SELECT snum, sname, city , CONCAT(comm * 100, "%") AS "persent" FROM vendeurs Résultat :

merde	Le nom de	ville	présent
1001	Peler	Londres	12.000%
1002	Serrès	San José	13.000%
1003	Axelrod	New York	10.000%
1004	Motika	Londres	11.000%
1007	Rifkin	Barcelone	15.000%

Dans cette requête, la fonction CONCAT prend 2 arguments, ce sont comm * 100 et le signe pourcentage ("%"). Nous nommons ensuite la colonne avec AS.

Il est important de savoir que l'utilisation de fonctions dégrade les performances. Ce n'est pas le seul point négatif, mais un point très important. Par conséquent, si vous pouvez vous en sortir avec du code SQL standard, il est préférable de ne pas utiliser de fonctions. Ils ne doivent être rappelés que dans des cas extrêmes.

Exclusion des données redondantes

Il est souvent nécessaire d'exclure les valeurs en double des résultats de la requête. Le mot clé DISTINCT est utilisé pour cela. L'effet inverse est obtenu en utilisant le mot ALL, qui est utilisé par défaut (c'est-à-dire qu'il n'a pas besoin d'être spécifié).

5. Il faut afficher les villes (city), où il y a des vendeurs

Demande sans exception :

SELECT city FROM vendeurs Résultat :

Les valeurs de Londres en double sont exclues du résultat, selon les besoins.

Trier le résultat par valeurs par colonne

L'instruction SELECT génère des données dans une séquence arbitraire. Pour trier le résultat par une colonne particulière, SQL utilise l'opérateur ORDER BY (c'est-à-dire, trier par...). Cette instruction vous permet de modifier l'ordre dans lequel les données sont sorties. ORDER BY ordonne le résultat de la requête en fonction des valeurs d'une ou plusieurs colonnes sélectionnées dans la clause SELECT. Dans ce cas, pour chaque colonne, vous pouvez définir le tri en ordre croissant - croissant (ASC) (ce paramètre est utilisé par défaut) ou en ordre décroissant - décroissant (DESC).

Triez le résultat par la colonne sname. Après l'opérateur ORDER BY, nous indiquons par quelle colonne trier, puis vous devez spécifier la méthode de tri

Exemple - tri par ordre croissant :

SELECT * FROM Vendeurs ORDER BY snom ASC

Résultat:

Exemple - tri sur plusieurs colonnes :

SELECT snum, sname, ville FROM Vendeurs ORDER BY sname DESC, ville DESC Résultat :

merde	Le nom de	ville
1002	Serrès	San José
1007	Rifkin	Barcelone
1001	Peler	Londres
1004	Motika	Londres
1003	Axelrod	New York

Quelques remarques importantes :
- la colonne par laquelle le tri se produit doit être spécifiée dans SELECT (vous pouvez utiliser *)
- l'opérateur ORDER BY est toujours écrit à la fin de la requête

Bienvenue sur mon blog. Aujourd'hui, nous allons parler des requêtes sql pour les débutants. Certains webmasters peuvent avoir une question. Pourquoi apprendre sql ? Vous ne pouvez pas passer?

Il s'avère que cela ne suffira pas à créer un projet Internet professionnel. SQL est utilisé pour travailler avec la base de données et créer des applications pour WordPress. Voyons plus en détail comment utiliser les requêtes.

Ce que c'est

SQL est un langage de requête structuré. Créé pour déterminer le type de données, y accéder et traiter l'information en peu de temps. Il décrit les composants ou certains résultats que vous souhaitez voir sur le projet Internet.

En termes simples, ce langage de programmation permet d'ajouter, de modifier, de rechercher et d'afficher des informations dans la base de données. La popularité de mysql est due au fait qu'il est utilisé pour créer des projets Internet dynamiques, basés sur une base de données. Par conséquent, pour développer un blog fonctionnel, vous devez apprendre ce langage.

Que peut faire

Le langage sql permet :

• créer des tableaux ;
• modifier la réception et le stockage de différentes données ;
• combiner les informations en blocs ;
• protéger les données ;
• créer des requêtes en accès.

Important! Après avoir traité sql, vous pouvez écrire des applications pour WordPress de toute complexité.

Quelle structure

La base de données se compose de tableaux qui peuvent être représentés sous forme de fichier Excel.

Elle a un nom, des colonnes et une ligne avec quelques informations. Vous pouvez créer de telles tables à l'aide de requêtes sql.

Que souhaitez-vous savoir

Points clés lors de l'apprentissage de SQL

Comme indiqué ci-dessus, les requêtes sont utilisées pour traiter et entrer de nouvelles informations dans une base de données composée de tables. Chaque ligne est une entrée distincte. Créons donc une base de données. Pour ce faire, écrivez la commande :

Créer la base de données 'bazaname'

Entre guillemets, nous écrivons le nom de la base de données en latin. Essayez de penser à un nom significatif pour elle. Ne créez pas une base de données comme "111", "www" et autres.

Après avoir créé la base de données, installez :

DÉFINIR LES NOMS 'utf-8'

Cela est nécessaire pour que le contenu du site s'affiche correctement.

Maintenant, nous créons une table :

CREATE TABLE 'bazaname' . 'tableau' (

id INT(8) NOT NULL AUTO_INCREMENT CLÉ PRIMAIRE,

log VARCHAR(10),

passer VARCHAR(10),

date DATE

Dans la deuxième ligne, nous avons écrit trois attributs. Voyons ce qu'ils signifient :

• L'attribut NOT NULL signifie que la cellule ne sera pas vide (le champ est obligatoire) ;
• La valeur de AUTO_INCREMENT est la saisie semi-automatique ;
• PRIMARY KEY est la clé primaire.

Comment ajouter des informations

Pour remplir les champs de la table créée avec des valeurs, l'instruction INSERT est utilisée. Nous écrivons les lignes de code suivantes :

INSÉRER DANS 'tableau'

(login , pass , date) VALEURS

('Vasa', '87654321', '2017-06-21 18:38:44');

Entre parenthèses, nous indiquons le nom des colonnes, et dans le suivant - les valeurs.

Important! Suivez la séquence des noms de colonne et des valeurs.

Comment mettre à jour les informations

Pour cela, la commande UPDATE est utilisée. Voyons comment changer le mot de passe d'un utilisateur spécifique. Nous écrivons les lignes de code suivantes :

UPDATE 'table' SET pass = '12345678' WHERE id = '1'

Changez maintenant le mot de passe en '12345678'. Les changements se produisent dans la ligne avec "id"=1. Si vous n'écrivez pas la commande WHERE, toutes les lignes changeront, pas une spécifique.

Je vous conseille d'acheter le livre SQL pour les nuls ". Avec son aide, vous pourrez travailler professionnellement avec la base de données étape par étape. Toutes les informations sont construites sur la base du principe du simple au complexe, et seront bien reçues.

Comment supprimer une entrée

Si vous avez écrit quelque chose de mal, corrigez-le avec la commande DELETE. Fonctionne de la même manière que UPDATE. Nous écrivons le code suivant :

DELETE FROM 'table' WHERE id = '1'

Échantillonnage d'informations

La commande SELECT est utilisée pour récupérer des valeurs de la base de données. Nous écrivons le code suivant :

SELECT * FROM 'table' WHERE id = '1'

DANS cet exemple sélectionner tous les champs disponibles dans le tableau. Cela se produit si vous écrivez un astérisque "*" dans la commande. Si vous devez choisir un exemple de valeur, écrivez comme ceci :

SELECT log , passez FROM table WHERE id = '1'

Il convient de noter que la capacité de travailler avec des bases de données ne suffira pas. Pour créer un projet Internet professionnel, vous devrez apprendre à ajouter des données de la base de données aux pages. Pour cela, familiarisez-vous avec le langage de programmation web php. Cela vous aidera Le parcours cool de Mikhail Rusakov .

Suppression d'un tableau

Se produit avec une requête DROP. Pour ce faire, écrivez les lignes suivantes :

tableau DROP TABLE ;

Sortie d'un enregistrement à partir d'une table selon une certaine condition

Considérez ce code :

SELECT id, country, city FROM table WHERE people>150000000

Il affichera les registres des pays dont la population est supérieure à cent cinquante millions.

Une association

Il est possible de lier plusieurs tables ensemble à l'aide de Join. Voyez comment cela fonctionne dans cette vidéo :

PHP et MySQL

Encore une fois, je tiens à souligner que les demandes lors de la création d'un projet Internet sont une chose courante. Pour les utiliser dans des documents php, suivez l'algorithme d'actions suivant :

• Connectez-vous à la base de données à l'aide de la commande mysql_connect() ;
• À l'aide de mysql_select_db(), sélectionnez la base de données souhaitée ;
• Traitement de la requête avec mysql_fetch_array();
• Nous fermons la connexion avec la commande mysql_close().

Important! Travailler avec une base de données n'est pas difficile. L'essentiel est d'écrire correctement la demande.

Les webmasters novices penseront. Et que lire sur ce sujet ? Je voudrais recommander le livre de Martin Graber " SQL pour les simples mortels ". Il est écrit de telle manière que les débutants comprendront tout. Utilisez-le comme un livre de référence.

Mais c'est une théorie. Comment ça marche en pratique ? En fait, un projet Internet doit non seulement être créé, mais également amené au TOP de Google et Yandex. Le cours vidéo vous y aidera " Création et promotion du site ».

Instruction vidéo

Vous avez encore des questions ? Regardez plus de vidéos en ligne.

Conclusion

Ainsi, gérer l'écriture de requêtes sql n'est pas aussi difficile qu'il n'y paraît, mais tout webmaster doit le faire. Les cours vidéo décrits ci-dessus vous y aideront. S'abonner à mon groupe VKontakte être le premier à connaître de nouvelles informations intéressantes.

Les requêtes sont écrites sans guillemets d'échappement, car MySQL, MS SQL Et PostGree ils sont différents.

Requête SQL : obtention des champs spécifiés (obligatoires) à partir de la table

SELECT id, country_title, count_people FROM table_name

Nous obtenons une liste d'enregistrements : TOUS les pays et leur population. Les noms des champs obligatoires sont séparés par des virgules.

SELECT * FROM nom_table

* désigne tous les champs. C'est-à-dire qu'il y aura des affichages TOUT champs de données.

Requête SQL : affichage des enregistrements d'une table en excluant les doublons

SELECT DISTINCT country_title FROM table_name

Nous obtenons une liste d'enregistrements : les pays où se trouvent nos utilisateurs. Il peut y avoir plusieurs utilisateurs d'un même pays. Dans ce cas, c'est votre demande.

Requête SQL : affichage des enregistrements d'une table selon une condition donnée

SELECT id, country_title, city_title FROM table_name WHERE count_people>100000000

Nous obtenons une liste de records : pays où le nombre d'habitants est supérieur à 100 000 000.

Requête SQL : affichage des enregistrements d'une table avec ordre

SELECT id, city_title FROM table_name ORDER BY city_title

On obtient une liste d'enregistrements : villes par ordre alphabétique. A au début, Z à la fin.

SELECT id, city_title FROM table_name ORDER BY city_title DESC

On obtient une liste d'enregistrements : villes à l'envers ( DESC) c'est bien. Au début I, à la fin A.

Requête SQL : compter le nombre d'enregistrements

SELECT COUNT(*) FROM nom_table

Nous obtenons le nombre (nombre) d'enregistrements dans la table. Dans ce cas, il n'y a AUCUNE liste d'entrées.

Requête SQL : affichage de la plage d'enregistrements souhaitée

SELECT * FROM nom_table LIMIT 2, 3

Nous obtenons 2 (deuxième) et 3 (troisième) enregistrements de la table. La requête est utile lors de la création d'une navigation sur des pages WEB.

Requêtes SQL avec conditions

Affichage des enregistrements d'une table selon une condition donnée à l'aide d'opérateurs logiques.

Requête SQL : construction AND (AND)

SELECT id, city_title FROM table_name WHERE country="Russie" AND oil=1

Obtenir une liste d'enregistrements : villes de Russie ET ont accès au pétrole. Quand l'opérateur est-il utilisé ? ET, alors les deux conditions doivent correspondre.

Requête SQL : construction OU (OU)

SELECT id, city_title FROM table_name WHERE country="Russie" OR country="USA"

Obtenir une liste des records : toutes les villes de Russie OU ETATS-UNIS. Quand l'opérateur est-il utilisé ? OU, alors AU MOINS une condition doit correspondre.

Requête SQL : construction AND NOT (AND NOT)

SELECT id, user_login FROM table_name WHERE country="Russie" AND NOT count_comments<7

Obtenir une liste des enregistrements : tous les utilisateurs de Russie ET fait PAS MOINS 7 commentaires.

Requête SQL : construction IN (B)

SELECT id, user_login FROM table_name WHERE country IN ("Russie", "Bulgarie", "Chine")

Nous obtenons une liste d'enregistrements : tous les utilisateurs qui vivent dans ( DANS) (Russie, ou Bulgarie, ou Chine)

Requête SQL : construction NOT IN (NOT IN)

SELECT id, user_login FROM table_name WHERE country NOT IN ("Russie","Chine")

Nous obtenons une liste d'enregistrements : tous les utilisateurs qui ne vivent pas dans ( PAS DEDANS) (Russie ou Chine).

Requête SQL : construction IS NULL (valeurs vides ou NOT vides)

SELECT id, user_login FROM table_name WHERE status IS NULL

Nous obtenons une liste d'enregistrements : tous les utilisateurs dont le statut n'est pas défini. NULL est une rubrique distincte et est donc vérifiée séparément.

SELECT id, user_login FROM table_name WHERE state IS NOT NULL

Nous obtenons une liste d'enregistrements : tous les utilisateurs pour lesquels le statut est défini (PAS DE ZÉRO).

Requête SQL : construction LIKE

SELECT id, user_login FROM table_name WHERE nom LIKE "John%"

Nous obtenons une liste d'enregistrements : les utilisateurs dont le nom de famille commence par la combinaison "Ivan". Le signe % signifie N'IMPORTE QUEL nombre de N'IMPORTE QUEL caractère. Pour trouver le signe %, vous devez utiliser le "Ivan\%" d'échappement.

Requête SQL : construction BETWEEN

SELECT id, user_login FROM table_name WHERE salaire BETWEEN 25000 AND 50000

On obtient une liste d'enregistrements : des utilisateurs qui perçoivent un salaire de 25 000 à 50 000 inclus.

Il existe de TRÈS nombreux opérateurs logiques, alors étudiez en détail la documentation du serveur SQL.

Requêtes SQL complexes

Requête SQL : joindre plusieurs requêtes

(SELECT id, user_login FROM table_name1) UNION (SELECT id, user_login FROM table_name2)

Nous obtenons une liste d'entrées : les utilisateurs qui sont enregistrés dans le système, ainsi que les utilisateurs qui sont enregistrés sur le forum séparément. L'opérateur UNION peut combiner plusieurs requêtes. UNION agit comme SELECT DISTINCT, c'est-à-dire qu'il supprime les valeurs en double. Pour obtenir absolument tous les enregistrements, vous devez utiliser l'opérateur UNION ALL.

Requête SQL : calcul des valeurs des champs MAX, MIN, SUM, AVG, COUNT

La sortie d'un, la valeur maximale du compteur dans le tableau :

SELECT MAX(compteur) FROM nom_table

La sortie de un, la valeur minimale du compteur dans le tableau :

SELECT MIN(compteur) FROM nom_table

Affichage de la somme de toutes les valeurs de compteur dans le tableau :

SELECT SUM(compteur) FROM nom_table

Affichage de la valeur moyenne du compteur dans le tableau :

SELECT AVG(compteur) FROM nom_table

Affichage du nombre de compteurs dans le tableau :

SELECT COUNT(compteur) FROM nom_table

Conclusion du nombre de compteurs dans le magasin n ° 1, dans le tableau :

SELECT COUNT(compteur) FROM table_name WHERE office="Atelier #1"

Ce sont les commandes les plus populaires. Il est recommandé, dans la mesure du possible, d'utiliser des requêtes SQL de ce type pour le calcul, car aucun environnement de programmation ne peut être comparé dans la vitesse de traitement des données au serveur SQL lui-même lors du traitement de ses propres données.

Requête SQL : regroupement d'enregistrements

SELECT continent, SUM(country_area) FROM pays GROUP BY continent

On obtient une liste d'enregistrements : avec le nom du continent et avec la somme des superficies de tous leurs pays. Autrement dit, s'il existe un répertoire de pays où chaque pays a sa superficie enregistrée, puis en utilisant la construction GROUP BY, vous pouvez connaître la taille de chaque continent (basée sur le regroupement par continents).

Requête SQL : utilisation de plusieurs tables via alias (alias)

SELECT o.order_no, o.amount_paid, c.company FROM commandes AS o, client AS avec WHERE o.custno=c.custno AND c.city="Tyumen"

Nous obtenons une liste d'enregistrements : des commandes d'acheteurs qui ne vivent qu'à Tyumen.

En fait, avec une base de données correctement conçue de ce type, la requête est la plus fréquente, c'est pourquoi MySQL a introduit un opérateur spécial qui fonctionne plusieurs fois plus rapidement que le code écrit ci-dessus.

SELECT o.order_no, o.amount_paid, z.company FROM commandes AS o LEFT JOIN client AS z ON (z.custno=o.custno)

Sous-requêtes imbriquées

SELECT * FROM nom_table WHERE salaire=(SELECT MAX(salaire) FROM employé)

Nous obtenons un enregistrement : des informations sur l'utilisateur avec le salaire maximum.

Attention! Les sous-requêtes imbriquées sont l'un des goulots d'étranglement des serveurs SQL. Avec leur flexibilité et leur puissance, ils augmentent également considérablement la charge sur le serveur. Ce qui entraîne un ralentissement catastrophique pour les autres utilisateurs. Il y a des cas très fréquents d'appels récursifs avec des requêtes imbriquées. Par conséquent, je recommande fortement de ne PAS utiliser de requêtes imbriquées, mais de les diviser en requêtes plus petites. Ou utilisez la combinaison LEFT JOIN décrite ci-dessus. En plus de ce type de requêtes, elles sont un foyer accru de failles de sécurité. Si vous décidez d'utiliser des sous-requêtes imbriquées, vous devez les concevoir très soigneusement et effectuer des exécutions initiales sur des copies de base de données (bases de données de test).

Requêtes SQL modifiant les données

Requête SQL : INSÉRER

Instruction INSÉRER permettent d'insérer des enregistrements dans la table. En termes simples, créez une ligne avec des données dans un tableau.

Option numéro 1. Consigne souvent utilisée :

INSERT INTO table_name (id, user_login) VALUES (1, "ivanov"), (2, "petrov")

Dans la table " nom de la table» insèrera 2 (deux) utilisateurs à la fois.

Option numéro 2. Il est plus pratique d'utiliser le style :

INSERT table_name SET id=1, user_login="ivanov" ; INSERT table_name SET id=2, user_login="petrov" ;

Cela a ses avantages et ses inconvénients.

Principaux inconvénients :

• De nombreuses petites requêtes SQL sont légèrement plus lentes qu'une grande requête SQL, mais d'autres requêtes seront mises en file d'attente pour le service. Autrement dit, si une grande requête SQL s'exécute pendant 30 minutes, pendant tout ce temps, le reste des requêtes fumera du bambou et attendra son tour.
• La demande est plus massive que la version précédente.

Principaux avantages:

• Lors de petites requêtes SQL, les autres requêtes SQL ne sont pas bloquées.
• Facilité de lecture.
• La flexibilité. Dans cette option, vous ne pouvez pas suivre la structure, mais ajouter uniquement les données nécessaires.
• Lors de la création d'archives de cette manière, vous pouvez facilement copier une ligne et l'exécuter via la ligne de commande (console), sans restaurer ainsi l'intégralité de l'ARCHIVE.
• Le style d'écriture est similaire à l'instruction UPDATE, qui est plus facile à retenir.

Requête SQL : MISE À JOUR

UPDATE nom_table SET user_login="ivanov", user_surname="Ivanov" WHERE id=1

Dans la table " nom de la table» dans l'enregistrement avec le numéro id=1, les valeurs des champs user_login et user_surname seront remplacées par les valeurs spécifiées.

Requête SQL : SUPPRIMER

DELETE FROM nom_table WHERE id=3

L'enregistrement avec le numéro d'identification 3 sera supprimé dans la table table_name.

1. Il est recommandé d'écrire tous les noms de champs en minuscules et, si nécessaire, séparés par un espace forcé "_" pour la compatibilité avec différents langages de programmation tels que Delphi, Perl, Python et Ruby.
2. Les commandes SQL sont écrites en MAJUSCULES pour plus de lisibilité. Rappelez-vous toujours que d'autres personnes peuvent lire le code après vous, mais très probablement vous-même après N temps.
3. Nommez d'abord les champs avec un nom, puis avec une action. Par exemple : city_status, user_login, user_name.
4. Essayez d'éviter les mots réservés dans différentes langues qui peuvent causer des problèmes en SQL, PHP ou Perl, tels que (nom, nombre, lien). Par exemple : le lien peut être utilisé dans MS SQL, mais est réservé dans MySQL.

Ce matériel est une courte référence pour le travail quotidien et ne prétend pas être une super méga source faisant autorité, qui est la principale source de requêtes SQL d'une base de données particulière.

• Traduction
• Didacticiel

Doit-il être « SELECT * WHERE a=b FROM c » ou « SELECT WHERE a=b FROM c ON * » ?

Si vous êtes comme moi, vous serez d'accord : SQL est l'une de ces choses qui semble facile à première vue (il se lit comme l'anglais !), mais d'une manière ou d'une autre, vous devez rechercher sur Google chaque requête simple pour trouver la syntaxe correcte.

Et puis les jointures, l'agrégation, les sous-requêtes commencent, et cela s'avère être complètement nul. Comme ça:

SELECT membres.prénom || " " || membres.lastname AS "Nom complet" FROM emprunts INNER JOIN membres ON membres.memberid=emprunts.memberid INNER JOIN livres ON livres.bookid=emprunts.bookid WHERE emprunts.bookid IN (SELECT bookid FROM livres WHERE stock>(SELECT avg(stock ) FROM livres)) GROUP BY membres.prénom, membres.nom;

Bué ! Cela effraiera tout débutant, ou même un développeur moyen s'il voit SQL pour la première fois. Mais tout n'est pas si mal.

Il est facile de se souvenir de ce qui est intuitif, et avec ce guide, j'espère réduire la barrière à l'entrée dans SQL pour les débutants, tout en offrant une nouvelle vision de SQL pour les plus expérimentés.

Bien que la syntaxe de SQL soit presque la même dans différentes bases de données, cet article utilise PostgreSQL pour les requêtes. Certains exemples fonctionneront dans MySQL et d'autres bases de données.

1. Trois mots magiques

Il existe de nombreux mots clés en SQL, mais SELECT , FROM et WHERE sont présents dans presque toutes les requêtes. Un peu plus tard, vous vous rendrez compte que ces trois mots représentent les aspects les plus fondamentaux de la création de requêtes sur la base de données, et que d'autres requêtes plus complexes ne sont que des ajouts.

2. Notre socle

Jetons un coup d'œil à la base de données que nous utiliserons comme exemple dans cet article :

Nous avons une bibliothèque de livres et des gens. Il existe également une table spéciale pour la comptabilité des livres émis.

• La table "livres" stocke des informations sur le titre, l'auteur, la date de publication et la disponibilité du livre. Tout est simple.
• Dans le tableau "membres" - les noms et prénoms de toutes les personnes qui se sont inscrites à la bibliothèque.
• La table « emprunts » stocke des informations sur les livres empruntés à la bibliothèque. La colonne bookid fait référence à l'identifiant du livre emprunté dans la table "books", et la colonne memberid fait référence à la personne correspondante dans la table "members". Nous avons également une date d'émission et une date à laquelle le livre doit être rendu.

3. Demande simple

Commençons par une demande simple : nous avons besoin des noms Et identifiants(id) tous les livres écrits par l'auteur "Dan Brown"

La requête ressemblera à ceci :

SELECT bookid AS "id", titre FROM livres WHERE author="Dan Brown" ;

Et le résultat est comme ça :

identifiant	titre
2	Le symbole perdu
4	Enfer

Assez simple. Décomposons la demande pour comprendre ce qui se passe.

3.1 FROM - d'où nous obtenons les données

Cela peut sembler évident maintenant, mais FROM sera très important plus tard lorsque nous aborderons les jointures et les sous-requêtes.

FROM pointe vers la table à interroger. Cela peut être une table déjà existante (comme dans l'exemple ci-dessus), ou une table créée à la volée via des jointures ou des sous-requêtes.

3.2 OÙ - quelles données afficher

WHERE se comporte simplement comme un filtre lignes que nous voulons sortir. Dans notre cas, nous ne voulons voir que les lignes où la valeur dans la colonne auteur est "Dan Brown".

3.3 SELECT - comment afficher les données

Maintenant que nous avons toutes les colonnes dont nous avons besoin dans la table dont nous avons besoin, nous devons décider comment afficher exactement ces données. Dans notre cas, nous n'avons besoin que des titres et des identifiants de livres, c'est donc ce que nous faisons. choisir avec SELECT . En même temps, vous pouvez renommer la colonne en utilisant AS .

L'ensemble de la requête peut être visualisé avec un schéma simple :

4. Connexions (jointures)

Maintenant, nous voulons voir les titres (pas nécessairement uniques) de tous les livres de Dan Brown qui ont été empruntés à la bibliothèque, et quand ces livres doivent être rendus :

SELECT livres.titre AS "Titre", emprunts.returndate AS "Date de retour" FROM emprunts JOIN livres ON emprunts.idlivre=livres.idlivre WHERE livres.auteur="Dan Brown" ;

Résultat:

Titre	date de retour
Le symbole perdu	2016-03-23 00:00:00
Enfer	2016-04-13 00:00:00
Le symbole perdu	2016-04-19 00:00:00

Pour l'essentiel, la demande est similaire à la précédente. à l'exception deÀ partir de la rubrique. Cela signifie que nous interrogeons les données d'une autre table. Nous n'accédons ni à la table "livres" ni à la table "emprunts". Au lieu de cela, nous nous tournons vers nouveau tableau, qui a été créé en joignant ces deux tables.

emprunts JOIN livres ON emprunts.bookid=books.bookid est une nouvelle table qui a été formée en combinant tous les enregistrements des tables "livres" et "emprunts" où les valeurs de bookid correspondent. Le résultat d'une telle fusion sera :

Et puis nous faisons une requête à cette table de la même manière que dans l'exemple ci-dessus. Cela signifie que lorsque vous joignez des tables, vous n'avez qu'à vous soucier de la façon d'effectuer cette jointure. Et puis la demande devient aussi claire que dans le cas de la « demande simple » du point 3.

Essayons une jointure un peu plus complexe avec deux tables.

Maintenant, nous voulons obtenir les noms et prénoms des personnes qui ont pris les livres de l'auteur "Dan Brown" à la bibliothèque.

Cette fois, allons de bas en haut :

Étape 1- d'où obtenons-nous les données ? Pour obtenir le résultat souhaité, nous devons joindre les tables "member" et "books" avec la table "borrowings". La section JOIN ressemblera à ceci :

emprunts JOIN livres ON emprunts.bookid=books.bookid JOIN membres ON members.memberid=emprunts.memberid

Le résultat de la connexion peut être vu sur le lien.

Étape 2 Quelles données montrons-nous ? Nous ne sommes intéressés que par les données où l'auteur du livre est "Dan Brown"

WHERE livres.auteur="Dan Brown"

Étape 3 Comment afficher les données ? Maintenant que les données ont été reçues, il ne vous reste plus qu'à afficher les noms et prénoms de ceux qui ont pris les livres :

SELECT membres.prénom AS "Prénom", membres.nom AS "Nom"

Super! Il ne reste plus qu'à combiner les trois composants et faire la requête dont nous avons besoin :

SELECT membres.prénom AS "Prénom", membres.nom AS "Nom" FROM emprunts JOIN livres ON emprunts.bookid=livres.bookid JOIN membres ON membres.memberid=emprunts.memberid WHERE livres.auteur="Dan Brown" ;

Qu'est-ce qui va nous donner :

prénom	nom de famille
Mike	Willis
Ellen	Hortons
Ellen	Hortons

Super! Mais les noms sont répétés (ils ne sont pas uniques). Nous corrigerons cela bientôt.

5. Agrégation

Grosso modo, les agrégations sont nécessaires pour convertir plusieurs chaînes en une seule. Dans le même temps, lors de l'agrégation, une logique différente est utilisée pour différentes colonnes.

Continuons avec notre exemple où les noms en double apparaissent. On peut voir qu'Ellen Horton a pris plus d'un livre, mais ce n'est pas le plus La meilleure façon afficher ces informations. Vous pouvez faire une autre demande :

SELECT membres.prénom AS "Prénom", membres.nom AS "Nom", nombre(*) AS "Nombre de livres empruntés" FROM emprunts JOIN livres ON emprunts.bookid=livres.bookid JOIN membres ON membres.memberid=emprunts .memberid WHERE livres.auteur="Dan Brown" GROUP BY membres.prénom, membres.nom de famille ;

Ce qui nous donnera le résultat souhaité :

prénom	nom de famille	Nombre de livres empruntés
Mike	Willis	1
Ellen	Hortons	2

Presque toutes les agrégations sont accompagnées d'une clause GROUP BY. Cette chose transforme une table qui pourrait être obtenue par une requête en groupes de tables. Chaque groupe correspond à une valeur unique (ou groupe de valeurs) de la colonne que nous avons spécifiée dans GROUP BY . Dans notre exemple, nous convertissons le résultat de l'exercice précédent en un groupe de chaînes. Nous effectuons également une agrégation avec count , qui convertit plusieurs lignes en une valeur entière (dans notre cas, le nombre de lignes). Cette valeur est ensuite affectée à chaque groupe.

Chaque ligne du résultat est le résultat de l'agrégation de chaque groupe.

Vous pouvez arriver à la conclusion logique que tous les champs du résultat doivent soit être spécifiés dans GROUP BY , soit une agrégation doit être effectuée sur eux. Parce que tous les autres champs peuvent différer les uns des autres dans différentes lignes, et si vous les sélectionnez avec SELECT "th, il n'est pas clair laquelle des valeurs possibles doit être prise.

Dans l'exemple ci-dessus, la fonction count a traité toutes les lignes (puisque nous comptions le nombre de lignes). D'autres fonctions comme sum ou max ne traitent que les lignes spécifiées. Par exemple, si nous voulons connaître le nombre de livres écrits par chaque auteur, nous avons besoin de cette requête :

SELECT auteur, sum(stock) FROM livres GROUP BY auteur ;

Résultat:

auteur	somme
Robin Sharma	4
Dan Brun	6
Jean Vert	3
Amish Tripathi	2

Ici, la fonction sum ne traite que la colonne de stock et calcule la somme de toutes les valeurs de chaque groupe.

6. Sous-requêtes

Les sous-requêtes sont des requêtes SQL normales intégrées dans des requêtes plus volumineuses. Ils sont divisés en trois types selon le type du résultat renvoyé.

6.1 Tableau bidimensionnel

Certaines requêtes renvoient plusieurs colonnes. Un bon exemple est la requête de l'exercice d'agrégation précédent. S'agissant d'une sous-requête, elle renverra simplement une autre table sur laquelle de nouvelles requêtes pourront être effectuées. Poursuivant l'exercice précédent, si nous voulons connaître le nombre de livres écrits par l'auteur « Robin Sharma », alors une des manières possibles est d'utiliser des sous-requêtes :

SELECT * FROM (SELECT auteur, sum(stock) FROM livres GROUP BY auteur) AS résultats WHERE author="Robin Sharma" ;

Résultat:

Peut être écrit comme : ["Robin Sharma", "Dan Brown"]

2. Utilisez maintenant ce résultat dans une nouvelle requête :

SELECT titre, bookid FROM livres WHERE auteur IN (SELECT auteur FROM (SELECT auteur, somme(stock) FROM livres GROUP BY auteur) AS résultats WHERE somme > 3);

Résultat:

titre	ID de livre
Le symbole perdu	2
Qui va pleurer quand tu mourras ?	3
Enfer	4

C'est la même chose que :

SELECT title, bookid FROM livres WHERE author IN ("Robin Sharma", "Dan Brown");

6.3 Valeurs individuelles

Certaines requêtes n'aboutissent qu'à une seule ligne et une seule colonne. Ils peuvent être traités comme des valeurs constantes et peuvent être utilisés partout où des valeurs sont utilisées, comme dans les opérateurs de comparaison. Ils peuvent également être utilisés comme tableaux à deux dimensions ou comme tableaux à un seul élément.

Par exemple, obtenons des informations sur tous les livres dont le nombre dans la bibliothèque dépasse la valeur moyenne pour le moment.

La moyenne peut être obtenue de cette façon :

sélectionnez avg (stock) dans les livres ;

Ce qui nous donne :

7. Opérations d'écriture

La plupart des opérations d'écriture de base de données sont assez simples par rapport aux opérations de lecture plus complexes.

7.1 Mise à jour

La syntaxe d'une demande UPDATE est sémantiquement la même qu'une demande de lecture. La seule différence est qu'au lieu de sélectionner des colonnes avec SELECT "th, nous définissons la connaissance avec SET "th.

Si tous les livres de Dan Brown sont perdus, vous devez réinitialiser la valeur de la quantité. La requête pour cela serait:

UPDATE livres SET stock=0 WHERE author="Dan Brown";

WHERE fait la même chose que précédemment : sélectionne des lignes. Au lieu de SELECT , qui était utilisé lors de la lecture, nous utilisons maintenant SET . Cependant, vous devez maintenant spécifier non seulement le nom de la colonne, mais également la nouvelle valeur de cette colonne dans les lignes sélectionnées.

7.2 Supprimer

Une requête DELETE est juste une requête SELECT ou UPDATE sans nom de colonne. Sérieusement. Comme avec SELECT et UPDATE , la clause WHERE reste la même : elle sélectionne les lignes à supprimer. L'opération de suppression détruit la ligne entière, il n'est donc pas logique de spécifier des colonnes individuelles. Donc, si nous décidons de ne pas réinitialiser le nombre de livres de Dan Brown, mais de supprimer toutes les entrées en général, alors nous pouvons faire une demande comme celle-ci :

DELETE FROM livres WHERE author="Dan Brown";

7.3 Insérer

Peut-être que la seule chose qui diffère des autres types de requêtes est INSERT . Le format est :

INSÉRER DANS x(a,b,c) VALEURS(x, y, z);

Où a , b , c sont les noms de colonne et x , y et z sont les valeurs à insérer dans ces colonnes, dans cet ordre. C'est fondamentalement ça.

Prenons un exemple précis. Voici une requête INSERT qui remplit toute la table "books":

INSERT INTO books (bookid,title,author,published,stock) VALUES (1,"Scion of Ikshvaku","Amish Tripathi","06-22-2015",2), (2,"The Lost Symbol"," Dan Brown","22-07-2010",3), (3,"Qui pleurera quand tu mourras ?","Robin Sharma","15-06-2006",4), (4,"Inferno" ,"Dan Brown","05-05-2014",3), (5,"Nos étoiles contraires","John Green","01-03-2015",3);

8. Vérification

Nous sommes arrivés au bout, je vous propose un petit test. Regardez cette demande au tout début de l'article. Pouvez-vous le comprendre? Essayez de le décomposer en sections SELECT , FROM , WHERE , GROUP BY et examinez les composants individuels de la sous-requête.

La voici sous une forme plus lisible :

SELECT membres.prénom || " " || membres.lastname AS "Nom complet" FROM emprunts INNER JOIN membres ON membres.memberid=emprunts.memberid INNER JOIN livres ON livres.bookid=emprunts.bookid WHERE emprunts.bookid IN (SELECT bookid FROM livres WHERE stock> (SELECT avg(stock ) FROM livres)) GROUP BY membres.prénom, membres.nom;

Cette requête renvoie une liste de personnes qui ont emprunté un livre à la bibliothèque dont le total est supérieur à la moyenne.

Résultat:

Nom et prénom
Linda Tyler

J'espère que vous avez réussi à vous en sortir sans problème. Mais si ce n'est pas le cas, je serai ravi de vos commentaires et de vos commentaires afin que je puisse améliorer ce post.

Balises : Ajouter des balises