MySQL häufig verwendete SQL und Befehle vom Eintrag bis zum Löschen der Datenbank und zum Weglaufen

Tabelle erstellen Tabellenname(
	Spaltenname 1 Datentyp 1,
	Spaltenname 2 Datentyp 2,
	....
	Spaltenname n Datentyp n
	);

in Benutzer2-Werte einfügen (1, '李四', '123'); // Löschen von Haustier hinzufügen, wobei ower = 'disn'; // Löschen, Aktualisieren, Haustier, Name festlegen = '后裔', wobei ower = 'dfn'; // ändern

①> 、< 、<= 、>= 、= 、<>	
②ZWISCHEN...UND	
③ IN (Sammlung)	
④LIKE Fuzzy-Abfrage	
⑤_Ein einzelnes beliebiges Zeichen ⑥%Mehrere beliebige Zeichen ⑦IS NULL 
⑧und oder &&
⑨oder oder|| 
⑩nicht oder!
Beispiele für Abfragebedingungen:
SELECT * FROM Benutzer WHERE Alter >= 18;
SELECT * FROM Benutzer WHERE Alter >= 18 AND Alter <=36;
SELECT * FROM Benutzer, wobei Alter zwischen 40 und 70 liegt;
SELECT * FROM Benutzer WHERE Alter IN (6,18,37);
// Über NULL
SELECT * FROM user WHERE height = NULL; Fehler, da Nullwert nicht = oder (!=) verwenden kann. Beurteilung SELECT * FROM user WHERE height IS NULL; (korrekt)
SELECT * FROM user WHERE height IS NOT NULL; (korrekt)
// Abfrage, wer den Nachnamen Chen hat? < wie>
SELECT * FROM Benutzer WHERE NAME LIKE '陈%';
// Personen abfragen, deren zweiter Buchstabe im Namen neu ist. SELECT * FROM user WHERE NAME LIKE "_新%";
// Personen abfragen, deren Namen drei Zeichen lang sind. SELECT * FROM user WHERE NAME LIKE '___';
// Personen abfragen, deren Namen „Hund“ enthalten. SELECT * FROM user WHERE NAME LIKE '%狗%';

 Tabelle Benutzer erstellen (
	id int primary key auto_increment, // Wenn Sie eine Tabelle erstellen, fügen Sie eine Primärschlüsseleinschränkung hinzu und vervollständigen Sie die automatische Primärschlüsselinkrementierung	
	Name varchar(20)
 );
-- Zusammengesetzter Primärschlüssel: Ein Primärschlüssel, der aus mehreren Feldern besteht, solange sich die Summe der zusammengesetzten Primärschlüssel nicht wiederholt. Kein Feld im zusammengesetzten Primärschlüssel darf leer sein.
Tabelle user2 erstellen (
 	Ich würde int,
 	Name varchar(20),
 	Passwort varchar(20),
 	Primärschlüssel (ID, Name)
);

 Tabelle user1 erstellen (
 	ID int Primärschlüssel auto_increment,
 	Telefonnummer varchar(20) eindeutig
 	 );
 Tabelle user2 erstellen (
 	ID int Primärschlüssel auto_increment,
 	Name varchar(20),
 	unique(id, name) // bedeutet, dass die beiden Felder nicht zusammen wiederholt werden );
 	 

Tabelle user3 erstellen (
	ID int Primärschlüssel auto_increment,
	Name varchar(20) nicht null
	);

Tabelle erstellen user4(
	ID int Primärschlüssel auto_increment,
	Alter int Standard 18,
	Name varchar(20) nicht null
	);

Tabelle erstellen Tabellenname(
....
Fremdschlüsselspalteneinschränkung Fremdschlüsselname Fremdschlüssel (Fremdschlüsselspaltenname) Referenzen Primärtabellenname (Primärtabellenspaltenname)
);
//Klasse Tabellenklassen erstellen(
	id int Primärschlüssel,
	Name varchar(20)
	);	
// Studententabelle Tabelle Student erstellen (
		id int Primärschlüssel,
		Name varchar(20),
		Klassen-ID int,
		Fremdschlüssel (Klassen-ID) verweist auf Klassen (ID)
		);
		

Alle Datensätze abfragen. Beispiel: Alle Datensätze in der Studententabelle abfragen.

wähle * vom Studenten;

