MySQL Serie 4 SQL-Syntax

Tutorial-Reihe

MySQL-Reihe: Grundlegende Konzepte der relationalen MySQL-Datenbank
MariaDB-Serverinstallation der MySQL-Reihe
MySQL Series II-Konfiguration für mehrere Instanzen
MySQL Serie 3 Grundlagen
MySQL-Serie fünf Ansichten, gespeicherte Funktionen, gespeicherte Prozeduren, Trigger
MySQL Series 6-Benutzer und Autorisierung
MySQL Series 7 MySQL-Speicher-Engine
MySQL Serie 8 MySQL Server-Variablen
MySQL-Serie 9 MySQL-Abfrage-Cache und -Index
MySQL Series 10 MySQL-Transaktionsisolierung zur Implementierung der Parallelitätskontrolle
MySQL Series 11-Protokollierung
MySQL Serie 12 Backup und Wiederherstellung
MySQL Serie 13 MySQL-Replikation
MySQL Serie 14 MySQL Hochverfügbarkeitsimplementierung
MySQL-Serie 15: Allgemeine MySQL-Konfiguration und Leistungsstresstest

1. Einführung und Spezifikation der SQL-Sprache

​ ist eine spezielle Programmiersprache, die zur Verwaltung relationaler Datenbankmanagementsysteme (RDBMS) oder zur Stream-Verarbeitung in relationalen Stream-Datenmanagementsystemen (RDSMS) verwendet wird.

• In den 1970er Jahren entwickelte IBM SQL für DB2
• 1981 brachte IBM die SQL/DS-Datenbank auf den Markt
• Industriestandards: T-SQL von Microsoft und Sybase, PL/SQL von Oracle
• SQL, die von relationalen Datenbanken verwendete Standardsprache, wurde ursprünglich 1986 auf Grundlage der Implementierung von IBM genehmigt. Im Jahr 1987 übernahm die Internationale Organisation für Normung (ISO) ANSI-SQL (American National Standards Institute) als internationalen Standard.
• SQL: ANSI SQL – SQL-86, SQL-89, SQL-92, SQL-99, SQL-03
  

SQL-Sprachspezifikation

1. Im Datenbanksystem wird bei SQL-Anweisungen nicht zwischen Groß- und Kleinschreibung unterschieden (Großschreibung wird empfohlen).
2. Aber String-Konstanten sind case-sensitiv
3. SQL-Anweisungen können einzeilig oder mehrzeilig geschrieben werden und enden mit ";"
4. Schlüsselwörter dürfen nicht über mehrere Zeilen gehen oder abgekürzt werden.
5. Verwenden Sie Leerzeichen und Einrückungen, um die Lesbarkeit zu verbessern
6. Klauseln werden normalerweise in separate Zeilen eingefügt, um die Bearbeitung zu erleichtern und die Lesbarkeit zu verbessern.
7. Hinweise:

• SQL-Standard:
  • /*Kommentarinhalt*/ Mehrzeiliger Kommentar
  • -- Einzeiliger Kommentar, beachten Sie die Leerzeichen
• MySQL-Hinweise:
  

Namenskonventionen für Datenbankobjekte

