Zusammenfassung der für MySQL erforderlichen allgemeinen Kenntnisse

Inhaltsverzeichnis

Primärschlüsseleinschränkung
Eindeutiger Primärschlüssel
Nicht Null-Einschränkung
Standardeinschränkungen
Fremdschlüsseleinschränkungen
1NF
2NF
3NF
Vorbereiten der Daten
1 bis 10
Berechnen Sie die durchschnittlichen Punktzahlen nach Gruppen
Gruppierungsbedingungen und Fuzzy-Abfragen
Abfrage mehrerer Tabellen - 1
Abfrage mehrerer Tabellen - 2
Abfrage der Drei-Tabellen-Assoziation
Unterabfrage plus Gruppierung zur Ermittlung der Durchschnittspunktzahl
Unterabfrage - 1
Unterabfrage - 2
YEAR-Funktion und Abfrage mit IN-Schlüsselwort
Mehrstufig verschachtelte Unterabfragen
Abfrage mehrerer Tabellen
Unterabfrage - 3
Verwendung von UNION und NOTIN
ANY bedeutet mindestens eins - DESC (absteigende Reihenfolge)
ALLE
Kopieren der Tabellendaten als bedingte Abfrage
Unterabfrage - 4
Bedingte Gruppenfilterung
NOTLIKE Fuzzy-Abfrage-Negation
YEAR- und NOW-Funktionen
MAX- und MIN-Funktionen
Sortierung mehrerer Segmente
Unterabfrage - 5
MAX-Funktion mit Unterabfragen
Unterabfrage - 6
Unterabfrage - 7
Unterabfrage - 8
Suche nach Level
Verbindungsabfrage

Innerer Join
Linker äußerer Join
Rechtes äußeres Glied
Vollständige externe Links

So steuern Sie Transaktionen - COMMIT / ROLLBACK

Eine Transaktion manuell starten - BEGIN / START TRANSACTION

ACID-Eigenschaften und Verwendung von Transaktionen

Transaktionsisolierung

Schmutzige Lektüre
Lesen Sie Commitment
Phantom lesen
Serialisierung

Dieser Artikel fasst die erforderlichen allgemeinen Kenntnisse zu MySQL zusammen. Teilen Sie uns die Einzelheiten zu Ihrer Information mit:

Als ich kürzlich SQL organisierte, fand ich eine hervorragende Notiz. Es war die Notiz, die der ursprüngliche Autor beim Erlernen von SQL gemacht hatte. Ich möchte diese Zusammenfassung mit allen teilen. Sie kann jedem dabei helfen, eine umfassende Leckerkennung und Fehlerbehebung für SQL durchzuführen. Vielen Dank an den ursprünglichen Autor hjzCy für seine Bemühungen. Der ursprüngliche Link befindet sich am Ende des Artikels. Wenn es Fehler gibt, hoffe ich, dass jeder gemeinsam darauf hinweisen kann!

An- und Abmelden beim MySQL-Server

# Melden Sie sich bei MySQL an
$ mysql -u root -p12345612

# MySQL-Datenbankserver beenden exit;

Grundlegende Syntax

--Alle Datenbanken anzeigen Datenbanken anzeigen;

- Erstellen Sie eine Datenbank. CREATE DATABASE-Test;

-- Test der Verwendung der Switch-Datenbank;

-- Alle Tabellen in der Datenbank anzeigen. Tabellen anzeigen;

-- Erstellen Sie eine Datentabelle CREATE TABLE pet (
  Name VARCHAR(20),
  Besitzer VARCHAR(20),
  Art VARCHAR(20),
  Geschlecht CHAR(1),
  Geburtsdatum,
  Todesdatum
);

-- Datentabellenstruktur anzeigen -- Haustier beschreiben;
Beschreibung Haustier;

-- Abfragetabelle SELECT * from pet;

-- Daten einfügen INSERT INTO pet VALUES ('puffball', 'Diane', 'hamster', 'f', '1990-03-30', NULL);

-- Daten ändern UPDATE pet SET name = ‚squirrel‘ where owner = ‚Diane‘;

-- Daten löschen DELETE FROM pet, wobei Name = ‚Eichhörnchen‘;

--Tabelle löschen DROP TABLE myorder;

Einschränkungen bei der Tabellenerstellung

Primärschlüsseleinschränkung

-- Primärschlüsseleinschränkung -- Macht ein Feld nicht wiederholt und nicht leer, wodurch die Eindeutigkeit aller Daten in der Tabelle sichergestellt wird.
CREATE TABLE-Benutzer (
  ID INT Primärschlüssel,
  Name VARCHAR(20)
);

-- Gemeinsamer Primärschlüssel -- Jedes Feld im gemeinsamen Primärschlüssel darf nicht leer sein, und die Summe der Felder darf nicht mit dem festgelegten gemeinsamen Primärschlüssel übereinstimmen.
CREATE TABLE-Benutzer (
  Ich würde INT,
  Name VARCHAR(20),
  Passwort VARCHAR(20),
  PRIMÄRSCHLÜSSEL(ID, Name)
);

-- Auto-Increment-Einschränkung -- Der Primärschlüssel der Auto-Increment-Einschränkung wird automatisch vom System zugewiesen.
CREATE TABLE-Benutzer (
  Ich würde INT PRIMARY KEY AUTO_INCREMENT,
  Name VARCHAR(20)
);

-- Primärschlüsseleinschränkung hinzufügen -- Wenn Sie vergessen, den Primärschlüssel festzulegen, können Sie ihn auch über SQL-Anweisungen festlegen (zwei Möglichkeiten):
ALTER TABLE-Benutzer ADD PRIMARY KEY(id);
ALTER TABLE-Benutzer MODIFY-ID INT PRIMARY KEY;

- Löschen Sie den Primärschlüssel ALTER TABLE user drop PRIMARY KEY;

Eindeutiger Primärschlüssel

-- Erstellen Sie beim Erstellen einer Tabelle einen eindeutigen Primärschlüssel CREATE TABLE user (
  Ich würde INT,
  Name VARCHAR(20),
  EINZIGARTIG(Name)
);

-- Fügen Sie einen eindeutigen Primärschlüssel hinzu -- Wenn Sie beim Erstellen der Tabelle keinen eindeutigen Schlüssel festgelegt haben, können Sie ihn auch über SQL-Anweisungen festlegen (zwei Möglichkeiten):
ALTER TABLE-Benutzer ADD UNIQUE(Name);
ALTER TABLE Benutzer MODIFY Name VARCHAR (20) UNIQUE;

- Löschen Sie den eindeutigen Primärschlüssel ALTER TABLE user DROP INDEX name;

Nicht Null-Einschränkung

-- Fügen Sie beim Erstellen einer Tabelle eine Nicht-Null-Einschränkung hinzu -- beschränken Sie ein Feld darauf, nicht NULL zu sein. CREATE TABLE user (
  Ich würde INT,
  Name VARCHAR (20) NICHT NULL
);

- Entfernen Sie die Nicht-Null-Einschränkung ALTER TABLE user MODIFY name VARCHAR(20);

Standardeinschränkungen

-- Fügen Sie beim Erstellen einer Tabelle eine Standardeinschränkung hinzu -- Beschränken Sie den Standardwert eines Felds CREATE TABLE user2 (
  Ich würde INT,
  Name VARCHAR(20),
  Alter INT DEFAULT 10
);

- Entfernen Sie die Nicht-Null-Einschränkung ALTER TABLE user MODIFY age INT;

Fremdschlüsseleinschränkungen

-- Klasse CREATE TABLE-Klassen (
  ID INT Primärschlüssel,
  Name VARCHAR(20)
);

-- Studententabelle CREATE TABLE students (
  ID INT Primärschlüssel,
  Name VARCHAR(20),
  -- Die class_id sollte hier mit dem ID-Feld in den Klassen class_id INT verknüpft werden,
  -- Gibt an, dass der Wert von class_id aus dem ID-Feldwert in den Klassen FOREIGN KEY(class_id) REFERENCES classes(id) stammen muss.
);

- 1. Datenwerte, die nicht in der Haupttabelle (übergeordnete Tabelle) „Klassen“ enthalten sind, können nicht in der sekundären Tabelle (untergeordnete Tabelle) „Studenten“ verwendet werden.
- 2. Wenn auf die Datensätze in der Primärtabelle von der Sekundärtabelle verwiesen wird, kann die Primärtabelle nicht gelöscht werden.

Drei große Datenbank-Design-Paradigmen

1NF

Sofern der Feldwert weiter zerlegt werden kann, ist die erste Normalform nicht erfüllt.

Je detaillierter das Paradigmendesign ist, desto besser kann es für bestimmte praktische Vorgänge sein, es ist jedoch nicht immer von Vorteil und muss entsprechend der tatsächlichen Situation des Projekts festgelegt werden.

2NF

Unter der Voraussetzung, dass das erste Paradigma erfüllt ist, müssen andere Spalten vollständig von der Primärschlüsselspalte abhängig sein. Wenn eine unvollständige Abhängigkeit vorliegt, kann dies nur bei einem zusammengesetzten Primärschlüssel passieren:

-- Auftragstabelle CREATE TABLE myorder (
  Produkt-ID INT,
  Kunden-ID INT,
  Produktname VARCHAR (20),
  Kundenname VARCHAR(20),
  PRIMÄRSCHLÜSSEL (Produkt-ID, Kunden-ID)
);

Tatsächlich hängt in dieser Bestelltabelle product_name nur von product_id customer_name nur von customer_id ab. Mit anderen Worten: product_name und customer_id sind irrelevant, und customer_name und product_id sind ebenfalls irrelevant.

Dies erfüllt nicht die zweite Normalform: Alle anderen Spalten müssen vollständig von der Primärschlüsselspalte abhängig sein!

CREATE TABLE meine Bestellung (
  order_id INT Primärschlüssel,
  Produkt-ID INT,
  Kunden-ID INT
);

CREATE TABLE Produkt (
  ID INT Primärschlüssel,
  Name VARCHAR(20)
);

CREATE TABLE Kunde (
  ID INT Primärschlüssel,
  Name VARCHAR(20)
);

