Fondamentaux de SQL | Instruction SELECT | Gestion de base de données

Introduction

L'instruction SELECT, l'une des instructions les plus couramment utilisées en SQL, est utilisée pour sélectionner des données dans une table. Ce laboratoire apprendra SELECT et comment l'appliquer à des pratiques réelles.

Objectif d'apprentissage

• SELECT Syntaxe de base
• Conditions des symboles mathématiques
• ET OU DANS
• Caractères génériques
• Trier
• Fonctions et calculs intégrés SQL
• Requêtes sous-requêtes et jointures

Préparation

Avant de commencer, téléchargez les tables de données pertinentes et créez une base de données nommée mysql_labex (3 tables : département, employé, projet).

Démarrez le service MySQL et connectez-vous en tant que root.

cd ~/project
sudo service mysql start
mysql -u root

Il existe deux fichiers create-database.sql et insert-data.sql, qui se trouvent dans ~/project/.

Charger les données dans le fichier. Vous devez saisir la commande dans la console MySQL pour construire la base de données :

source ~/project/create-database.sql
source ~/project/insert-data.sql

Dans les instructions d'exploitation de la base de données, la requête la plus fréquemment utilisée, également considérée comme la plus importante, est la requête SELECT. Dans les ateliers précédents, nous avons utilisé SELECT * FROM table_name; déclarations à de nombreux endroits pour tout voir dans un tableau. SELECT peut être utilisé avec des mots-clés de diverses contraintes, qui englobent une variété de fonctionnalités. Ce laboratoire présentera ces utilisations en détail.

Instruction SELECT de base

Le format de base de l'instruction SELECT :

SELECT row name  FROM table name WHERE constraint;

Si vous souhaitez interroger tout le contenu de la table, alors interrogez le nom de la colonne avec un astérisque *, qui représente toutes les colonnes de la table qui seront interrogées. Dans la plupart des cas, nous avons uniquement besoin de voir la colonne spécifiée d'une table, par exemple pour voir le nom et l'âge de la table des employés :

USE mysql_labex;
SELECT name,age FROM employee;

MariaDB [mysql_labex]> SELECT name,age FROM employee;
+------+------+
| name | age  |
+------+------+
| Tom  |   26 |
| Jack |   24 |
| Rose |   22 |
| Jim  |   35 |
| Mary |   21 |
| Alex |   26 |
| Ken  |   27 |
| Rick |   24 |
| Joe  |   31 |
| Mike |   23 |
| Jobs | NULL |
| Tony | NULL |
+------+------+
12 rows in set (0.000 sec)

Conditions des symboles mathématiques

Les instructions SELECT ont souvent des contraintes WHERE, utilisées pour réaliser des requêtes plus précises. Les contraintes WHERE peuvent avoir une notation mathématique (=, <,>,>=, <=). Nous venons de demander le nom et l'âge, et apportons maintenant une légère modification :

SELECT name,age FROM employee WHERE age>25;




</p>
<p>Filtrer les résultats avec un âge supérieur à 25 :<br>
</p>

<pre class="brush:php;toolbar:false">MariaDB [mysql_labex]> SELECT name,age FROM employee WHERE age>25;
+------+------+
| name | age  |
+------+------+
| Tom  |   26 |
| Jim  |   35 |
| Alex |   26 |
| Ken  |   27 |
| Joe  |   31 |
+------+------+
5 rows in set (0.000 sec)

Ou recherchez le nom, l'âge et le téléphone d'une employée nommée Mary :

SELECT name,age,phone FROM employee WHERE name='Mary';

Résultat :

MariaDB [mysql_labex]> SELECT name,age,phone FROM employee WHERE name='Mary';
+------+------+--------+
| name | age  | phone  |
+------+------+--------+
| Mary |   21 | 100101 |
+------+------+--------+
1 row in set (0.000 sec)

"ET" et "OU"

Nous pouvons avoir plus d'une contrainte après WHERE, et en fonction de la relation logique de ces conditions, nous pouvons utiliser OR et AND pour connecter :

Filtre - l'âge est inférieur à 25 ans ou l'âge est supérieur à 30

SELECT name,age FROM employee WHERE age<25 OR age>30;

MariaDB [mysql_labex]> SELECT name,age FROM employee WHERE age<25 OR age>30;
+------+------+
| name | age  |
+------+------+
| Jack |   24 |
| Rose |   22 |
| Jim  |   35 |
| Mary |   21 |
| Rick |   24 |
| Joe  |   31 |
| Mike |   23 |
+------+------+
7 rows in set (0.000 sec)

Filtre - l'âge est supérieur à 25 ans et l'âge est inférieur à 30

SELECT name,age FROM employee WHERE age>25 AND age<30;