- Muss mit einem Buchstaben beginnen
- Kann Zahlen und drei Sonderzeichen enthalten (# _ $)
- Verwenden Sie keine reservierten MySQL-Wörter
- Objekte in derselben Datenbank (Schema) können nicht denselben Namen haben

Klassifizierung von SQL-Anweisungen

DDL: Datendefinitionssprache

- ERSTELLEN, LÖSCHEN, ÄNDERN

DML: Datenmanipulationssprache

- EINFÜGEN, LÖSCHEN, AKTUALISIEREN

DCL: Datenkontrollsprache

- GEWÄHREN, WIDERRUF

DQL: Datenabfragesprache

-WÄHLEN

2. Datenbankbetrieb

1. Erstellen Sie eine Bibliothek

CREATE DATABASE [IF NOT EXISTS] db_name; Erstelle eine Datenbank

CHARACTER SET 'Zeichensatzname' Legt den Zeichensatztyp fest

COLLATE 'Sortierungsname' legt die Sortierung fest

Alle unterstützten Zeichensätze anzeigen: ZEICHENSATZ ANZEIGEN;

Alle unterstützten Sortierregeln anzeigen: SORTIMENT ANZEIGEN;

MariaDB [(keine)]> Datenbank erstellen, falls nicht vorhanden, testdb;

2. Löschen Sie die Bibliothek

Ich tu nicht

3. Datenbankliste anzeigen

DATENBANKEN ANZEIGEN;

3. Tabellenbedienung

1. Erstellen Sie eine Tabelle

Methode 1: Direkt erstellen
TABELLE ERSTELLEN [WENN NICHT VORHANDEN] tbl_name (create_definition,...)

MariaDB [testdb]> Tabelle erstellen, wenn nicht vorhanden. Studenten (ID TINYINT UNSIGNED AUTO_INCREMENT PRIMARY KEY, Name VARCHAR (30) NICHT NULL, Telefon CHAR (11), Geschlecht ENUM ('M', 'F')); 

Methode 2: Erstellen durch Abfragen einer vorhandenen Tabelle; die neue Tabelle wird direkt mit den Daten aus der Abfrage eingefügt

Tabelle erstellen [wenn nicht vorhanden] Tabellenname Auswahlanweisung

MariaDB [testdb]> CREATE TABLE-Benutzer SELECT Benutzer, Host, Passwort FROM mysql.user;

Wenn wir einfach die Abfrage der alten Tabelle nachahmen und eine Tabelle ohne Datensätze erstellen möchten, können wir die Bedingung WHERE 0=1; hinzufügen.

MariaDB [testdb]> CREATE TABLE user2 SELECT Benutzer, Host, Passwort FROM mysql.user WHERE 0=1;

Methode 3: Erstellen Sie eine Tabelle, indem Sie die Tabellenstruktur einer vorhandenen Tabelle kopieren, aber nicht die Daten kopieren

Tabelle erstellen [wenn nicht vorhanden] Tabellenname wie alter Tabellenname

MariaDB [testdb]> CREATE TABLE user3 LIKE mysql.user;

2. Ändern Sie die Tabelle

ALTER TABLE Tabellenname [Alterungsspezifikation [, Alterungsspezifikation] ...]

Attribut ADD hinzufügen

MariaDB [testdb]> ALTER TABLE students ADD age TINYINT AFTER name;

FALLEN

MariaDB [testdb]> ALTER TABLE students DROP phone;

ÄNDERN, MODIFIZIEREN

MariaDB [testdb]> ALTER TABLE Studenten CHANGE Alter Alter TINYINT (2) NOT NULL;

MariaDB [testdb]> ALTER TABLE students MODIFY gender ENUM('M','F');

3. Tabelle löschen

MariaDB [testdb]> DROP TABLE Benutzer3;

4. Tabelle anzeigen

TABELLEN ANZEIGEN; Alle Tabellen in der Bibliothek auflisten

DESC [db_name.]tb_name; Tabellenstruktur anzeigen

SHOW CREATE TABLE tbl_name; Zeigen Sie den Befehl zum Erstellen der Tabelle an

SHOW TABLE STATUS LIKE 'tbl_name'; Tabellenstatus anzeigen

SHOW TABLE STATUS FROM db_name; Zeigt den Status aller Tabellen in der angegebenen Datenbank an.

ENGINES ANZEIGEN; Alle Speicher-Engines anzeigen

4. DML: Datenmanipulationssprache

MariaDB [testdb]> DESC-Studenten; #Beispieltabelle+--------+---------------------+------+-----+---------+----------------+
| Feld | Typ | Null | Schlüssel | Standard | Extra |
+--------+---------------------+------+-----+---------+----------------+
| id | tinyint(3) unsigniert | NEIN | PRI | NULL | auto_increment |
| Name | varchar(30) | NEIN | | NULL | |
| Alter | tinyint(2) | NEIN | | NULL | |
| Geschlecht | Aufzählung('M','F') | JA | | NULL | |
+--------+---------------------+------+-----+---------+----------------+

1. INSERT fügt Daten ein

Einfügen eines einzelnen Datensatzes

INSERT INTO tb_name (Spalte1,Spalte2,...) WERTE (Wert1,Wert2,...);

MariaDB [testdb]> INSERT students(id,name,ages,gender) VALUES (1,'tom',26,'M');
MariaDB [testdb]> INSERT students(name,ages,gender) VALUES ('jerry',19,'M'); 
MariaDB [testdb]> INSERT students(name,ages,gender) VALUES ('maria',19,'M');
MariaDB [testdb]> INSERT students SET name='ouyangfeng',ages=56,gender='M';

Einfügen mehrerer Datensätze

INSERT INTO tb_name (col1,col2,...) VALUES (val1,val2,...)[,(val1,val2,...),...];

MariaDB [testdb]> INSERT students(name,ages,gender) VALUES ('xiaolongnv',18,'W'),('dongfangbubai',28,'W');

MariaDB [testdb]> SELECT * FROM students;
+----+--------------+------+--------+
| ID | Name | Alter | Geschlecht |
+----+--------------+------+--------+
| 1 | tom | 26 | M |
| 2 | Jerry | 19 | M |
| 3 | maria | 19 | M |
| 4 | xiaolongnv | 18 | F |
| 5 | dongfangbubai | 28 | F |
| 6 | ouyangfeng | 56 | M |
+----+--------------+------+--------+

Daten aus anderen Tabellen abfragen und in dieser Tabelle speichern

MariaDB [testdb]> ALTER TABLE students ADD address TEXT; #Fügen Sie ein Feld zum Testen hinzu

MariaDB [testdb]> INSERT students(name,adresse) SELECT user,host FROM mysql.user;

MariaDB [testdb]> SELECT * FROM students;
+----+---------------+------+--------+-----------+
| ID | Name | Alter | Geschlecht | Adresse |
+----+---------------+------+--------+-----------+
| 1 | tom | 26 | M | NULL |
| 2 | Jerry | 19 | M | NULL |
| 3 | maria | 19 | M | NULL |
| 4 | xiaolongnv | 18 | F | NULL |
| 5 | dongfangbubai | 28 | F | NULL |
| 6 | ouyangfeng | 56 | M | NULL |
| 7 | root | 0 | NULL | 127.0.0.1 |
| 8 | Wurzel | 0 | NULL | ::1 |
| 9 | | 0 | NULL | centos7 |
| 10 | root | 0 | NULL | centos7 |
| 11 | | 0 | NULL | lokaler Host |
| 12 | root | 0 | NULL | lokaler Host |
+----+---------------+------+--------+-----------+

2. UPDATE zum Ändern von Daten

UPDATE tbl_name SET col1=Wert1,col2=Wert2,... WHERE col=Wert;

MariaDB [testdb]> UPDATE Studenten SET Geschlecht = 'F' WHERE id = 3;

3. LÖSCHEN

MariaDB [testdb]> DELETE FROM students WHERE name=''; #Datensätze mit leeren Namen löschen MariaDB [testdb]> TRUNCATE TABLE user; #Datensätze der Situationstabelle

Hinweis: Es muss eine Einschränkung (WHERE | LIMIT) vorhanden sein, sonst werden die angegebenen Felder aller Zeilen geändert

5. SELECT: Datenabfrage

• AS: Alias
• WHERE: Gibt die Filterbedingungen an, um die Funktion „select“ zu erreichen
  • +, -, *, /, %: Arithmetische Operatoren
  • =, !=, <>, >, <, >=, <=: Vergleichsoperatoren
  • ZWISCHEN min_num UND max_num: zwischen min_num und max_mun
  • IN (Element1, Element2, ...): im Element ...
  • IS NULL: leer
  • IS NOT NULL: Nicht leer
  • LIKE: übereinstimmen, mögen. . .
    %: beliebiges Zeichen beliebiger Länge
    _: Ein einzelnes beliebiges Zeichen
  • RLIKE: Regulärer Ausdruck, nicht empfohlen
  • REGEXP: Wie oben
  • NOT, AND, OR, XOR: Logische Operatoren
• GROUP BY: Gruppieren Sie die Abfrageergebnisse nach den angegebenen Bedingungen für „Aggregations“-Operationen
  • AVG() Durchschnitt
  • MAX() Maximale Anzahl
  • MIN() Mindestanzahl
  • COUNT() Statistiken
  • SUMME()
  • HAVING: Gibt Filterbedingungen für die Ergebnisse von Gruppenaggregationsvorgängen an. Ähnlich wie WHERE, kann aber nur in Gruppen verwendet werden
• ORDER BY: Sortierung
  • ASC: positive Sequenz, Standard
  • DESC: Umgekehrte Reihenfolge
  • -SCHLÜSSELWORT: Durch das Hinzufügen von - vor dem Schlüsselwort beim Sortieren können Sie vermeiden, dass NULL am Anfang steht.
• LIMIT [[offset,]row_count]: Begrenzen Sie die Anzahl der Zeilen, die für Abfrageergebnisse ausgegeben werden
  

1. Auswahl

MariaDB [testdb]> SELECT * FROM students WHERE name='maria'; #Frage Marias Informationen abMariaDB [testdb]> SELECT * FROM students WHERE id BETWEEN 2 AND 5; #Frage die Informationen der Schüler von 2 bis 5 abMariaDB [testdb]> SELECT * FROM students WHERE name IN ('jerry','xiaolongnv'); #Frage die Informationen von Jerry und Xiaolongnv abMariaDB [testdb]> SELECT * FROM students WHERE gender IS NOT NULL; #Frage die Informationen ab, bei denen das Alter nicht leer istMariaDB [testdb]> SELECT * FROM students WHERE name LIKE '%o%'; #Frage die Informationen ab, bei denen der Name 'o' enthält

2. Projektion

MariaDB [testdb]> SELECT Benutzer ALS Benutzer, Host ALS Host, Passwort ALS Passwort FROM mysql.user;

3. Gruppierung

MariaDB [testdb]> SELECT gender,AVG(ages) FROM students GROUP BY gender; #Durchschnittsalter von Jungen und Mädchen abfragenMariaDB [testdb]> SELECT gender,AVG(ages) FROM students GROUP BY gender HAVING gender='M'; #Nur die Durchschnittsaltersinformationen von Jungen anzeigen

4. Sortieren

MariaDB [testdb]> SELECT * FROM students ORDER BY ages DESC; #Nach Alter sortieren, in umgekehrter Reihenfolge anzeigenMariaDB [testdb]> SELECT * FROM students WHERE ages > 0 ORDER BY ages LIMIT 3; #Nach Alter sortieren, diejenigen mit einem Alter größer als 0 herausfiltern, in aufsteigender Reihenfolge sortieren und die ersten drei Datensätze nehmen

6. Abfrage mehrerer Tabellen

Der Übung halber erweitern wir die Tabelle

MariaDB [testdb]> LÖSCHEN VON Studenten, wobei die ID zwischen 7 und 12 liegt;
MariaDB [testdb]> CREATE TABLE-Score (ID TINYINT (2) UNSIGNED AUTO_INCREMENT PRIMARY KEY, Score TINYINT (3));
MariaDB [testdb]> ALTER TABLE students ADD sid TINYINT(2); 
MariaDB [testdb]> UPDATE Studenten SET sid=6 WHERE id=6;
MariaDB [testdb]> INSERT score SET score=87;
MariaDB [testdb]> SELECT * FROM students;
+----+--------------+------+--------+---------+---------+------+
| ID | Name | Alter | Geschlecht | Adresse | Seite |
+----+--------------+------+--------+---------+---------+------+
| 1 | tom | 26 | M | NULL | 1 |
| 2 | Jerry | 19 | M | NULL | 2 |
| 3 | maria | 19 | F | NULL | 3 |
| 4 | xiaolongnv | 18 | F | NULL | 4 |
| 5 | dongfangbubai | 28 | F | NULL | 5 |
| 6 | ouyangfeng | 56 | M | NULL | 6 |
+----+--------------+------+--------+---------+---------+------+
MariaDB [testdb]> AUSWÄHLEN * FROM Punktzahl;   
+----+--------+
| ID | Punktzahl |
+----+--------+
| 1 | 99 |
| 2 | 98 |
| 3 | 88 |
| 4 | 68 |
| 5 | 78 |
| 6 | 87 |
+----+--------+

BEITRETEN AUF: Cross Join

INNER JOIN ON: Innerer Join

LEFT OUTER JOIN ON: Linker äußerer Join

RECHTER ÄUSSERER JOIN EIN: Rechter äußerer Join

UNION ON: Vollständiger äußerer Join

MariaDB [testdb]> SELECT * FROM students AS s,score AS o WHERE s.sid=o.id; #Schnittmenge zweier Tabellen

1. Querverbindung

MariaDB [testdb]> SELECT * FROM students JOIN score;

2. Innerer Join

MariaDB [testdb]> SELECT t.name,s.score FROM Studenten AS t INNER JOIN Punktzahl AS s ON t.sid=s.id;
+---------------+-------+
| Name | Punktzahl |
+---------------+-------+
| tom | 99 |
| Jerry | 98 |
| maria | 88 |
| xiaolongnv | 68 |
| dongfangbubai | 78 |
| 87 |
+---------------+-------+

3. Äußerer Join

MariaDB [testdb]> SELECT t.name,s.score FROM students AS t LEFT JOIN score AS s ON t.sid=s.id; #Linker äußerer Join +---------------+-------+
| Name | Punktzahl |
+---------------+-------+
| tom | 99 |
| Jerry | 98 |
| maria | 88 |
| xiaolongnv | 68 |
| dongfangbubai | 78 |
| 87 |
+---------------+-------+

MariaDB [testdb]> SELECT * FROM students AS t RIGHT JOIN score AS s ON t.sid=s.id; #Rechter äußerer Join

4. Vollständiger äußerer Join

MariaDB [testdb]> SELECT Name, Adresse FROM Studenten
    -> UNION
    -> WÄHLEN Sie Benutzer, Host AUS mysql.user;
+---------------+-----------+
| Name | Adresse |
+---------------+-----------+
| tom | NULL |
| Jerry | NULL |
| maria | NULL |
| xiaolongnv | NULL |
| dongfangbubai | NULL |
| ouyangfeng | NULL |
| Wurzel | 127.0.0.1 |
| Wurzel | ::1 |
| | centos7 |
| Wurzel | centos7 |
| | lokaler Host |
| Stammverzeichnis | lokaler Host |
+---------------+-----------+

5. Selbstverbindung

MariaDB [testdb]> ALTER TABLE students ADD tid TINYINT(2); #Ein weiteres Tid-Feld hinzufügenMariaDB [testdb]> SELECT * FROM students;
+----+--------------+------+--------+---------+---------+------+------+
| ID | Name | Alter | Geschlecht | Adresse | SID | TID |
+----+--------------+------+--------+---------+---------+------+------+
| 1 | tom | 26 | M | NULL | 1 | 2 |
| 2 | Jerry | 19 | M | NULL | 2 | 1 |
| 3 | maria | 19 | F | NULL | 3 | 4 |
| 4 | xiaolongnv | 18 | F | NULL | 4 | 5 |
| 5 | dongfangbubai | 28 | F | NULL | 5 | 4 |
| 6 | ouyangfeng | 56 | M | NULL | 6 | 4 |
+----+--------------+------+--------+---------+---------+------+------+

MariaDB [testdb]> SELECT s1.name AS studentname, s2.name AS teachername FROM students AS s1 INNER JOIN students AS s2 ON s1.id=s2.tid;
+---------------+---------------+
| Schülername | Lehrername |
+---------------+---------------+
| Jerry | Tom |
| Tom | Jerry |
| xiaolongnv | maria |
| dongfangbubai | xiaolongnv |
| xiaolongnv | dongfangbubai |
| xiaolongnv | ouyangfeng |
+---------------+---------------+

7. Unterabfrage

Unterabfrage: Eine Abfrageanweisung ist in einer Abfrageanweisung verschachtelt. Die Leistung ist schlecht und es handelt sich um eine Abfrage, die auf dem Abfrageergebnis einer bestimmten Anweisung basiert.

1. In der WHERE-Klausel verwendete Unterabfragen

Wird für Unterabfragen in Vergleichsausdrücken verwendet; Unterabfragen können nur einen einzelnen Wert zurückgeben

MariaDB [testdb]> SELECT name, ages FROM students WHERE ages > (SELECT AVG(ages) FROM students); #Frage Studenten ab, die älter als das Durchschnittsalter sind

In IN verwendete Unterabfragen: Die Unterabfrage sollte eine Einzelschlüsselabfrage sein und einen oder mehrere Werte aus der Liste der Komponenten zurückgeben

2. Unterabfragen in der FROM-Klausel

SELECT tb_alias.col1, ... FROM (SELECT-Klausel) AS tb_alias WHERE-Klausel;

8. Datentypen

Die Wahl des richtigen Datentyps ist für eine hohe Leistung von entscheidender Bedeutung. Dabei gelten drei Grundsätze:

• Kleiner ist normalerweise besser; versuchen Sie, den kleinsten Datentyp zu verwenden, der die Daten korrekt speichern kann.
• Halten Sie es einfach. Operationen an einfachen Datentypen erfordern normalerweise weniger CPU-Zyklen.
• Versuchen Sie, NULL zu vermeiden. Spalten, die NULL enthalten, sind für MySQL schwieriger zu optimieren.
  

1. Numerischer Typ

Genauer Wert

• INT
  • TINYINT Mikroplastische Chirurgie 1
  • SMALLINT Kleine Ganzzahl 2
  • MEDIUMINT Mittlere Ganzzahl 3
  • INT Ganzzahl 4
  • BIGINT Große Ganzzahl 8
• DECIMAL exakter Punkttyp

Ungefähre Werte

• FLOAT Gleitkommazahl mit einfacher Genauigkeit Typ4
• DOUBLE Gleitkommazahl mit doppelter Genauigkeit Typ 8
• REAL
• BISSCHEN

2. Zeichentyp

Feste Länge

- CHAR (ohne Berücksichtigung der Groß-/Kleinschreibung) 255

- BINÄR (Groß-/Kleinschreibung beachten)

Verlängerung

• VARCHAR (ohne Berücksichtigung der Groß-/Kleinschreibung) 65.535
• VARBINNARY (Groß-/Kleinschreibung beachten)

TEXT (ohne Berücksichtigung der Groß-/Kleinschreibung)

• TINYTEXT 255
• TEXT 65.535
• MITTELTEXT 16.777.215
• LANGTEXT 4.294.967.295

BLOB (Groß-/Kleinschreibung beachten)

• TINYBLOB Mikro-Binär-Großobjekt 255
• BLOB Binäres großes Objekt 64K
• MEDIUMBLOB Mittleres binäres großes Objekt 16M
• LONGBLOB Langes binäres großes Objekt 4G

ENUM-Aufzählung 65535 Variationen

SET setzt 1-64 Saiten, die beliebig kombiniert werden können

3. Datums- und Uhrzeittyp

• DATUM 3
• ZEIT 3
• DATUMZEIT 8
• ZEITSTEMPEL 4
• JAHR{2|4} 1

4. Boolesche Werte

• BOOL, BOOLEAN: Boolescher Typ, ein Synonym für TINYINT(1). Ein Wert von Null wird als falsch betrachtet. Werte ungleich Null werden als wahr betrachtet.
  

Siehe die offizielle Dokumentation: https://dev.mysql.com/doc/refman/5.5/en/data-types.html

Zusammenfassen

Dies ist das Ende dieses Artikels über SQL-Syntax. Weitere relevante Inhalte zur SQL-Syntax finden Sie in früheren Artikeln auf 123WORDPRESS.COM oder in den folgenden verwandten Artikeln. Ich hoffe, dass jeder 123WORDPRESS.COM in Zukunft unterstützen wird!