SQL-Grundlagen | SELECT-Anweisung | Datenbankverwaltung

Einführung

SELECT-Anweisung, eine der am häufigsten verwendeten Anweisungen in SQL, wird zum Auswählen von Daten in einer Tabelle verwendet. In diesem Labor lernen Sie SELECT und wie man es auf reale Praktiken anwendet.

Lernziel

• SELECT Grundlegende Syntax
• Mathematische Symbolbedingungen
• UND ODER IN
• Platzhalter
• Sortieren
• In SQL integrierte Funktionen und Berechnungen
• Unterabfragen und Join-Abfragen

Vorbereitung

Bevor wir beginnen, laden Sie relevante Datentabellen herunter und erstellen Sie eine Datenbank mit dem Namen mysql_labex (3 Tabellen: Abteilung, Mitarbeiter, Projekt).

Starten Sie den MySQL-Dienst und melden Sie sich als Root an.

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

Es gibt zwei Dateien create-database.sql und insert-data.sql, die sich in ~/project/.

Daten in die Datei laden. Sie müssen den Befehl in der MySQL-Konsole eingeben, um die Datenbank zu erstellen:

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

In Datenbankbetriebsanweisungen wird am häufigsten die SELECT-Abfrage verwendet und auch als die wichtigste angesehen. In früheren Übungen haben wir SELECT * FROM table_name; Anweisungen an vielen Stellen, um alles in einer Tabelle zu sehen. SELECT kann mit Schlüsselwörtern verschiedener Einschränkungen verwendet werden, die eine Vielzahl von Funktionen umfassen. In diesem Labor werden diese Verwendungsmöglichkeiten im Detail vorgestellt.

Grundlegende SELECT-Anweisung

Das Grundformat der SELECT-Anweisung:

SELECT row name  FROM table name WHERE constraint;

Wenn Sie den gesamten Inhalt der Tabelle abfragen möchten, fragen Sie den Namen der Spalte mit einem Sternchen * ab, das bedeutet, dass alle Spalten in der Tabelle abgefragt werden. In den meisten Fällen müssen wir nur die angegebene Spalte einer Tabelle sehen, beispielsweise um den Namen und das Alter der Mitarbeitertabelle zu sehen:

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)

Mathematische Symbolbedingungen

SELECT-Anweisungen haben oft WHERE-Einschränkungen, die verwendet werden, um genauere Abfragen zu erreichen. WHERE-Einschränkungen können eine mathematische Notation haben (=, <,>,>=, <=). Wir haben gerade den Namen und das Alter abgefragt und nehmen nun eine kleine Änderung vor:

SELECT name,age FROM employee WHERE age>25;




</p>
<p>Ergebnisse nach Alter über 25 Jahren filtern:<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)

Oder finden Sie den Namen, das Alter und die Telefonnummer einer Mitarbeiterin namens Mary:

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

Ergebnis:

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)

„UND“ und „ODER“

Wir können mehr als eine Einschränkung nach WHERE haben, und basierend auf der logischen Beziehung dieser Bedingungen können wir OR und AND verwenden, um Folgendes zu verbinden:

Filter – Alter ist unter 25 oder Alter ist über 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)

Filter – Alter ist größer als 25 und Alter ist kleiner als 30

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

Wenn wir das Alter 25 und 30 einbeziehen müssen, verwenden Sie Alter ZWISCHEN 25 UND 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)

IN & NICHT IN

Die Schlüsselwörter IN ​​und NOT IN ​​werden verwendet, um Ergebnisse in einem bestimmten Bereich zu filtern. Beispielsweise möchten wir Personen in dpt3 oder dpt4:
finden

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

Für NOT IN, wie im folgenden Befehl, erhalten wir Personen, die nicht in dpt1 oder dpt3 sind:

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)

Platzhalter

Das Schlüsselwort LIKE wird mit Platzhaltern in SQL-Anweisungen verwendet, wobei Platzhalter unbekannte Zeichen darstellen. Platzhalter in SQL sind _ und %. Wobei _ ein nicht spezifiziertes Zeichen darstellt, % stellt unbestimmte nicht spezifizierte Zeichen dar.

Wenn Sie sich beispielsweise nur daran erinnern, dass die ersten vier Ziffern der Telefonnummer 1101 sind und die letzten beiden Ziffern vergessen sind, können Sie sie durch zwei _-Platzhalter ersetzen:

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

und hier haben wir Telefonnummern, die mit 1101 beginnen:

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)

In einem anderen Fall, beispielsweise wenn Sie sich nur an den ersten Buchstaben des Namens erinnern und die Länge des Namens nicht kennen, verwenden Sie den Platzhalter % anstelle unbestimmter Zeichen:

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

Hier haben wir Namen, die mit J:
beginnen

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)

Sortieren Sie Ihre Ergebnisse

Um die abgefragten Ergebnisse übersichtlicher und leichter verständlich zu gestalten, müssen wir sie möglicherweise nach bestimmten Regeln sortieren. ORDER BY ist praktisch. Standardmäßig ist ORDER BY in der aufsteigenden-Anordnung, und durch die Verwendung von ASC und DESC können wir auch Ergebnisse in aufsteigender und absteigender Reihenfolge erhalten bestellen.

Zum Beispiel sortieren wir das Gehalt in absteigender Reihenfolge, SQL-Anweisung:

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)

Integrierte SQL-Funktionen und -Berechnungen

SQL ermöglicht die Berechnung der Daten in der Tabelle. In dieser Hinsicht verfügt SQL über fünf integrierte Funktionen, die das Ergebnis von SELECT:

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

Das obige ist der detaillierte Inhalt vonSQL-Grundlagen | SELECT-Anweisung | Datenbankverwaltung. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!