Fragen Sie die angegebenen Felder ab, zum Beispiel: Abfrage Sname, Ssex, Klasse im Student.

Wählen Sie Nachnamen, Geschlecht und Klasse des Schülers aus.

Abfrage aller Einheiten in der Lehrertabelle, also der eindeutigen Abgangsspalte. <Duplikate eindeutig ausschließen>

wählen Sie einen anderen Kurs als den des Lehrers;

Abfrage aller Datensätze in der Punktetabelle, deren Punktestand zwischen 60 und 80 liegt <Abfrageintervall zwischen... und...>

Wählen Sie * aus der Punktzahl, bei der der Abschluss zwischen 60 und 80 liegt;
Wählen Sie * aus der Punktzahl, bei der der Grad > 60 und der Grad < 80 ist;

Fragen Sie die Datensätze mit den Punktzahlen 85, 86 oder 88 in der Punktzahltabelle ab. Wählen Sie „* from score where degree in(85, 86, 88);“

Abfrage der Studententabelle nach Studenten der Klasse „95031“ oder deren Geschlecht „weiblich“ ist. <oder bedeutet entweder>

Wählen Sie *von Student, wobei Klasse = „95031“ oder Geschlecht = „Mädchen“ ist;

Abfrage aller Datensätze in der Studententabelle in absteigender Reihenfolge der Klasse <desc, asc, standardmäßig aufsteigend (ausgelassen)>.

Wählen Sie * aus der Reihenfolge der Studenten nach Klasse absteigend aus;

Fragen Sie alle Datensätze in der Punktetabelle in aufsteigender Reihenfolge der CNO und absteigender Reihenfolge des Grades ab. Wählen Sie * aus der Punktereihenfolge nach CNO asc,degree desc;

Abfrage der Schüleranzahl in Klasse "95031" <Statistikzählung>

Wählen Sie Anzahl(*) aus dem Studenten, wobei Klasse = „95031“ ist.
Abfrage der Matrikel-ID und Kurs-ID des Studenten mit der höchsten Punktzahl in der Punktetabelle (Unterabfrage)

Wählen Sie sno, cno aus der Punktzahl, wobei Grad = (Wählen Sie max(Grad) aus der Punktzahl); wobei: Wählen Sie max(Grad) aus der Punktzahl, um zuerst die höchste Punktzahl zu finden.

select sno,cno degree from score order by degree desc limit 0,1; wobei: die erste Zahl von limit den Startpunkt angibt und die zweite Zahl die Anzahl der Einträge. Bei mehreren identischen Höchstpunktzahlen treten wahrscheinlich Fehler auf, daher wird diese Abfragemethode nicht empfohlen.

Fragen Sie die Durchschnittsnote jedes Kurses ab. Wählen Sie „cno“, „avg(degree)“ aus der Notengruppe nach „cno“ aus.

Abfrage der Durchschnittsnote der Kurse aus der Punktetabelle, die von mindestens 2 Studierenden belegt werden und bei 3 beginnen.

Wählen Sie cno, Durchschnitt (Grad) aus der Punktegruppe nach cno mit count(cno) >= 2 und cno wie ,3 %‘.

Fragen Sie die SNO-Spalte mit Wertungen größer als 70 und kleiner als 90 ab.