Nach der Aufteilung sind product_id und customer_id in myorder vollständig vom Primärschlüssel order_id abhängig, und andere Felder in product und customer sind vollständig vom Primärschlüssel abhängig. Erfüllt das Design des zweiten Paradigmas!

3NF

Unter der Voraussetzung, dass das zweite Paradigma erfüllt wird, sollten keine transitiven Abhängigkeiten zwischen anderen Spalten als der Primärschlüsselspalte bestehen.

CREATE TABLE meine Bestellung (
  order_id INT Primärschlüssel,
  Produkt-ID INT,
  Kunden-ID INT,
  Kundentelefon VARCHAR(15)
);

customer_phone in der Tabelle kann von order_id und customer_id abhängen, was nicht dem Entwurf der dritten Normalform entspricht: Es kann keine transitiven Abhängigkeiten zwischen anderen Spalten geben.

CREATE TABLE meine Bestellung (
  order_id INT Primärschlüssel,
  Produkt-ID INT,
  Kunden-ID INT
);

CREATE TABLE Kunde (
  ID INT Primärschlüssel,
  Name VARCHAR(20),
  Telefon VARCHAR(15)
);

Nach der Änderung besteht keine transitive Abhängigkeit zwischen anderen Spalten. Andere Spalten hängen nur von der Primärschlüsselspalte ab, was dem Design der dritten Normalform entspricht!

Abfrageübung

Vorbereiten der Daten

- Erstellen Sie eine Datenbank CREATE DATABASE select_test;
-- Datenbank wechseln USE select_test;

-- Erstellen Sie eine Studententabelle CREATE TABLE student (
  kein VARCHAR(20) PRIMARY KEY,
  Name VARCHAR(20) NOT NULL,
  Geschlecht VARCHAR(10) NICHT NULL,
  Geburtstag DATE, -- Geburtstagsklasse VARCHAR(20) -- Klasse);

-- Erstellen Sie eine Lehrertabelle CREATE TABLE teacher (
  kein VARCHAR(20) PRIMARY KEY,
  Name VARCHAR(20) NOT NULL,
  Geschlecht VARCHAR(10) NICHT NULL,
  Geburtstagsdatum,
  Beruf VARCHAR(20) NOT NULL, -- Berufsbezeichnung Abteilung VARCHAR(20) NOT NULL -- Abteilung);

-- Erstellen Sie eine Kurstabelle CREATE TABLE course (
  kein VARCHAR(20) PRIMARY KEY,
  Name VARCHAR(20) NOT NULL,
  t_no VARCHAR(20) NOT NULL, -- Lehrernummer -- gibt an, dass tno vom Wert des Felds „no“ in der Lehrertabelle stammt FOREIGN KEY(t_no) REFERENCES teacher(no)
);

- Punktetabelle CREATE TABLE score (
  s_no VARCHAR(20) NOT NULL, -- Matrikelnummer c_no VARCHAR(20) NOT NULL, -- Kursnummer Grad DECIMAL, -- Note -- gibt an, dass s_no und c_no aus dem Feldwert „no“ in den Tabellen „Student“ bzw. „Course“ stammen. FOREIGN KEY(s_no) REFERENCES student(no),
  FOREIGN KEY(c_no) REFERENZEN Kurs(nr),
  -- Setze s_no, c_no als gemeinsamen Primärschlüssel PRIMARY KEY (s_no, c_no)
);

-- Alle Tabellen anzeigen TABELLEN ANZEIGEN;

-- Daten der Studententabelle hinzufügen INSERT INTO student VALUES('101', 'Zeng Hua', 'Männlich', '1977-09-01', '95033');
INSERT INTO student VALUES('102', 'Student', 'Student', '1975-10-02', '95031');
INSERT INTO student VALUES('103', 'Student', 'Student', '1976-01-23', '95033');
INSERT INTO student VALUES('104', 'Student', 'Student', '1976-02-20', '95033');
INSERT INTO student VALUES('105', 'Student', 'Student', '10.02.1975', '95031');
INSERT INTO student VALUES('106', 'Armee', 'Männlich', '1974-06-03', '95031');
INSERT INTO student VALUES('107', 'Studentenname', 'Student', '1976-02-20', '95033');
INSERT INTO student VALUES('108', 'Studentenname', 'Name', '1975-02-10', '95031');
INSERT INTO student VALUES('109', 'Studentenwert', 'Wert', '1974-06-03', '95031');

-- Daten der Lehrertabelle hinzufügen INSERT INTO teacher VALUES('804', 'Li Cheng', 'Männlich', '1958-12-02', 'Außerordentlicher Professor', 'Abteilung für Informatik');
INSERT INTO teacher VALUES('856', 'Lehrer', 'Schreibweise', '1969-03-12', 'Lehrer', 'Lehrer-ID');
INSERT INTO teacher VALUES('825', 'Lehrer', 'Tabelle', '1972-05-05', 'Lehrer', 'Lehrertext');
INSERT INTO teacher VALUES('831', 'Liu Bing', 'Weiblich', '1977-08-14', 'Lehrassistentin', 'Abteilung für Elektrotechnik');

-- Kursdaten hinzufügen INSERT INTO course VALUES('3-105', 'Einführung in die Informatik', '825');
INSERT INTO course VALUES('3-245', 'Betriebssystem', '804');
INSERT INTO course VALUES('6-166', 'Digitale Schaltkreise', '856');
INSERT INTO course VALUES('9-888', 'Höhere Mathematik', '831');

-- Daten der Punktetabelle hinzufügen INSERT INTO score VALUES('103', '3-105', '92');
INSERT INTO score VALUES('103', '3-245', '86');
INSERT INTO score VALUES('103', '6-166', '85');
INSERT INTO score VALUES('105', '3-105', '88');
INSERT INTO score VALUES('105', '3-245', '75');
INSERT INTO score VALUES('105', '6-166', '79');
INSERT INTO score VALUES('109', '3-105', '76');
INSERT INTO score VALUES('109', '3-245', '68');
INSERT INTO score VALUES('109', '6-166', '81');

-- Zeigen Sie die Tabellenstruktur an. SELECT * FROM course;
WÄHLEN SIE * AUS Punktzahl;
WÄHLEN SIE * VON Student;
SELECT * FROM Lehrer;

1 bis 10

-- Alle Zeilen der Studententabelle abfragen SELECT * FROM student;

-- Abfrage aller Zeilen der Felder „Name“, „Geschlecht“ und „Klasse“ in der Tabelle „Student“ SELECT name, sex, class FROM student;

-- Abfrage der eindeutigen Abteilungsspalte in der Lehrertabelle -- Abteilung: Deduplizierungsabfrage SELECT DISTINCT Abteilung FROM Lehrer;

-- Abfrage aller Zeilen in der Punktetabelle mit Punktzahlen zwischen 60 und 80 (Intervallabfrage und Operatorabfrage)
-- BETWEEN xx AND xx: Abfrageintervall, AND bedeutet „und“
SELECT * FROM score WHERE Grad ZWISCHEN 60 UND 80;
SELECT * FROM Punktzahl WHERE Abschluss > 60 UND Abschluss < 80;

-- Abfrage der Zeilen in der Punktetabelle mit einer Punktzahl von 85, 86 oder 88 -- IN: Abfrage mehrerer Werte in der Spezifikation SELECT * FROM score WHERE degree IN (85, 86, 88);

-- Abfrage aller Zeilen in der Studententabelle, deren Klasse „95031“ oder deren Geschlecht „weiblich“ ist -- oder: zeigt eine Oder-Beziehung an SELECT * FROM student WHERE class = „95031“ or sex = „weiblich“;

-- Abfrage aller Zeilen der Studententabelle in absteigender Reihenfolge der Klasse -- DESC: absteigende Reihenfolge, von hoch nach niedrig -- ASC (Standard): aufsteigende Reihenfolge, von niedrig nach hoch SELECT * FROM student ORDER BY class DESC;
Wählen Sie * aus dem Studenten aus. Bestellen Sie nach Klasse ASC.

-- Abfrage aller Zeilen der Punktetabelle in aufsteigender Reihenfolge der c_no und absteigender Reihenfolge des Grades. SELECT * FROM score ORDER BY c_no ASC, degree DESC;

-- Abfrage der Anzahl der Schüler in der Klasse "95031" -- COUNT: Statistik SELECT COUNT(*) FROM student WHERE class = '95031';

-- Abfrage der Matrikel-ID und Kurs-ID des Studenten mit der höchsten Punktzahl in der Punktetabelle (Unterabfrage oder Sortierabfrage).
- (SELECT MAX(degree) FROM score): Unterabfrage zum Berechnen der höchsten Punktzahl SELECT s_no, c_no FROM score WHERE degree = (SELECT MAX(degree) FROM score);

- Sortierabfrage - LIMIT r, n: bedeutet, beginnend bei der r-ten Zeile, n Daten abzufragen SELECT s_no, c_no, degree FROM score ORDER BY degree DESC LIMIT 0, 1;

Berechnen Sie die durchschnittlichen Punktzahlen nach Gruppen

Abfrage der Durchschnittsnote der einzelnen Kurse.

- AVG: Durchschnittswert SELECT AVG(Grad) FROM Punktzahl WHERE c_no = '3-105';
Wählen Sie AVG (Grad) aus Punktzahl, wobei c_no = '3-245' ist.
Wählen Sie AVG (Grad) aus Punktzahl, wobei c_no = '6-166' ist.

-- GROUP BY: Gruppenabfrage SELECT c_no, AVG(degree) FROM score GROUP BY c_no;

Gruppierungsbedingungen und Fuzzy-Abfragen

Abfrage der Durchschnittsnoten von Kursen aus der score , die von mindestens 2 Studierenden belegt werden und deren Nummer mit 3 beginnt.

WÄHLEN SIE * AUS Punktzahl;
-- c_no Kursnummer +------+-------+--------+
| S_Nr. | C_Nr. | Grad |
+------+-------+--------+
| 103 | 3-105 | 92 |
| 103 | 3-245 | 86 |
| 103 | 6-166 | 85 |
| 105 | 3-105 | 88 |
| 105 | 3-245 | 75 |
| 105 | 6-166 | 79 |
| 109 | 3-105 | 76 |
| 109 | 3-245 | 68 |
| 109 | 6-166 | 81 |
+------+-------+--------+