Si nous devons inclure les âges 25 et 30, utilisez âge ENTRE 25 ET 30 :

MariaDB [mysql_labex]> SELECT name,age FROM employee WHERE age>25 AND age<30;
+------+------+
| name | age  |
+------+------+
| Tom  |   26 |
| Alex |   26 |
| Ken  |   27 |
+------+------+
3 rows in set (0.000 sec)

MariaDB [mysql_labex]> SELECT name,age FROM employee WHERE age BETWEEN 25 AND 30;
+------+------+
| name | age  |
+------+------+
| Tom  |   26 |
| Alex |   26 |
| Ken  |   27 |
+------+------+
3 rows in set (0.000 sec)

DANS ET PAS DANS

Les

Mots clés IN ​​et NOT IN ​​sont utilisés pour filtrer les résultats dans une certaine plage. Par exemple, nous voulons trouver des personnes dans dpt3 ou dpt4 :

SELECT name,age,phone,in_dpt FROM employee WHERE in_dpt IN ('dpt3','dpt4');

Pour NOT IN, comme dans la commande suivante, nous obtiendrons les personnes qui ne sont pas dans dpt1 ni dans dpt3 :

SELECT name,age,phone,in_dpt FROM employee WHERE in_dpt NOT IN ('dpt1','dpt3');

MariaDB [mysql_labex]> SELECT name,age,phone,in_dpt FROM employee WHERE in_dpt IN ('dpt3','dpt4');
+------+------+--------+--------+
| name | age  | phone  | in_dpt |
+------+------+--------+--------+
| Tom  |   26 | 119119 | dpt4   |
| Rose |   22 | 114114 | dpt3   |
| Rick |   24 | 987654 | dpt3   |
| Mike |   23 | 110110 | dpt4   |
| Tony | NULL | 102938 | dpt3   |
+------+------+--------+--------+
5 rows in set (0.000 sec)

MariaDB [mysql_labex]> SELECT name,age,phone,in_dpt FROM employee WHERE in_dpt NOT IN ('dpt1','dpt3');
+------+------+--------+--------+
| name | age  | phone  | in_dpt |
+------+------+--------+--------+
| Tom  |   26 | 119119 | dpt4   |
| Jack |   24 | 120120 | dpt2   |
| Mary |   21 | 100101 | dpt2   |
| Joe  |   31 | 110129 | dpt2   |
| Mike |   23 | 110110 | dpt4   |
| Jobs | NULL |  19283 | dpt2   |
+------+------+--------+--------+
6 rows in set (0.000 sec)

Caractères génériques

Le mot-clé LIKE est utilisé avec des caractères génériques dans les instructions SQL, les caractères génériques représentant des caractères inconnus. Les caractères génériques dans SQL sont _ et %. Lequel _ représente un caractère non spécifié, %représente indéfini des caractères non spécifiés.

Par exemple, si vous vous souvenez seulement que les quatre premiers chiffres du numéro de téléphone sont 1101 et que les deux derniers chiffres sont oubliés, vous pouvez les remplacer par deux _ jokers :

SELECT name,age,phone FROM employee WHERE phone LIKE '1101__';

et ici nous avons des numéros de téléphone commençant par 1101 :

MariaDB [mysql_labex]> SELECT name,age,phone FROM employee WHERE phone LIKE '1101__';
+------+------+--------+
| name | age  | phone  |
+------+------+--------+
| Joe  |   31 | 110129 |
| Mike |   23 | 110110 |
+------+------+--------+
2 rows in set (0.000 sec)

Dans un autre cas, par exemple lorsque vous ne vous souvenez que de la première lettre du nom et que vous ne connaissez pas la longueur du nom, utilisez le caractère générique % au lieu de caractères indéfinis :

SELECT name,age,phone FROM employee WHERE name LIKE 'J%';

Ici, nous avons des noms commençant par J :

MariaDB [mysql_labex]> SELECT name,age,phone FROM employee WHERE name LIKE 'J%';
+------+------+--------+
| name | age  | phone  |
+------+------+--------+
| Jack |   24 | 120120 |
| Jim  |   35 | 100861 |
| Joe  |   31 | 110129 |
| Jobs | NULL |  19283 |
+------+------+--------+
4 rows in set (0.000 sec)

Triez vos résultats

Afin de rendre les résultats interrogés plus organisés et plus faciles à suivre, nous devrons peut-être les trier selon certaines règles. ORDER BY est pratique. Par défaut, ORDER BY est en ordre croissant, et en utilisant ASC et DESC, nous pouvons également obtenir des résultats en ordre croissant et décroissant commande.

Par exemple, on trie le salaire par ordre décroissant, instruction SQL :

SELECT name,age,salary,phone FROM employee ORDER BY salary DESC;