Wählen Sie SNO, Grad aus der Punktzahl, wobei der Grad zwischen 70 und 90 liegt;
Fragen Sie die Spalten „sname“, „cno“ und „degree“ aller Studenten ab.
Wählen Sie Sname, CNO, Abschluss von Student, Punktzahl, wobei student.sno = Punktzahl.sno;
Fragen Sie die Spalten „sno“, „cname“ und „degree“ aller Studenten ab. Wählen Sie „sno, cname, degree“ aus „course“, „score“, wobei „course.cno“ = „score.cno“ ist.
Fragen Sie die Durchschnittsnote jedes Kurses für Studierende im Kurs „95031“ ab.
Wählen Sie cno, Durchschnitt (Abschluss) aus der Punktzahl, wobei sno in (Wählen Sie sno vom Studenten, wobei Klasse = „95031“ ist), gruppieren Sie nach cno;
Abfrage der Datensätze aller Studenten, die den Wahlkurs "3-105" belegt haben und deren Punktzahl höher ist als die des Studenten Nr. "109" in "3-105".
Wählen Sie * aus der Punktzahl, wobei cno = „3-105“ und Grad > (Wählen Sie den Grad aus der Punktzahl, wobei sno = „109“ und cno = „3-105“);
Abfrage aller Datensätze, deren Punktzahl höher ist als die des Studenten mit der Matrikelnummer „109“ und der Kursnummer „3-105“ select * from score where degree > (select degree from score where sno = ‚109‘ and cno = ‚3-105‘);
Abfrage aller SNO, SNAME, SBIRTHDAY von Studenten, die im selben Jahr wie Matrikelnummer 108.101 geboren sind
wähle *von Student, wo Jahr(Geburtstag) in (wähle Jahr(Geburtstag) von Student, wo Geburtstag in(108, 101));
Fragen Sie die Noten der vom Lehrer „Zhang Xu“ unterrichteten Schüler ab. Wählen Sie * aus der Punktzahl, wobei cno = (Wählen Sie cno aus dem Kurs, wobei tno = (Wählen Sie tno aus dem Lehrer, wobei tname = „Zhang Xu“));
Abfrage der Namen von Lehrern, deren Schülerzahl an einem Kurs mehr als 5 beträgt.
Wählen Sie tname vom Lehrer, wobei tno = (Wählen Sie tno vom Kurs, wobei cno = (Wählen Sie cno aus der Punktegruppe nach cno mit Anzahl(*) > 5));
Abfrage bei den CNOs für Kurse mit Punktzahlen über 85
Wählen Sie cno, Grad aus der Punktzahl, wobei der Grad > 85 ist;
Abfrage der Punktetabelle der Kurse, die von Lehrern der „Abteilung Informatik“ unterrichtet werden. Wählen Sie * aus der Punktzahl, wobei cno in (wählen Sie cno aus dem Kurs, wobei tno in (wählen Sie tno aus dem Lehrer, wobei depart = „Abteilung Informatik“));
Abfrage von CNO, SNO und Abschluss von Studierenden, die die Wahlpflichtfachnummer „3-105“ belegt haben und deren Noten mindestens besser sind als die der Wahlpflichtfachnummer „3-245“, und Sortierung dieser absteigend nach Abschluss.
irgendeins, mindestens eins.

Wählen Sie * aus der Punktzahl, wobei cno = „3-105“ und Grad > beliebig (wählen Sie den Grad aus der Punktzahl, wobei cno = „3-245“), sortieren Sie nach Grad absteigend;

Wählen Sie * aus der Punktzahl, wobei cno = „3-105“ und Grad > alles (wählen Sie den Grad aus der Punktzahl, wobei cno = „3-245“), sortieren Sie nach Grad absteigend;

Wählen Sie * aus Punktzahl A, wobei Grad < (Wählen Sie Durchschnitt (Grad) aus Punktzahl B, wobei a.cno = b.cno);
Tabelle a
+-----+-------+--------+
| sno | cno | Grad |
+-----+-------+--------+
| 101 | 3-105 | 91 |
| 102 | 3-105 | 92 |
| 103 | 3-105 | 92 |
| 103 | 3-245 | 86 |
| 103 | 6-166 | 85 |
| 104 | 3-105 | 81 |
| 105 | 3-105 | 88 |
| 105 | 3-245 | 75 |
| 105 | 6-166 | 79 |
| 109 | 3-105 | 76 |
| 109 | 3-245 | 68 |
| 109 | 6-166 | 81 |
+-----+-------+--------+
12 Zeilen im Satz (0,00 Sek.) 

Tabelle b
| sno | cno | Grad |
+-----+-------+--------+
| 101 | 3-105 | 91 |
| 102 | 3-105 | 92 |
| 103 | 3-105 | 92 |
| 103 | 3-245 | 86 |
| 103 | 6-166 | 85 |
| 104 | 3-105 | 81 |
| 105 | 3-105 | 88 |
| 105 | 3-245 | 75 |
| 105 | 6-166 | 79 |
| 109 | 3-105 | 76 |
| 109 | 3-245 | 68 |
| 109 | 6-166 | 81 |
+-----+-------+--------+
12 Zeilen im Satz (0,00 Sek.) 