Aus der Analysetabelle geht hervor, dass mindestens 2 Studierende die Lehrveranstaltungen 3-105 , 3-245 und 6-166 gewählt haben und die Lehrveranstaltungen, die mit einer 3 beginnen, 3-105 und 3-245 sind. Das heißt, wir möchten die durchschnittlichen degree aller 3-105 und 3-245 abfragen.

-- Fragen Sie zuerst c_no, AVG(degree) ab, indem Sie SELECT c_no, AVG(degree) FROM score GROUP BY c_no gruppieren.
+----------+----------+
| c_nr. | AVG(Grad) |
+----------+----------+
| 3-105 | 85,3333 |
| 3-245 | 76,3333 |
| 6-166 | 81,6667 |
+----------+----------+

-- Abfrage der Kurse, die von mindestens 2 Studenten belegt werden -- HAVING: gibt an, dass HAVING COUNT(c_no) >= 2

-- und der Kurs beginnt mit 3 -- LIKE zeigt eine Fuzzy-Abfrage an, „%“ ist ein Platzhalter, der mit jedem Zeichen nach „3“ übereinstimmt.
UND c_no WIE ,3 %‘;

-- Verketten Sie die vorherigen SQL-Anweisungen miteinander.
-- Durch die Angabe eines COUNT(*) am Ende wird zusätzlich die Nummer der jeweiligen Gruppe abgefragt.
WÄHLEN Sie c_no, AVG(Grad), COUNT(*) FROM Punktzahl GROUP BY c_no
MIT ANZAHL(c_no) >= 2 UND c_no WIE '3%';
+-------+-------------+----------+
| c_no | AVG(Grad) | ANZAHL(*) |
+-------+-------------+----------+
| 3-105 | 85,3333 | 3 |
| 3-245 | 76,3333 | 3 |
+-------+-------------+----------+

Abfrage mehrerer Tabellen - 1

Fragen Sie name aller Studierenden sowie die dem Studierenden in score Punktetabelle entsprechende c_no . und degree .

SELECT Nr., Name VON Student;
+-----+-----------+
| kein | Name |
+-----+-----------+
| 101 | Zeng Hua |
| 102 | Kuang Ming |
| 103 | Wang Li|
| 104 | Li Jun |
| 105 | Wang Fang|
| 106 | Armee |
| 107 | Wang Nima |
| 108 | Zhang Quandan |
| 109 | Zhao Tiezhu|
+-----+-----------+

Wählen Sie s_no, c_no, Abschluss aus Punktzahl;
+------+-------+--------+
| S_Nr. | C_Nr. | Grad |
+------+-------+--------+
| 103 | 3-105 | 92 |
| 103 | 3-245 | 86 |
| 103 | 6-166 | 85 |
| 105 | 3-105 | 88 |
| 105 | 3-245 | 75 |
| 105 | 6-166 | 79 |
| 109 | 3-105 | 76 |
| 109 | 3-245 | 68 |
| 109 | 6-166 | 81 |
+------+-------+--------+

Durch Analyse können wir feststellen, dass wir nur den Feldwert s_no in score Punktetabelle durch den entsprechenden Feldwert name in der student ersetzen müssen. Wie geht das?

– FROM …: gibt eine Abfrage aus den Studenten- und Punktetabellen an. – Die WHERE-Bedingung gibt an, dass das Ergebnis nur angezeigt wird, wenn student.no und score.s_no gleich sind.
SELECT Name, C_Nr., Abschluss FROM Student, Punktzahl
WO student.no = score.s_no;
+--------------+-------+--------+
| Name | C_Nr | Abschluss |
+--------------+-------+--------+
| Wang Li | 3-105 | 92 |
| Wang Li | 3-245 | 86 |
| Wang Li | 6-166 | 85 |
| Wang Fang | 3-105 | 88 |
| Wang Fang | 3-245 | 75 |
| Wang Fang | 6-166 | 79 |
| Zhao Tiezhu | 3-105 | 76 |
| Zhao Tiezhu | 3-245 | 68 |
| Zhao Tiezhu | 6-166 | 81 |
+--------------+-------+--------+

Abfrage mehrerer Tabellen - 2

Abfrage der Spalten no , Lehrveranstaltungsname ( name in course ) und Note ( degree in score ) aller Studierenden.

Mit der no des Studenten ist nur score verknüpft. Durch Abfragen score können Sie daher alle mit dem Studenten verknüpften no und degree finden:

Wählen Sie s_no, c_no, Abschluss aus Punktzahl;
+------+-------+--------+
| S_Nr. | C_Nr. | Grad |
+------+-------+--------+
| 103 | 3-105 | 92 |
| 103 | 3-245 | 86 |
| 103 | 6-166 | 85 |
| 105 | 3-105 | 88 |
| 105 | 3-245 | 75 |
| 105 | 6-166 | 79 |
| 109 | 3-105 | 76 |
| 109 | 3-245 | 68 |
| 109 | 6-166 | 81 |
+------+-------+--------+

Anschließend course Kurstabelle abfragen:

+----------+-----------------+
| kein | Name |
+----------+-----------------+
| 3-105 | Einführung in Computer |
| 3-245 | Betriebssysteme |
| 6-166 | Digitale Schaltungen |
| 9-888 | Höhere Mathematik |
+----------+-----------------+

Ersetzen Sie einfach c_no in score Punktetabelle durch den entsprechenden Wert name in der course .

- Fügen Sie einen Abfragefeldnamen hinzu, um die Punkte- bzw. Kurstabellen abzufragen.
--as bedeutet, einen Alias für das Feld zu verwenden.
SELECT s_no, Name als c_name, Abschluss FROM Punktzahl, Kurs
WO score.c_no = kurs.no;
+------+-----------------+--------+
| s_nr | c_name | Grad |
+------+-----------------+--------+
| 103 | Einführung in Computer | 92 |
| 105 | Einführung in Computer | 88 |
| 109 | Einführung in Computer | 76 |
| 103 | Betriebssysteme | 86 |
| 105 | Betriebssysteme | 75 |
| 109 | Betriebssysteme | 68 |
| 103 | Digitale Schaltungen | 85 |
| 105 | Digitale Schaltungen | 79 |
| 109 | Digitale Schaltungen | 81 |
+------+-----------------+--------+

Abfrage der Drei-Tabellen-Assoziation

Abfrage name , der Lehrveranstaltungsbezeichnung ( name in course ) und degree aller Studierenden.

Da nur die Studierenden-ID und die Klassen-ID mit score verknüpft sind, müssen wir nur die score abfragen.

WÄHLEN SIE * AUS Punktzahl;
+------+-------+--------+
| S_Nr. | C_Nr. | Grad |
+------+-------+--------+
| 103 | 3-105 | 92 |
| 103 | 3-245 | 86 |
| 103 | 6-166 | 85 |
| 105 | 3-105 | 88 |
| 105 | 3-245 | 75 |
| 105 | 6-166 | 79 |
| 109 | 3-105 | 76 |
| 109 | 3-245 | 68 |
| 109 | 6-166 | 81 |
+------+-------+--------+

Ersetzen Sie einfach s_no und c_no durch die entsprechenden name in student und srouse .

Ersetzen Sie zuerst s_no durch das name in der student :

SELECT Name, C_Nr., Abschluss FROM Student, Punktzahl WHERE Student.Nr. = Punktzahl.S_Nr.;
+--------------+-------+--------+
| Name | C_Nr | Abschluss |
+--------------+-------+--------+
| Wang Li | 3-105 | 92 |
| Wang Li | 3-245 | 86 |
| Wang Li | 6-166 | 85 |
| Wang Fang | 3-105 | 88 |
| Wang Fang | 3-245 | 75 |
| Wang Fang | 6-166 | 79 |
| Zhao Tiezhu | 3-105 | 76 |
| Zhao Tiezhu | 3-245 | 68 |
| Zhao Tiezhu | 6-166 | 81 |
+--------------+-------+--------+

Ersetzen Sie dann c_no durch das name in course Kurstabelle:

- Kurstabelle SELECT Nr., Name FROM Kurs;
+----------+-----------------+
| kein | Name |
+----------+-----------------+
| 3-105 | Einführung in Computer |
| 3-245 | Betriebssysteme |
| 6-166 | Digitale Schaltungen |
| 9-888 | Höhere Mathematik |
+----------+-----------------+

-- Da die Feldnamen wiederholt werden, verwenden Sie stattdessen „Tabellenname.Feldname als Alias“.
Wählen Sie student.name als s_name, course.name als c_name, degree
VON Student, Punktzahl, Kurs
WO student.NO = score.s_no
UND score.c_no = kurs.no;

Unterabfrage plus Gruppierung zur Ermittlung der Durchschnittspunktzahl

Fragen Sie die Durchschnittsnote jedes Kurses für Studierende der Klasse 95031 ab.

Filtern Sie in score Punktetabelle die Klassennummer und die Note des Schülers entsprechend der Schülernummer in student heraus:

-- IN (..): Benutze die ausgewählte Matrikelnummer als Bedingung für s_no SELECT s_no, c_no, degree FROM score
WO s_no IN (SELECT no FROM student WHERE class = '95031');
+------+-------+--------+
| S_Nr. | C_Nr. | Grad |
+------+-------+--------+
| 105 | 3-105 | 88 |
| 105 | 3-245 | 75 |
| 105 | 6-166 | 79 |
| 109 | 3-105 | 76 |
| 109 | 3-245 | 68 |
| 109 | 6-166 | 81 |
+------+-------+--------+

Zu diesem Zeitpunkt müssen wir nur c_no gruppieren, um die Durchschnittsnote jedes Kurses der Schüler in Klasse 95031 zu erhalten:

Wählen Sie c_no, AVG (Grad) aus Punktzahl
WHERE s_no IN (SELECT no FROM student WHERE class = '95031')
GRUPPE NACH c_Nr;
+----------+----------+
| c_nr. | AVG(Grad) |
+----------+----------+
| 3-105 | 82,0000 |
| 3-245 | 71,5000 |
| 6-166 |
+----------+----------+

Unterabfrage - 1

Abfrage aller Datensätze von Studenten, deren Punktzahl höher ist als die von Student Nr. 109 im Kurs 3-105 .

Filtern Sie zunächst die Klassennummern 3-105 heraus und suchen Sie dann alle Zeilen, in denen die Punktzahl höher ist als die des Schülers mit der Nummer 109 .

SELECT * FROM Punktzahl
WO c_no = '3-105'
UND Abschluss > (WÄHLEN Sie Abschluss AUS Punktzahl, wobei s_no = ,109‘ und c_no = ,3-105‘);

Unterabfrage - 2

Abfrage der Notentabellen aller Kurse 3-105 deren Noten höher sind als die des Studenten Nr. 109 .

-- Es gibt keine Beschränkung hinsichtlich der Kursnummer, solange die Punktzahl höher ist als die des Studenten Nr. 109 in den Kursen 3-105.
SELECT * FROM Punktzahl
WO Abschluss > (WÄHLEN Sie Abschluss AUS Punktzahl, WO s_no = ‚109‘ UND c_no = ‚3-105‘);

YEAR-Funktion und Abfrage mit IN-Schlüsselwort

Fragen Sie alle Spalten no , name und birthday , die im selben Jahr wie die Schüler Nr. 101 und Nr. 108 geboren wurden.

-- YEAR(..): Extrahiert das Jahr aus dem Datum. SELECT Nr., Name, Geburtstag FROM Student
WHERE YEAR(Geburtstag) IN (SELECT YEAR(Geburtstag) FROM student WHERE no IN (101, 108));

Mehrstufig verschachtelte Unterabfragen

Fragen Sie die Schülerbewertungstabelle des Lehrers '張旭' ab.

Suchen Sie zuerst die Lehrernummer:

SELECT NO FROM Lehrer WHERE NAME = 'Lehrer'

Die Kursnummer des Dozenten finden Sie in sourse :

Wählen Sie NEIN aus dem Kurs, wobei t_nr. = (Wählen Sie NEIN aus dem Lehrer, wobei NAME = 'Kurs' ist);

Abfrage der Punktetabelle durch Auswahl der Lehrveranstaltungsnummer:

Wählen Sie * aus Punktzahl, wobei c_no = (
  SELECT nein FROM Kurs WHERE t_no = (
    SELECT no FROM teacher WHERE NAME = 'Lehrer'
  )
);

Abfrage mehrerer Tabellen

Suchen Sie die Namen von Lehrern, bei denen mehr als 5 Schüler einen Wahlkurs belegen.

Ermitteln Sie zunächst in der teacher über das Feld no , ob mindestens 5 Schüler am gleichen Kurs des Lehrers teilnehmen:

-- Abfrage der Lehrertabelle SELECT Nr., Name FROM Lehrer;
+-----+--------+
| kein | Name |
+-----+--------+
| 804 | Li Cheng|
| 825 | Wang Ping|
| 831 | Liu Bing|
| 856 | Zhang Xu|
+-----+--------+

SELECT Name FROM Lehrer WHERE nein IN (
  -- die entsprechende Bedingung finden Sie hier);

Sehen Sie sich die Informationen der Tabelle bezüglich der Lehrernummer an:

SELECT * FROM Kurs;
-- t_no: Lehrernummer+-------+-----------------+------+
| nein | Name | t_nr |
+-------+-----------------+------+
| 3-105 | Einführung in Computer | 825 |
| 3-245 | Betriebssysteme | 804 |
| 6-166 | Digitale Schaltungen | 856 |
| 9-888 | Höhere Mathematik | 831 |
+-------+-----------------+------+

Wir haben festgestellt, dass sich das Feld mit der Lehrernummer in der course befindet, wissen aber immer noch nicht, für welchen Kurs mindestens 5 Studenten eingeschrieben sind. Daher müssen wir es anhand score Punktetabelle abfragen:

-- Fügen Sie vorher einige Daten in die Partitur ein, um die Abfragebedingungen zu verbessern.
INSERT INTO score VALUES ('101', '3-105', '90');
INSERT INTO score VALUES ('102', '3-105', '91');
INSERT INTO score VALUES ('104', '3-105', '89');

-- Abfrage der Punktetabelle SELECT * FROM score;
+------+-------+--------+
| S_Nr. | C_Nr. | Grad |
+------+-------+--------+
| 101 | 3-105 | 90 |
| 102 | 3-105 | 91 |
| 103 | 3-105 | 92 |
| 103 | 3-245 | 86 |
| 103 | 6-166 | 85 |
| 104 | 3-105 | 89 |
| 105 | 3-105 | 88 |
| 105 | 3-245 | 75 |
| 105 | 6-166 | 79 |
| 109 | 3-105 | 76 |
| 109 | 3-245 | 68 |
| 109 | 6-166 | 81 |
+------+-------+--------+

- Verwenden Sie c_no als Gruppe in der Punktetabelle und beschränken Sie c_no auf mindestens 5 Datenelemente.
Wählen Sie c_no aus Punktzahl GROUP BY c_no HAVING COUNT(*) > 5;
+----------+
| c_nr |
+----------+
| 3-105 |
+----------+

Finden Sie anhand der gefilterten Kursnummern die Lehrernummern mit mindestens 5 Schülern in einem Kurs:

SELECT t_no FROM Kurs WHERE nein IN (
  SELECT c_no FROM Punktzahl GROUP BY c_no HAVING COUNT(*) > 5
);
+------+
| t_nein |
+------+
| 825 |
+------+

Suchen Sie in der teacher den Namen des Lehrers anhand der gefilterten Lehrernummer:

SELECT Name FROM Lehrer WHERE nein IN (
  -- Endbedingung SELECT t_no FROM course WHERE no IN (
    SELECT c_no FROM Punktzahl GROUP BY c_no HAVING COUNT(*) > 5
  )
);

Unterabfrage - 3

Überprüfen Sie das Transkript der Kurse der „Abteilung Informatik“.

Die Idee besteht darin, zunächst die Nummern aller計算機系in course Kurstabelle zu finden und dann anhand dieser Nummer score abzufragen.

-- Abfrage aller Lehrernummern des Fachbereichs Informatik über die Lehrertabelle SELECT Nr., Name, Fachbereich FROM Lehrer WHERE Fachbereich = 'Fachbereich Informatik'
+-----+--------+--------------+
| Nr. | Name | Abteilung |
+-----+--------+--------------+
| 804 | Li Cheng | Institut für Informatik |
| 825 | Wang Ping | Institut für Informatik |
+-----+--------+--------------+

-- Abfrage der Kursnummer des Lehrers über die Kurstabelle SELECT no FROM course WHERE t_no IN (
  SELECT no FROM teacher WHERE department = 'Abteilung für Informatik'
);
+----------+
| nein |
+----------+
| 3-245 |
| 3-105 |
+----------+

-- Abfrage der Punktetabelle basierend auf der gefilterten Kursnummer SELECT * FROM score WHERE c_no IN (
  SELECT nein FROM Kurs WHERE t_no IN (
    SELECT no FROM teacher WHERE department = 'Abteilung für Informatik'
  )
);
+------+-------+--------+
| S_Nr. | C_Nr. | Grad |
+------+-------+--------+
| 103 | 3-245 | 86 |
| 105 | 3-245 | 75 |
| 109 | 3-245 | 68 |
| 101 | 3-105 | 90 |
| 102 | 3-105 | 91 |
| 103 | 3-105 | 92 |
| 104 | 3-105 | 89 |
| 105 | 3-105 | 88 |
| 109 | 3-105 | 76 |
+------+-------+--------+

Verwendung von UNION und NOTIN

Abfrage von Lehrenden mit unterschiedlichen Berufsbezeichnungen im計算機系und電子工程系.

-- NOT: stellt eine logische Negation dar SELECT * FROM teacher WHERE department = 'Informatik' AND profession NOT IN (
  SELECT Beruf FROM Lehrer WHERE Abteilung = 'Abteilung für Elektrotechnik'
)
-- Kombinieren Sie zwei Sätze UNION
SELECT * FROM Lehrer WHERE Abteilung = 'Abteilung für Elektrotechnik' AND Beruf NOT IN (
  SELECT Beruf FROM Lehrer WHERE Abteilung = 'Abteilung für Informatik'
);

ANY bedeutet mindestens eins - DESC (absteigende Reihenfolge)

Abfrage der score für Kurse 3-105 deren Punktzahlen <u>mindestens</u> höher als 3-245 sind.

Wählen Sie * aus Punktzahl, wobei c_no = '3-105' ist.
+------+-------+--------+
| S_Nr. | C_Nr. | Grad |
+------+-------+--------+
| 101 | 3-105 | 90 |
| 102 | 3-105 | 91 |
| 103 | 3-105 | 92 |
| 104 | 3-105 | 89 |
| 105 | 3-105 | 88 |
| 109 | 3-105 | 76 |
+------+-------+--------+

Wählen Sie * aus Punktzahl, wobei c_no = '3-245' ist.
+------+-------+--------+
| S_Nr. | C_Nr. | Grad |
+------+-------+--------+
| 103 | 3-245 | 86 |
| 105 | 3-245 | 75 |
| 109 | 3-245 | 68 |
+------+-------+--------+

-- ANY: Erfüllt jede Bedingung in der SQL-Anweisung.
– Das heißt, solange es unter den Punktzahlen von 3–105 eine gibt, die höher ist als jede beliebige ausgewählte Zeile zwischen 3–245, erfüllt diese die Bedingung.
--Fragen Sie abschließend die Ergebnisse in absteigender Reihenfolge ab.
SELECT * FROM Punktzahl WHERE c_no = '3-105' AND Grad > BELIEBIG(
  Wählen Sie Abschluss aus Punktzahl, wobei c_no = '3-245' ist.
) ORDER BY Grad DESC;
+------+-------+--------+
| S_Nr. | C_Nr. | Grad |
+------+-------+--------+
| 103 | 3-105 | 92 |
| 102 | 3-105 | 91 |
| 101 | 3-105 | 90 |
| 104 | 3-105 | 89 |
| 105 | 3-105 | 88 |
| 109 | 3-105 | 76 |
+------+-------+--------+