MariaDB [mysql_labex]> SELECT name,age,salary,phone FROM employee ORDER BY salary DESC;
+------+------+--------+--------+
| name | age  | salary | phone  |
+------+------+--------+--------+
| Jobs | NULL |   3600 |  19283 |
| Joe  |   31 |   3600 | 110129 |
| Ken  |   27 |   3500 | 654321 |
| Rick |   24 |   3500 | 987654 |
| Mike |   23 |   3400 | 110110 |
| Tony | NULL |   3400 | 102938 |
| Alex |   26 |   3000 | 123456 |
| Mary |   21 |   3000 | 100101 |
| Jim  |   35 |   3000 | 100861 |
| Rose |   22 |   2800 | 114114 |
| Jack |   24 |   2500 | 120120 |
| Tom  |   26 |   2500 | 119119 |
+------+------+--------+--------+
12 rows in set (0.000 sec)

Fonctions et calculs intégrés SQL

SQL permet le calcul des données dans le tableau. À cet égard, SQL dispose de cinq fonctions intégrées qui font le résultat de SELECT :

Function:	COUNT	SUM	AVG	MAX	MIN
For:	count numbers	sum up	average	maximum value	minimum value

The COUNT function can be used for any data type (because it is only a count), while SUM and AVG functions can only calculate numeric data types. MAX and MIN can be used for numeric, string, or datetime data types.

For example, when we want to calculate the maximum and minimum value of salary, we use a statement like this:

SELECT MAX(salary) AS max_salary,MIN(salary) FROM employee;

You may have noticed a tiny detail. Use AS keyword can rename value. E.g. Max value is renamed into max_salary:

MariaDB [mysql_labex]> SELECT MAX(salary) AS max_salary,MIN(salary) FROM employee;
+------------+-------------+
| max_salary | MIN(salary) |
+------------+-------------+
|       3600 |        2500 |
+------------+-------------+
1 row in set (0.000 sec)

Subqueries

The SELECT statements discussed above all involve data in only one table, but sometimes you have to process multiple tables to get the information you need. For example, you want to know a few projects done by the department where the employee named "Tom" is located. Employee information is stored in the employee table, but the project information is stored in the project table.

We can use subqueries to deal with such situations:

SELECT of_dpt,COUNT(proj_name) AS count_project FROM project
WHERE of_dpt IN
(SELECT in_dpt FROM employee WHERE name='Tom');

MariaDB [mysql_labex]> SELECT of_dpt,COUNT(proj_name) AS count_project FROM project
    -> WHERE of_dpt IN
    -> (SELECT in_dpt FROM employee WHERE name='Tom');
+--------+---------------+
| of_dpt | count_project |
+--------+---------------+
| dpt4   |             2 |
+--------+---------------+
1 row in set (0.000 sec)

Subqueries can also be extended to three, four or more layers.

Join

When dealing with multiple tables, the subquery is only useful when the results are from the same table. However, if you need to display data in two or more tables, you must use the join operation.

The basic idea is to connect two or more tables as a new table to operate, as follows:

SELECT id,name,people_num
FROM employee,department
WHERE employee.in_dpt = department.dpt_name
ORDER BY id;

This result is the number of employees in each department, where employee id and name from the employee table, people_num from the department table:

MariaDB [mysql_labex]> SELECT id,name,people_num
    -> FROM employee,department
    -> WHERE employee.in_dpt = department.dpt_name
    -> ORDER BY id;
+----+------+------------+
| id | name | people_num |
+----+------+------------+
|  1 | Tom  |         15 |
|  2 | Jack |         12 |
|  3 | Rose |         10 |
|  4 | Jim  |         11 |
|  5 | Mary |         12 |
|  6 | Alex |         11 |
|  7 | Ken  |         11 |
|  8 | Rick |         10 |
|  9 | Joe  |         12 |
| 10 | Mike |         15 |
| 11 | Jobs |         12 |
| 12 | Tony |         10 |
+----+------+------------+
12 rows in set (0.000 sec)

Another connection statement format is to use the JOIN ON syntax. The statement is the same as:

SELECT id,name,people_num
FROM employee JOIN department
ON employee.in_dpt = department.dpt_name
ORDER BY id;

Result is the same.

Summary

In this lab we learned the basic use of SELECT statement:

• Basic syntax
• Mathmatical symbol conditions
• AND OR IN
• Wildcards
• Sort
• SQL built-in functions and calculations
• Sunqueries and connection queries

---

? Practice Now: SQL's SELECT Statement

---

Want to Learn More?

• ? Learn the latest MySQL Skill Trees
• ? Read More MySQL Tutorials
• ? Join our Discord or tweet us @WeAreLabEx

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!