Datenaufbereitung für analytische Anwendungsfälle:
mysql> wähle * von Person;
+----+--------+--------+
| ID | Name | Karten-ID |
+----+--------+--------+
| 1 | Zhang San | 1 |
| 2 | Li Si | 3 |
| 3 | Wang Wu | 6 |
+----+--------+--------+
3 Zeilen im Satz (0,00 Sek.)
mysql> wähle * von Karte;
+------+----------+
| Ich würde | Name |
+------+----------+
| 1 | Essenskarte|
| 2 | CCB-Karte|
| 3 | Landwirtschaftliche Bankkarte|
| 4 | Visitenkarte|
| 5 | Postkarte |
+------+----------+
5 Zeilen im Satz (0,00 Sek.)

Wählen Sie * aus der inneren Person-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 |
+----+--------+--------+------+-----------+
2 Zeilen im Satz (0,00 Sek.)

Wählen Sie * von der linken Person aus, um die Karte beizutreten, 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 |
+----+--------+--------+------+-----------+
3 Zeilen im Satz (0,00 Sek.)

Wählen Sie * von der richtigen Person aus, um die Karte mit person.cardId = card.id zu verbinden.

+------+--------+--------+------+-----------+
| 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 |
+------+--------+--------+------+-----------+
5 Zeilen im Satz (0,01 Sek.)

mysql> wähle * von Person, vollständige Join-Karte auf person.cardId= card.id;
FEHLER 1054 (42S22): Unbekannte Spalte „person.cardId“ in „on-Klausel“
**** So lösen Sie das Problem, dass MySQL keinen vollständigen Join unterstützt ****
 <Linke Verbindung + rechte Verbindung>, das heißt, die linke und rechte Verbindung durch Vereinigung verbinden. <Linke Verbindung Vereinigung rechte Verbindung>.
z.B:

Wählen Sie * von der linken Person aus, und verbinden Sie die Karte mit person.cardId = card.id. Union. Wählen Sie * von der rechten Person aus, und verbinden Sie die Karte mit 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 |
+------+--------+--------+------+-----------+
6 Zeilen im Satz (0,01 Sek.)

MySQL führt Anweisungen in einer strengen Reihenfolge aus und kann die Select-Anweisung nicht ändern.
aus
Wo
Gruppieren nach
haben
Bestellen bis

Zum Beispiel:
ein --> -100
Benutzersatz aktualisieren: Geld = Geld – 100, wobei Name = „a“ ist;
b --> +100
Benutzersatz aktualisieren: Geld = Geld + 100, wobei Name = „b“;
-- Wenn im tatsächlichen Programm nur eine SQL-Anweisung erfolgreich ausgeführt wird, die andere jedoch nicht? Dann sind die Daten davor und danach inkonsistent.
Benutzersatz aktualisieren: Geld = Geld – 100, wobei Name = „a“;
Benutzersatz aktualisieren: Geld = Geld + 100, wobei Name = „b“;
Bei mehreren SQL-Anweisungen kann es Anforderungen für gleichzeitigen Erfolg oder gleichzeitiges Fehlschlagen geben.

mysql> wählen Sie @@autocommit;
+--------------+
| @@autocommit |
+--------------+
| 1 |
+--------------+
1 Zeile im Satz (0,00 Sek.)
//Tabelle erstellen, Datenbankbank erstellen;
Tabelle Benutzer erstellen (
	id int Primärschlüssel,
 Name varchar(20),
 Geld in
 );