ALLE

Abfrage der score für Kurse 3-105 und Noten über 3-245 .

– Nur eine kleine Änderung gegenüber der vorherigen Frage.
-- ALL: Erfüllt alle Bedingungen in der SQL-Anweisung.
-- Das heißt, die Punktzahl in jeder Zeile von 3-105 muss höher sein als alle herausgefilterten Zeilen von 3-245, um die Bedingungen zu erfüllen.
Wählen Sie * aus Punktzahl, wobei c_Nr. = '3-105' und Grad > ALLE (
  Wählen Sie Abschluss aus Punktzahl, wobei c_no = '3-245' ist.
);
+------+-------+--------+
| S_Nr. | C_Nr. | Grad |
+------+-------+--------+
| 101 | 3-105 | 90 |
| 102 | 3-105 | 91 |
| 103 | 3-105 | 92 |
| 104 | 3-105 | 89 |
| 105 | 3-105 | 88 |
+------+-------+--------+

Kopieren der Tabellendaten als bedingte Abfrage

Fragen Sie die Punktetabelle für einen Kurs ab, dessen Punktzahl niedriger ist als die durchschnittliche score des Kurses.

-- Abfrage der durchschnittlichen Punktzahl SELECT c_no, AVG(degree) FROM score GROUP BY c_no;
+----------+----------+
| c_nr. | AVG(Grad) |
+----------+----------+
| 3-105 | 87,6667 |
| 3-245 | 76,3333 |
| 6-166 | 81,6667 |
+----------+----------+

- Abfrage der Punktetabelle SELECT degree FROM score;
+--------+
| Grad |
+--------+
| 90 |
| 91 |
| 92 |
| 86 |
| 85 |
| 89 |
| 88 |
| 75 |
| 79 |
| 76 |
| 68 |
| 81 |
+--------+

-- Tabelle b auf Tabelle a anwenden, um Daten abzufragen -- Punktzahl a (b): die Tabelle als a (b) deklarieren,
– Auf diese Weise können Sie a.c_no = b.c_no als Bedingung zum Ausführen der Abfrage verwenden.
SELECT * FROM Punktzahl a WHERE Abschluss < (
  (Wählen Sie AVG (Grad) aus Punktzahl b, wobei a.c_no = b.c_no)
);
+------+-------+--------+
| S_Nr. | C_Nr. | Grad |
+------+-------+--------+
| 105 | 3-245 | 75 |
| 105 | 6-166 | 79 |
| 109 | 3-105 | 76 |
| 109 | 3-245 | 68 |
| 109 | 6-166 | 81 |
+------+-------+--------+

Unterabfrage - 4

Abfrage name und der department aller Lehrkräfte, die Kurse unterrichten (Kurse sind in course Kurstabelle vorhanden) .

SELECT Name, Abteilung FROM Lehrer WHERE Nr. IN (SELECT t_no FROM Kurs);
+--------+-----------------+
| Name | Abteilung |
+--------+-----------------+
| Li Cheng | Fakultät für Informatik |
| Wang Ping | Fakultät für Informatik |
| Liu Bing| Fakultät für Elektrotechnik|
| Zhang Xu | Fakultät für Elektrotechnik |
+--------+-----------------+

Bedingte Gruppenfilterung

Fragen Sie die student nach class ab, in denen sich mindestens zwei Jungen befinden.

-- Informationen zur Studententabelle anzeigen SELECT * FROM student;
+-----+-----------+-----+------------+-----------+
| Nr. | Name | Geschlecht | Geburtstag | Klasse |
+-----+-----------+-----+------------+-----------+
| 101 | Zeng Hua | Männlich | 01.09.1977 | 95033 |
| 102 | Kuang Ming | Männlich | 02.10.1975 | 95031 |
| 103 | Wang Li | Weiblich | 23.01.1976 | 95033 |
| 104 | Li Jun | Männlich | 20.02.1976 | 95033 |
| 105 | Wang Fang | Weiblich | 10.02.1975 | 95031 |
| 106 | Armee | Männlich | 03.06.1974 | 95031 |
| 107 | Wang Nima | Männlich | 20.02.1976 | 95033 |
| 108 | Zhang Quandan | Männlich | 10.02.1975 | 95031 |
| 109 | Zhao Tiezhu | Männlich | 03.06.1974 | 95031 |
| 110 | Zhang Fei | Männlich | 03.06.1974 | 95038 |
+-----+-----------+-----+------------+-----------+

-- Fragen Sie nur das Geschlecht „männlich“ ab, gruppieren Sie dann nach Klasse und begrenzen Sie die Klassenzeilen auf größer als 1.
SELECT Klasse FROM Schüler WHERE Geschlecht = 'Klasse' GROUP BY Klasse HAVING COUNT(*) > 1;
+----------+
| Klasse |
+----------+
|95033|
|95031|
+----------+

NOTLIKE Fuzzy-Abfrage-Negation

Abfrage der student nach Datensätzen von Studenten, deren Nachname nicht „Wang“ ist.

-- NICHT: Negation -- WIE: Fuzzy-Abfrage mysql> SELECT * FROM student WHERE name NOT LIKE '王%';
+-----+-----------+-----+------------+-----------+
| Nr. | Name | Geschlecht | Geburtstag | Klasse |
+-----+-----------+-----+------------+-----------+
| 101 | Zeng Hua | Männlich | 01.09.1977 | 95033 |
| 102 | Kuang Ming | Männlich | 02.10.1975 | 95031 |
| 104 | Li Jun | Männlich | 20.02.1976 | 95033 |
| 106 | Armee | Männlich | 03.06.1974 | 95031 |
| 108 | Zhang Quandan | Männlich | 10.02.1975 | 95031 |
| 109 | Zhao Tiezhu | Männlich | 03.06.1974 | 95031 |
| 110 | Zhang Fei | Männlich | 03.06.1974 | 95038 |
+-----+-----------+-----+------------+-----------+

YEAR- und NOW-Funktionen

Fragen Sie den Namen und das Alter jedes Schülers in der student ab.

-- Verwenden Sie die Funktion YEAR(NOW()), um das aktuelle Jahr zu berechnen und das Geburtsjahr abzuziehen, um das Alter zu ermitteln.
SELECT Name, YEAR(NOW()) - YEAR(Geburtstag) als Alter FROM Student;
+--------------+------+
| Name | Alter |
+--------------+------+
| Zeng Hua | 42 |
| Kuang Ming | 44 |
| Wang Li| 43 |
| Li Juni | 43 |
| Wang Fang | 44 |
| Armee | 45 |
| Wang Nima | 43 |
| Zhang Quandan | 44 |
| Zhao Tiezhu | 45 |
| Zhang Fei | 45 |
+--------------+------+

MAX- und MIN-Funktionen

Abfrage der maximalen und minimalen birthday in der student .

SELECT MAX(Geburtstag), MIN(Geburtstag) FROM Student;
+---------------+---------------+
| MAX(Geburtstag) | MIN(Geburtstag) |
+---------------+---------------+
| 01.09.1977 | 03.06.1974 |
+---------------+---------------+

Sortierung mehrerer Segmente

Abfrage der student in absteigender Reihenfolge nach class und birthday .

SELECT * FROM student ORDER BY class DESC, Geburtstag;
+-----+-----------+-----+------------+-----------+
| Nr. | Name | Geschlecht | Geburtstag | Klasse |
+-----+-----------+-----+------------+-----------+
| 110 | Zhang Fei | Männlich | 03.06.1974 | 95038 |
| 103 | Wang Li | Weiblich | 23.01.1976 | 95033 |
| 104 | Li Jun | Männlich | 20.02.1976 | 95033 |
| 107 | Wang Nima | Männlich | 20.02.1976 | 95033 |
| 101 | Zeng Hua | Männlich | 01.09.1977 | 95033 |
| 106 | Armee | Männlich | 03.06.1974 | 95031 |
| 109 | Zhao Tiezhu | Männlich | 03.06.1974 | 95031 |
| 105 | Wang Fang | Weiblich | 10.02.1975 | 95031 |
| 108 | Zhang Quandan | Männlich | 10.02.1975 | 95031 |
| 102 | Kuang Ming | Männlich | 02.10.1975 | 95031 |
+-----+-----------+-----+------------+-----------+

Unterabfrage - 5

Fragen Sie nach „männlichen“ Lehrern und den Kursen, die sie unterrichten.

Wählen Sie * aus dem Kurs, wobei t_nr. in (Wählen Sie keine aus dem Lehrer, wobei Geschlecht = '男');
+----------+--------------+------+
| nein | Name | t_nr |
+----------+--------------+------+
| 3-245 | Betriebssysteme | 804 |
| 6-166 | Digitale Schaltungen | 856 |
+----------+--------------+------+

MAX-Funktion mit Unterabfragen

Fragen Sie die score des Schülers mit der höchsten Punktzahl ab.

-- Finde die höchste Punktzahl (diese Abfrage kann nur ein Ergebnis haben)
Wählen Sie MAX(Grad) aus Punktzahl;

-- Filtern Sie alle Tabellen mit der höchsten Punktzahl gemäß den oben genannten Bedingungen heraus.
– Diese Abfrage kann mehrere Ergebnisse haben, vorausgesetzt, der Gradwert erfüllt die Bedingung mehrmals.
Wählen Sie * aus Punktzahl, wobei Grad = (Wählen Sie MAX (Grad) aus Punktzahl);
+------+-------+--------+
| S_Nr. | C_Nr. | Grad |
+------+-------+--------+
| 103 | 3-105 | 92 |
+------+-------+--------+

Unterabfrage - 6

Abfrage name aller Klassenkameraden mit dem gleichen Geschlecht wie „Li Jun“.

-- Nehmen Sie zunächst Li Juns Geschlecht als Bedingung: SELECT sex FROM student WHERE name = 'Li Jun';
+-----+
| Geschlecht |
+-----+
| Männlich |
+-----+