// Fügen Sie zuerst Benutzerdaten a in die Tabelle ein.
in Benutzerwerte einfügen (1, 'a', 1000);
Abfrage OK, 1 Zeile betroffen (0,00 Sek.)
// Führen Sie einen Rollback-Vorgang durch.
mysql> Rollback;
Abfrage OK, 0 Zeilen betroffen (0,00 Sek.)
// Überprüfen Sie nach dem Ausführen des Rollbacks die Datentabelleninformationen und stellen Sie fest, dass die eingefügten Daten auch dann noch vorhanden sind, wenn das Rollback aufgerufen wird. Dies bedeutet, dass ein Rollback derzeit nicht möglich ist.
mysql> wähle * vom Benutzer aus;
+----+------+-------+
| ID | Name | Geld |
+----+------+-------+
| 1 | ein | 1000 |
+----+------+-------+
1 Zeile im Satz (0,00 Sek.)
// Sie können das Rollback-Auto-Commit von msql auf „False“ setzen.
setze Autocommit = 0;
Abfrage OK, 0 Zeilen betroffen (0,00 Sek.)
mysql> wählen Sie @@autocommit;
+--------------+
| @@autocommit |
+--------------+
| 0 |
+--------------+
1 Zeile im Satz (0,00 Sek.)
// Mit anderen Worten: Die obige Operation „set autocommit = 0;“ schaltet das automatische Commit von MySQL aus.
*******Daten erneut einfügen:*******
in Benutzerwerte einfügen (2,'b',1000);
Abfrage OK, 1 Zeile betroffen (0,00 Sek.)
//Überprüfen Sie die Tabelle nach dem Einfügen der Daten. Die Daten von Benutzer 2 wurden erfolgreich hinzugefügt.
mysql> wähle * vom Benutzer aus;
+----+------+-------+
| ID | Name | Geld |
+----+------+-------+
| 1 | ein | 1000 |
| 2 | b | 1000 |
+----+------+-------+
2 Zeilen im Satz (0,00 Sek.)
// Führen Sie einen Rollback-Vorgang durch.
mysql> Rollback;
Abfrage OK, 0 Zeilen betroffen (0,00 Sek.)
// Überprüfen Sie nach dem Rollback die Tabelle erneut und stellen Sie fest, dass die gerade eingefügten Daten gelöscht wurden.
mysql> wähle * vom Benutzer aus;
+----+------+-------+
| ID | Name | Geld |
+----+------+-------+
| 1 | ein | 1000 |
+----+------+-------+
1 Zeile im Satz (0,01 Sek.)
**** Wenn Sie in diesem Szenario möchten, dass Benutzer B die Daten erfolgreich übermittelt, können Sie den Befehl „commit;“ verwenden, um eine manuelle Übermittlungsoperation durchzuführen. Wenn Sie die manuelle Übermittlung nach der Übermittlung durch Rollback rückgängig machen möchten, ist dies nicht möglich. Mit anderen Worten: Sobald die Transaktion übermittelt wurde, kann die ausgeführte SQL-Anweisung nicht mehr rückgängig gemacht werden. Dies bedeutet, dass die Daten nach der Übermittlung der Transaktion dauerhaft wirksam sind.

Im Augenblick:
 Der aktuelle Standardmodus ist der Auto-Commit-Modus, und die Ausführung eines Rollbacks ist derzeit ungültig. Führen Sie die folgende SQL-Anweisung aus:
 Transaktion starten; (oder beginnen;)
 Benutzersatz aktualisieren: Geld = Geld – 100, wobei Name = „a“;
 Benutzersatz aktualisieren: Geld = Geld + 100, wobei Name = „b“;
 Führen Sie nach dem Einfügen der Benutzerdaten a und b erneut ein Rollback aus und stellen Sie fest, dass die Transaktion erfolgreich zurückgesetzt werden kann. Sie können erfolgreich in den Modus zum manuellen Öffnen von Transaktionen wechseln. Wenn Sie möchten, dass die eingefügten Daten wirksam werden, müssen Sie auch manuell ein Commit ausführen, um den Vorgang festzuschreiben.
 Nachdem die Transaktion gestartet wurde und einmal festgeschrieben ist, kann sie nicht mehr zurückgesetzt werden, d. h., die aktuelle Transaktion ist mit dem Festschreiben beendet.
 

mysql> wähle @@global.transaction_isolation;
+--------------------------------+
| @@global.transaction_isolation |
+--------------------------------+
| WIEDERHOLBARES LESEN |
+--------------------------------+
1 Zeile im Satz (0,00 Sek.)

Zum Beispiel:
Tabelle myorder erstellen(
		Produkt-ID int,
		Kunden-ID int,
		Produktname varchar(20),
		Kundenname varchar(20),
		Primärschlüssel (Produkt-ID, Kunden-ID
	);
	In der aktuellen Tabelle hängen andere Spalten als der Primärschlüssel nur von einigen Feldern des Primärschlüssels ab. Dies erfüllt nicht die zweite Normalform und erfordert normalerweise eine Tabellenaufteilung.
Tabelle myorder erstellen(
		order_id int Primärschlüssel,
		Produkt-ID int,
		Kunden-ID int
	);
Tabelle Produkt erstellen (
		id int Primärschlüssel,
		Name varchar(20)
	);
Tabelle Kunde erstellen(
		id int Primärschlüssel,
		Name varchar(20)
		);
Nach der Aufteilung in drei Tabellen ist die zweite Normalform erreicht.

Tabelle „Student“ erstellen (
	sno varchar(20) Primärschlüssel,
	sname varchar(20) nicht null,
	ssex varchar(20) nicht null,
	Geburtstag, Datum und Uhrzeit,
	Klasse varchar(20)
	);

Tabelle „Student“ erstellen (
	sno varchar(20) Primärschlüssel,
	sname varchar(20) nicht null,
	ssex varchar(10) nicht null,
	Geburtstagsdatum/-zeit,
	Klasse varchar(20)
)

Tabelle Lehrer erstellen(
	tno varchar(20) Primärschlüssel,
	tname varchar(20) nicht null,
	tsex varchar(20) nicht null,
	tGeburtstag Datum/Uhrzeit,
	prof varchar(20) nicht null,
	abreisen varchar(20) nicht null
	);

Tabellenkurs erstellen(
	cno varchar(20) Primärschlüssel,
	cname varchar(20) nicht null,
	tno varchar(20) nicht null,
	Fremdschlüssel (tno) verweist auf Lehrer (tno)
	);

Tabelle erstellen (
	sno varchar(20) nicht null,
	Grad Dezimal,
	Primärschlüssel (sno, cno),
	Fremdschlüssel (sno) verweist auf Student(sno),
	Fremdschlüssel (cno) Referenzen Kurs (cno)
	);

in Studentenwerte einfügen ('101', 'Zeng Hua', 'Männlich', '1977-09-01', '95033');
in Studentenwerte einfügen ('102', '匡明', '男', '1975-10-02', '95031');
in Studentenwerte einfügen ('103', '103', '103', '1976-01-23', '95033');
in Studentenwerte einfügen ('104', '104', '104', '1976-02-20', '95033');
in Studentenwerte einfügen ('105', '王芳', '女', '1975-02-10', '95031');
in Studentenwerte einfügen ('106', '陆君', '男', '1974-06-03', '95031');
in Studentenwerte einfügen ('107', '王尼马', '男', '1976-02-20', '95033');
in Studentenwerte einfügen ('108', 'Studentenname', 'Student', '10.02.1975', '95031');
in Studentenwerte einfügen ('109', '赵铁柱', '男', '1974-06-03', '95031');

in Lehrerwerte einfügen (,804',,Zeit',,Farbe',,1958-12-02',,Zeitraffer',,Zeitrafferfoto');
in Lehrerwerte einfügen (,856',,856',,856',,12.03.1969',,856',,856-Punkte-Quote');
in Lehrerwerte einfügen (,825',,825',,825',,1972-05-05',,825',,825-Punkte-Liste');
in Lehrerwerte einfügen ('831', 'Liu Bing', 'Weiblich', '14.08.1977', 'Lehrassistent', 'Abteilung für Elektrotechnik');

in Kurswerte einfügen ('3-105', 'Einführung in die Informatik', '825');
in Kurswerte einfügen ('3-245', 'Betriebssystem', '804');
in Kurswerte einfügen (,6-166‘,,Digital Circuit‘,,856‘);
in Kurswerte einfügen (,9-888‘,,Höhere Mathematik‘,,831‘);
 
in Score-Werte einfügen('103','3-245','86');
in Score-Werte einfügen('105','3-245','75');
in Score-Werte einfügen('109','3-245','68');
in Score-Werte einfügen('103','3-105','92');
in Score-Werte einfügen('105','3-105','88');
in Score-Werte einfügen('109','3-105','76');
in Score-Werte einfügen('103','3-105','64');
in Score-Werte einfügen('105','6-166','79');
in Score-Werte einfügen('109','6-166','81');


Tabelle Person erstellen(
	ID int Primärschlüssel auto_increment,
	Name varchar(20),
	Karten-ID int
);

Tischkarte erstellen (
	Ich würde int,
	Name varchar(20)
);

in Kartenwerte einfügen (1, ‚Reiskarte‘);
in Kartenwerte einfügen (2, 'ＣＣ银行卡');
in Kartenwerte einfügen (3, „Landwirtschaftliche Bankkarte“);
in Kartenwerte einfügen (4, „Visitenkarte“);
in Kartenwerte einfügen (5, ‚Postkarte‘);

in Personenwerte einfügen (1, '张三',1);
in Personenwerte einfügen (2, '李四',3);
in Personenwerte einfügen (3, '王五', 6);