- Abfrage von Namen und Geschlecht basierend auf dem Gender
Name wählen, Sex vom Schüler wobei Sex = (
  Wählen Sie Sex vom Schüler, wobei Name = '李军'
);
+-----------+-----+
|
+-----------+-----+
| Zeng Hua |
|
|
|
|
|
|
|
+-----------+-----+

Unterabfrage - 7

Fragen Sie name Klassenkameraden ab, die das gleiche Geschlecht und die gleiche Klasse wie "李军" haben.

Wählen Sie Name, Sex, Klasse vom Schüler, wobei Sex = ((
  Wählen Sie Sex vom Schüler, wobei Name = '李军'
) Und Klasse = ((
  Wählen Sie die Klasse aus dem Schüler, wobei Name = '李军'
);
+-----------+------+-------+
|
+-----------+------+-------+
|
| Li jun |
|
+-----------+------+-------+

Unterabfrage - 8

Fragen Sie das Protokoll aller männlichen Studenten, die den Kurs "Einführung in die Informatik" belegt haben, ab.

Die erforderliche "Einführung in die Informatik" und das Geschlecht "männlich" finden Sie in course und student .

Wählen Sie * aus der Punktzahl, wobei c_no = ((
  Wählen Sie Nein aus dem Kurs, wobei Name = 'Einführung in die Informatik'
) Und s_no in (
  Wählen Sie nein vom Schüler, wobei Sex = '男'
);
+------+-------+--------+
|
+------+-------+--------+
|
|
|
| 109 | 3-105 | 76 |
+------+-------+--------+

Suche nach Ebene

Erstellen Sie eine grade , um die Noten der Schüler darzustellen und Daten einfügen:

Tischnote erstellen (
  niedrige int (3),
  UPP INT (3),
  Grade Char (1)
);

In die Gradewerte einfügen (90, 100, 'a');
In die Notenwerte einfügen (80, 89, 'B');
In die Gradewerte einfügen (70, 79, 'c');
In die Klassenwerte einfügen (60, 69, 'D');
In die Klassenwerte einfügen (0, 59, 'e');

Aus der Klasse auswählen;
+------+------+-------+
|
+------+------+-------+
|
|
|
|
|
+------+------+-------+

Fragen Sie s_no , c_no und grade für alle Schüler an.

Die Idee ist, eine Intervallabfrage ( BETWEEN ) zu verwenden, um festzustellen, ob sich die Grad der Schüler ( degree ) zwischen low und upp in grade Klassentabelle befindet.

Wählen Sie S_NO, C_NO, Note aus der Punktzahl, Note
Wo Grad zwischen niedrig und upp;
+------+-------+---------+
|
+------+-------+---------+
|
|
|
|
|
|
|
|
|
|
|
|
+------+-------+---------+

Verbindungsabfrage

Bereiten Sie Daten für Testen von Verbindungsabfragen vor:

Datenbank testjoin erstellen;

Tischperson erstellen (
  Ich würde INT,
  Name VARCHAR(20),
  Cardid int
);

Tischkarte erstellen (
  Ich würde INT,
  Name VARCHAR(20)
);

Einfügen in Kartenwerte (1, 'Reiskarte'), (2, 'Construction Bank Card'), (3, 'Agricultural Bank Card'), (4, „Industrie- und Gewerbekarte“), (5, "Postkarte");
Aus der Karte auswählen;
+------+----------+
| Ich würde | Name |
+------+----------+
| 1 | Essenskarte|
| 2 | CCB-Karte|
| 3 | Landwirtschaftliche Bankkarte|
| 4 | Visitenkarte|
| 5 | Postkarte |
+------+----------+

Einfügen in Personalte (1, '张三', 1), (2, '李四', 3), (3, '王五', 6);
Wählen Sie * aus der Person;
+------+--------+--------+
| ID | Name | Karten-ID |
+------+--------+--------+
| 1 | Zhang San | 1 |
| 2 | Li Si | 3 |
| 3 | Wang Wu | 6 |
+------+--------+--------+

Nachdem wir die beiden Tabellen analysiert hatten, stellten wir fest, dass person in der card für cardId -Feld keinen entsprechenden id -Fremdschlüssel enthält. Wenn festgelegt, kann die Zeile mit cardId Kardidfeldwert von 6 person nicht eingefügt werden, da der cardId in card Kartentabelle nicht vorhanden ist.

Innerer Join

Um Daten in diesen beiden Tabellen abzufragen, können Sie INNER JOIN verwenden, um sie miteinander zu verbinden.

- Inner-Join: Zeigt einen inneren Join an, der zwei Tabellen miteinander verbindet.
- ON: Zeigt an, dass eine bestimmte Bedingung ausgeführt werden soll.
Wählen Sie * von Person Inner Join Card auf Person.cardid = card.id;
+------+--------+--------+------+-----------+
| ID | Name | Karten-ID | ID | Name |
+------+--------+--------+------+-----------+
| 1 | Zhang San| 1 | 1 | Essenskarte|
| 2 | Li Si | 3 | 3 | Landwirtschaftliche Bankkarte |
+------+--------+--------+------+-----------+

- Das Ablassen des inneren Schlüsselworts erzeugt das gleiche Ergebnis.
- Wählen Sie * aus der Person Join Card auf Person.cardid = card.id;

Hinweis: Die gesamte card ist rechts verknüpft.

Linker äußerer Join

Die linke Tabelle ( person ) wird vollständig angezeigt und die rechte Tabelle wird angezeigt, wenn sie den Bedingungen erfüllt, sonst wird NULL gefüllt.

- Links-Join wird auch als linke äußere Join bezeichnet.
Wählen Sie * von Person Links -Join -Karte auf Person.cardid = card.id;
+------+--------+--------+------+-----------+
| ID | Name | Karten-ID | ID | Name |
+------+--------+--------+------+-----------+
| 1 | Zhang San| 1 | 1 | Essenskarte|
| 2 | Li Si | 3 | 3 | Landwirtschaftliche Bankkarte |
| 3 | Wang Wu | 6 | NULL | NULL |
+------+--------+--------+------+-----------+

Rechts äußerer Link

NULL Tabelle auf der rechten Seite ( card ) wird vollständig angezeigt.

Wählen Sie * von Person Right Join Card auf Person.cardid = card.id;
+------+--------+--------+------+-----------+
| ID | Name | Karten-ID | ID | Name |
+------+--------+--------+------+-----------+
| 1 | Zhang San| 1 | 1 | Essenskarte|
| 2 | Li Si | 3 | 3 | Landwirtschaftliche Bankkarte |
| NULL | NULL | NULL | 2 | CCB-Karte |
| NULL | NULL | NULL | 4 | Visitenkarte |
| NULL | NULL | NULL | 5 | Postkarte |
+------+--------+--------+------+-----------+

Vollständige externe Links

Zeigen Sie alle Daten in den beiden Tabellen vollständig an.

- MySQL unterstützt keine vollständige Außenverbindung mit dieser Syntax- SELECT * von Person Full Join Card auf Person.cardid = card.id;
- Es ist ein Fehler aufgetreten:
- Fehler 1054 (42S22): Unbekannte Spalte 'Person.Cardid' in 'On-Klausel'

- MySQL Full Join Syntax, wobei Union zwei Tabellen zusammenführt.
Wählen Sie * aus der Person links Join Card auf Person.cardid = card.id
UNION
Wählen Sie * von Person Right Join Card auf Person.cardid = card.id;
+------+--------+--------+------+-----------+
| ID | Name | Karten-ID | ID | Name |
+------+--------+--------+------+-----------+
| 1 | Zhang San| 1 | 1 | Essenskarte|
| 2 | Li Si | 3 | 3 | Landwirtschaftliche Bankkarte |
| 3 | Wang Wu | 6 | NULL | NULL |
| NULL | NULL | NULL | 2 | CCB-Karte |
| NULL | NULL | NULL | 4 | Visitenkarte |
| NULL | NULL | NULL | 5 | Postkarte |
+------+--------+--------+------+-----------+

Transaktionen

In MySQL ist eine Transaktion tatsächlich die kleinste unteilbare Arbeitseinheit. Transaktionen können die Integrität eines Unternehmens sicherstellen .

Zum Beispiel unsere Bankübertragung:

-a -> -100
UPDATE User Set Money = Money - 100 wobei Name = 'a';

-B -> +100
UPDATE User Set Money = Money + 100 wobei Name = 'B';

Wenn in einem tatsächlichen Projekt nur eine SQL -Anweisung erfolgreich ausgeführt wird und die andere fehlschlägt, treten inkonsistente Daten auf.

Bei der Ausführung mehrerer verwandter SQL -Anweisungen muss daher eine Transaktion erforderlich sein, dass diese SQL -Anweisungen entweder gleichzeitig erfolgreich ausgeführt werden oder alle fehlschlagen.

So kontrollieren Sie Transaktionen - Commit / Rollback

In MySQL ist der automatische Transaktionszustand standardmäßig aktiviert.

- Abfragen Sie den automatischen Commit-Status der Transaktion aus @@ autocommit;
+--------------+
|
+--------------+
| 1 |
+--------------+

Die Rolle der automatischen Einreichung : Wenn wir eine SQL -Anweisung ausführen, wird ihr Effekt sofort reflektiert und kann nicht zurückgerollt werden .

Was ist Rollback? Zum Beispiel:

Datenbankbank erstellen;

Bank verwenden;

CREATE TABLE-Benutzer (
  ID INT Primärschlüssel,
  Name VARCHAR(20),
  Geld int
);

In Benutzerwerte einfügen (1, 'a', 1000);

Wählen Sie * vom Benutzer aus;
+----+------+-------+
| ID | Name | Geld |
+----+------+-------+
| 1 | ein | 1000 |
+----+------+-------+

Wie Sie sehen können, wirkt sich die Daten unmittelbar nach der Ausführung der Einfügeanweisung in Kraft, da die Transaktion in MySQL sie automatisch in die Datenbank anpasst . Der sogenannte Rollback bedeutet, alle SQL-Anweisungen, die ausgeführt wurden, rückgängig zu machen und sie zurück in den Zustand zu rollen, als die Daten zuletzt übermittelt wurden .

Verwenden Sie ROLLBACK , um einen Rollback in MySQL durchzuführen:

- Rollen Sie zurück zum letzten Leitfadenrollback;

Wählen Sie * vom Benutzer aus;
+----+------+-------+
| ID | Name | Geld |
+----+------+-------+
| 1 | ein | 1000 |
+----+------+-------+

Da alle ausgeführten SQL -Anweisungen eingereicht wurden, wurden die Daten nicht zurückgerollt. Wie können die Daten zurückgerollt werden?

-- Automatisches Commit deaktivieren SET AUTOCOMMIT = 0;

- Abfragen Sie den automatischen Commit-Status aus @@ AutoCommit;
+--------------+
|
+--------------+
| 0 |
+--------------+

Nach dem Ausschalten des AutoCommit werden die Testdaten zurückgerollt:

In Benutzerwerte einfügen (2, 'B', 1000);

- Nach dem Ausschalten des Autokommitas werden Datenänderungen in einer virtuellen temporären Datentabelle angezeigt.
- Die geänderten Daten werden nicht tatsächlich in die Datentabelle eingefügt.
Wählen Sie * vom Benutzer aus;
+----+------+-------+
| ID | Name | Geld |
+----+------+-------+
| 1 | ein | 1000 |
| 2 | b | 1000 |
+----+------+-------+

- Die tatsächlichen Daten in der Datentabelle sind tatsächlich:
+----+------+-------+
| ID | Name | Geld |
+----+------+-------+
| 1 | ein | 1000 |
+----+------+-------+

- Da die Daten nicht tatsächlich begangen wurden, können Sie Rollback verwenden.

- Wählen Sie erneut * vom Benutzer aus;
+----+------+-------+
| ID | Name | Geld |
+----+------+-------+
| 1 | ein | 1000 |
+----+------+-------+

Wie können Sie die virtuellen Daten tatsächlich an die Datenbank senden? Verwenden von COMMIT :

In Benutzerwerte einfügen (2, 'B', 1000);
- Manuell Daten (Persistenz), manuell einreichen,
- Senden Sie die Daten in die Datenbank.
BEGEHEN;

- Rollback-Rollback nach dem Verhalten;

- erneut abfragen (Rollback ist ungültig)
Wählen Sie * vom Benutzer aus;
+----+------+-------+
| ID | Name | Geld |
+----+------+-------+
| 1 | ein | 1000 |
| 2 | b | 1000 |
+----+------+-------+

Zusammenfassen
Automatikübermittlung
Überprüfen Sie den Status des automatischen Untergangs: SELECT @@AUTOCOMMIT ;
Setzen Sie den AutoCommit -Status: SET AUTOCOMMIT = 0 .
Manuelle Einreichung
Wenn @@AUTOCOMMIT = 0 , verwenden Sie den Befehl COMMIT , um die Transaktion zu begehen.
Transaktionsrollback
Wenn @@AUTOCOMMIT = 0 , verwenden Sie den Befehl ROLLBACK , um die Transaktion zurückzurollen.

Für die praktische Anwendung von Transaktionen kehren wir zum Bankübertragungsprojekt zurück:

- Überweisen von UNTEREMENDEN UNSERE SETELE MONEY = Geld - 100 wobei name = 'a';

- UPPATE User Set Money = Money + 100 wobei Name = 'B';

Wählen Sie * vom Benutzer aus;
+----+------+-------+
| ID | Name | Geld |
+----+------+-------+
|
|
+----+------+-------+

Wenn während der Übertragung ein Unfall auftritt, können Sie ROLLBACK zum letzten eingereichten Zustand zurückführen:

-Während des Transfers geschieht etwas Unerwartetes und muss zurückgerollt werden.
ROLLBACK;

Wählen Sie * vom Benutzer aus;
+----+------+-------+
| ID | Name | Geld |
+----+------+-------+
| 1 | ein | 1000 |
| 2 | b | 1000 |
+----+------+-------+

Zu diesem Zeitpunkt sind wir vor dem Unfall zurück im Staat, dh die Transaktion bietet uns die Möglichkeit, es zu bereuen. Unter der Annahme, dass nichts Unerwartetes mit den Daten passiert, können Sie die Daten manuell an die Tabelle verpflichten: COMMIT .

Starten Sie manuell eine Transaktion - Beginnen- / Starttransaktion

Nachdem der Standardausschuss der Transaktion eingeschaltet wurde ( @@AUTOCOMMIT = 1 ), kann Transaktionsrollback nicht verwendet werden. Wir können aber auch ein Transaktionsereignis manuell starten, damit es zurückgerollt werden kann:

- Verwenden Sie Beginn oder Start-Transaktion, um eine Transaktion manuell zu starten- Starttransaktion;
BEGINNEN;
UPDATE User Set Money = Money - 100 wobei Name = 'a';
UPDATE User Set Money = Money + 100 wobei Name = 'B';

-Da die manuell geöffnete Transaktion nicht automatisch eingeschaltet ist, hat sich nicht eingeschaltet,
- Die zu diesem Zeitpunkt geänderten Daten werden in einer temporären Tabelle weiterhin gespeichert.
Wählen Sie * vom Benutzer aus;
+----+------+-------+
| ID | Name | Geld |
+----+------+-------+
|
|
+----+------+-------+

- Rollback Rollback;

Wählen Sie * vom Benutzer aus;
+----+------+-------+
| ID | Name | Geld |
+----+------+-------+
| 1 | ein | 1000 |
| 2 | b | 1000 |
+----+------+-------+

COMMIT wird immer noch verwendet, um Daten nach der Einreichung einzureichen.

BEGINNEN;
UPDATE User Set Money = Money - 100 wobei Name = 'a';
UPDATE User Set Money = Money + 100 wobei Name = 'B';

Wählen Sie * vom Benutzer aus;
+----+------+-------+
| ID | Name | Geld |
+----+------+-------+
|
|
+----+------+-------+

-Submit-Datenbeschaffung;

- Testen Sie Rollback (ungültig, weil die Tabellendaten begangen wurden)
ROLLBACK;

Säureeigenschaften und Verwendung von Transaktionen

Vier Merkmale von Transaktionen:

Eine Atomizität : Eine Transaktion ist die kleinste Einheit und kann nicht geteilt werden;
C Konsistenz : SQL -Anweisungen in derselben Transaktion müssen gleichzeitig erfolgreich sein oder fehlschlagen.
I Isolation : Transaktion 1 und Transaktion 2 sind voneinander isoliert.
D Persistenz : Sobald eine Transaktion endet ( COMMIT ), kann sie nicht zurückgegeben werden ( ROLLBACK ).

Transaktionsisolierung

Die Transaktionsisolierung kann in vier Typen unterteilt werden (Leistung von niedrig bis hoch) :

LESEN SIE UNVERBINDLICH
Bei mehreren Transaktionen kann jede Transaktion die nicht übereinstimmenden Daten anderer Transaktionen erkennen.
LESEN SIE ENGAGIERT
Nur Daten, die von anderen Transaktionen begangen wurden, können gelesen werden.
Wiederholbares Lesen (wiederholbares Lesen)
Wenn mehrere Verbindungen Transaktionen eröffnet haben, können Datensätze nicht zwischen Transaktionen geteilt werden.
SERIALISIERBAR
Alle Transaktionen werden in fester Reihenfolge ausgeführt , und der Schreibbetrieb der nächsten Transaktion wird nach Abschluss einer Transaktion ausgeführt.

Zeigen Sie die Standard -Isolationsstufe der aktuellen Datenbank an:

- Für MySQL 8.x gibt Global die Systemebene an, und kein Global zeigt die Sitzungsstufe an.
Wählen Sie @@ Global.transaction_isolation;
Wählen Sie @@ Transaction_isolation;
+--------------------------------+
|. @@ Global.transaction_isolation |
+--------------------------------+
|.
+--------------------------------+

- Mysql 5.x
Wählen Sie @@ Global.tx_isolation;
Wählen Sie @@ Tx_isolation;

Um die Isolationsstufe zu ändern:

- Setzen Sie die Systemisolationsstufe.
Setzen Sie die globale Transaktions -Isolationsstufe, die unbekannt ist.

- Abfragen Sie die Systemisolationsstufe und stellen Sie fest, dass es geändert wurde.
Wählen Sie @@ Global.transaction_isolation;
+--------------------------------+
|. @@ Global.transaction_isolation |
+--------------------------------+
| LESEN-UNCOMMITTED |
+--------------------------------+

Schmutzige Lektüre

Test Lesen Sie die nicht verbindliche Isolation:

In Benutzerwerte einfügen (3, 'Xiaoming', 1000);
In Benutzerwerte einfügen (4, 'Taobao Store', 1000);

Wählen Sie * vom Benutzer aus;
+----+-----------+-------+
| ID | Name | Geld |
+----+-----------+-------+
|
|
|
|
+----+-----------+-------+

- Starten Sie eine Transaktion, um Daten zu betreiben- Angenommen, Xiao Ming hat in einem Taobao-Geschäft ein Paar Schuhe für 800 Yuan gekauft:
TRANSAKTION STARTEN;
UPDATE User Set Money = Money - 800 wobei name = 'xiao ming';
UPDATE User Set Money = Geld + 800 Wobei Name = 'Taobao Store';

-Der Taobao-Laden überprüft dann das Ergebnis auf der anderen Seite und stellt fest, dass das Geld eingegangen ist.
Wählen Sie * vom Benutzer aus;
+----+-----------+-------+
| ID | Name | Geld |
+----+-----------+-------+
|
|
|
|
+----+-----------+-------+

Da die Übertragung von Xiao Ming bei einer neu eröffneten Transaktion durchgeführt wird und das Ergebnis der Operation durch andere Transaktionen (das Taobao -Geschäft der anderen Partei) erfolgt, ist das Abfrageergebnis des Taobao -Geschäfts korrekt und der Taobao -Geschäft bestätigt die Quittung. Aber in diesem Moment, wenn Xiao Ming den ROLLBACK -Befehl in der Transaktion ausführt, in der er sich befindet, was wird dann passieren?

- Transaktionsrollback von Xiao Ming;

- Egal wer die andere Partei ist, wenn Sie die Ergebnisse erneut durchsuchen, werden Sie feststellen:
Wählen Sie * vom Benutzer aus;
+----+-----------+-------+
| ID | Name | Geld |
+----+-----------+-------+
|
|
|
|
+----+-----------+-------+

Dies wird als schmutziges Lesen bezeichnet, bei dem eine Transaktion Daten liest, die von einer anderen Transaktion nicht begangen wurden. Dies ist in der tatsächlichen Entwicklung nicht erlaubt.

Lesen Sie Commitment

Stellen Sie die Isolationsstufe auf, um festgelegt zu lesen :

Setzen Sie die globale Transaktions -Isolationsstufe Lesen Sie fest;
Wählen Sie @@ Global.transaction_isolation;
+--------------------------------+
|. @@ Global.transaction_isolation |
+--------------------------------+
| GELESEN-ENGAGIERT |
+--------------------------------+

Auf diese Weise können sie, wenn neue Transaktionsverbindungen eingehen, nur die übermittelten Transaktionsdaten abfragen. Für die aktuelle Transaktion sehen sie jedoch immer noch nicht übereinstimmende Daten, beispielsweise:

- Betriebsdatentransaktion (aktuelle Transaktion)
TRANSAKTION STARTEN;
UPDATE User Set Money = Money - 800 wobei name = 'xiao ming';
UPDATE User Set Money = Geld + 800 Wobei Name = 'Taobao Store';

- Obwohl die Isolationsstufe in der aktuellen Transaktion verpflichtet ist
- Es wird immer noch die vorübergehend geänderten Daten in der Datentabelle angezeigt, nicht die tatsächlich übermittelten Daten.
Wählen Sie * vom Benutzer aus;
+----+-----------+-------+
| ID | Name | Geld |
+----+-----------+-------+
|
|
|
|
+----+-----------+-------+


- Angenommen, zu diesem Zeitpunkt wird eine neue Transaktion aus der Ferne geöffnet und mit der Datenbank verbunden.
$ mysql -u root -p12345612

- Zu diesem Zeitpunkt kann die von der Remoteverbindung abgefragte Daten nur der eingereichte Auswahl * vom Benutzer sein.
+----+-----------+-------+
| ID | Name | Geld |
+----+-----------+-------+
|
|
|
|
+----+-----------+-------+

Es gibt jedoch immer noch ein Problem damit. Zum Beispiel:

- Als Xiao Zhang die Daten abfragte, stellte er fest:
Wählen Sie * vom Benutzer aus;
+----+-----------+-------+
| ID | Name | Geld |
+----+-----------+-------+
|
|
|
|
+----+-----------+-------+

- Bevor Xiao Zhang den Durchschnittswert von Geld in der Tabelle berechnete, führte Xiao Wang eine Operation durch:
TRANSAKTION STARTEN;
In Benutzerwerte einfügen (5, 'C', 100);
BEGEHEN;

- Die tatsächlichen Daten der Tabelle zu diesem Zeitpunkt sind:
Wählen Sie * vom Benutzer aus;
+----+-----------+-------+
| ID | Name | Geld |
+----+-----------+-------+
|
|
|
|
|
+----+-----------+-------+

- Wenn Xiao Zhang den Durchschnittswert erneut berechnet, ist die Berechnung inkonsistent:
Wählen Sie AVG (Geld) vom Benutzer aus;
+------------+
| Avg (Geld) |
+------------+
|
+------------+

Obwohl Leseding es uns ermöglicht, nur Daten zu lesen, die von anderen Transaktionen verpflichtet wurden, gibt es immer noch ein Problem . Dies wird als nicht wiederholbares Lesen bezeichnet (Lesen Sie verpflichtet) .

Phantom lesen

Stellen Sie die Isolationsstufe auf wiederholbares Lesen ein (wiederholbares Lesen) :

Legen Sie die globale Transaktions -Isolationsebene wiederholbares Lesen ein;
Wählen Sie @@ Global.transaction_isolation;
+--------------------------------+
|. @@ Global.transaction_isolation |
+--------------------------------+
| WIEDERHOLBARES LESEN |
+--------------------------------+

Um wiederholbares Lesen zu testen, nehmen Sie an, dass START TRANSACTION auf zwei verschiedenen Verbindungen ausgeführt wird:

- Xiao Zhang-Chengdu-Starttransaktion;
In Benutzerwerte einfügen (6, 'D', 1000);

- Xiao Wang - Peking Start -Transaktion;

- Xiao Zhang-Chengdu Commit;

Nachdem die aktuelle Transaktion gestartet wurde, kann sie nicht vor ihrer Verpflichtung abgefragt werden, kann jedoch nach dem Verpflichtung abgefragt werden. Wenn jedoch andere Transaktionen vor dem Commit geöffnet werden, wird die derzeit betriebene Verbindung in dieser Transaktionslinie nicht abgefragt. Es ist gleichbedeutend mit dem Öffnen eines separaten Threads.

Unabhängig davon, ob Xiao Zhang COMMIT abgeschlossen hat, kann Xiao Wang die Transaktionsaufzeichnungen von Xiao Zhang nicht abfragen, sondern nur die Aufzeichnungen seiner eigenen Transaktion:

Wählen Sie * vom Benutzer aus;
+----+-----------+-------+
| ID | Name | Geld |
+----+-----------+-------+
|
|
|
|
|
+----+-----------+-------+

Dies liegt daran, dass Xiao Wang zuvor eine neue Transaktion ( START TRANSACTION ) gestartet hat , sodass die Linie seiner neuen Transaktion nicht mit anderen Transaktionen verbunden ist .

Tatsache ist jedoch, dass Xiao Zhang bereits einen Datensatz in die reale Datentabelle eingefügt hat. Aber Xiao Wang wusste das zu diesem Zeitpunkt nicht und fügte auch die gleichen Daten ein.

In Benutzerwerte einfügen (6, 'D', 1000);
- Fehler 1062 (23000): Duplikateintrag '6' für den Schlüssel 'Primär' '

Es wurde ein Fehler gemeldet, und die Operation wurde darüber informiert, dass bereits ein Feld mit Primärschlüssel 6 vorhanden war. Dieses Phänomen wird auch als Phantom Read bezeichnet, wobei die durch eine Transaktion eingereichten Daten von anderen Transaktionen nicht gelesen werden können .

Serialisierung

Wie der Name schon sagt, werden alle Schreibvorgänge von Transaktionen serialisiert. Was bedeutet das? Ändern Sie die Isolationsstufe in serialisierbar :

Setzen Sie globale Transaktions -Isolationsniveaus serialisierbar;
Wählen Sie @@ Global.transaction_isolation;
+--------------------------------+
|. @@ Global.transaction_isolation |
+--------------------------------+
| SERIALISIERBAR |
+--------------------------------+

Nehmen wir Xiao Zhang und Xiao Wang als Beispiele:

- Xiao Zhang-Chengdu-Starttransaktion;

- Xiao Wang - Peking Start -Transaktion;

- Fragen Sie die Tabelle vor, bevor Sie die Transaktion starten, und bereiten Sie sich auf den Betrieb der Daten vor.
Wählen Sie * vom Benutzer aus;
+----+-----------+-------+
| ID | Name | Geld |
+----+-----------+-------+
|
|
|
|
|
|
+----+-----------+-------+

- Es stellte fest, dass es keine Nr. 7 Wang Xiaohua gibt. Fügen Sie also ein Datenstück ein:
In Benutzerwerte einfügen (7, '王小花', 1000);

Was passiert an diesem Punkt? Da die aktuelle Isolationsstufe serialisierbar ist, bedeutet Serialisierungsmittel: Angenommen, alle Transaktionen werden in einer seriellen Warteschlange platziert, werden alle Transaktionen in einer festen Reihenfolge ausgeführt und der Schreibbetrieb der nächsten Transaktion wird nach Abschluss einer Transaktion ausgeführt ( dies bedeutet, dass nur eine Transaktionsbetriebsbetrieb im Vordergrund ausgeführt werden kann .

Nach dieser Erklärung wird er, wenn Xiao Wang Daten einfügt, in einem Wartezustand sein, bis Xiao Zhang sich COMMIT , die Transaktion zu beenden, in der er sich befindet, oder die Wartezeitübergänge erfolgt.

Leser, die an weiteren MySQL-bezogenen Inhalten interessiert sind, können sich die folgenden Themen auf dieser Site ansehen: „MySQL-Abfragekenntnisse“, „Zusammenfassung der allgemeinen MySQL-Funktionen“, „MySQL-Protokolloperationskenntnisse“, „Zusammenfassung der MySQL-Transaktionsoperationskenntnisse“, „MySQL-gespeicherte Prozedurkenntnisse“ und „Zusammenfassung der MySQL-Datenbanksperrenkenntnisse“.

Ich hoffe, dass dieser Artikel für jedermann beim Entwurf einer MySQL-Datenbank hilfreich ist.

Das könnte Sie auch interessieren:

Analyse einiger Wissenspunkte über den Unterschied zwischen MySQLI und MySQL in PHP
Zusammenfassung der grundlegenden MySQL-Kenntnisse
Zusammenfassung der Wissenspunkte zur MySQL-Architektur
MySQL Join Query Prinzip Knowledge Punkte
MySQL-Wissenspunkte und häufig verwendete MySQL-Befehle für die Computerprüfung der zweiten Ebene
Zusammenfassung von MySQL ALDER -Befehlswissenpunkten
Zusammenfassung des Grundwissens und der Operationen der MySQL -Datenbank
Zusammenfassung der Wissenspunkte zum B-Tree-Index bei der MySQL-Optimierung
MySql-Wissenspunkte: Transaktion, Index, Sperrprinzip und Nutzungsanalyse

<<: So verwenden Sie CSS-Variablen in JS

>>: Detaillierte Erklärung zum Erstellen eines CDN-Servers mit Nginx (Bild und Text)