Verwendung von MySQL DDL-Anweisungen

Verwendung von MySQL DDL-Anweisungen

Vorwort

Die Sprachklassifikation von SQL umfasst im Wesentlichen folgende Typen:

DDL Datendefinitionssprache erstellen, löschen, ändern Anweisungen zum Erstellen, Löschen und Ändern in der Datendefinitionssprache.
DML Datenmanipulationssprache einfügen, löschen, aktualisieren Definieren Sie die Vorgänge zum Hinzufügen, Löschen und Ändern von Datenbankeinträgen.
DQL Datenbankabfragesprache wählen Definiert Abfragevorgänge für Datenbankeinträge.
DCL Datenbank-Steuerungssprache gewähren, entfernen

Definieren Sie Zugriffsrechte und Sicherheitsstufen für Datenbanken, Tabellen, Felder und Benutzer.

(erteilen, widerrufen usw.).

TCL Transaktionskontrollsprache

setze autocommit=0,

Transaktion starten,

Sicherungspunkt, Commit, Rollback

Definiert Transaktionsvorgänge in der Datenbank.

In diesem Abschnitt wird hauptsächlich die Datendefinitionssprache DDL (Data Define Language) vorgestellt. Wir verwenden es, um einige Verwaltungsvorgänge (Erstellen, Löschen, Ändern usw.) an Datenbanken und Tabellen durchzuführen, z. B.: Erstellen einer Datenbank, Löschen einer Datenbank, Erstellen einer Tabelle, Ändern einer Tabelle, Löschen einer Tabelle, Hinzufügen, Löschen und Ändern von Feldern usw. und Verwalten der Datenbank- und Tabellenstruktur.

Als nächstes werden wir sie einzeln erklären (der Inhalt in [] unten ist optional).

Datenbankverwaltung

Erstellen einer Datenbank

Datenbank erstellen [falls nicht vorhanden] dbname;

Löschen einer Datenbank

Datenbanken löschen [falls vorhanden] dbname;

Der vollständige Text lautet wie folgt:

Datenbanken löschen [falls vorhanden] o_dbname;
Datenbank n_dbname erstellen;

o_dbname stellt den alten Datenbanknamen dar und n_dbname stellt den neuen Datenbanknamen dar.

Probieren Sie es aus:

mysql> Datenbanken anzeigen;
+--------------------+
| Datenbank |
+--------------------+
| Informationsschema |
| Käuferpartei |
| Käuferpartei1 |
|git_jeeshop|
| jz |
|
| 0 Kommentare
| lokalesdk |
| Assistentensteuerung |
|mysql |
| Leistungsschema |
| Schlaganfalldaten |
| Prüfung |
+--------------------+
13 Reihen im Set

mysql> Datenbank löschen, falls vorhanden, test1;
Abfrage OK, 0 Zeilen betroffen

mysql> Datenbank test1 erstellen;
Abfrage OK, 1 Zeile betroffen

mysql> Datenbank test1 erstellen;
1007 - Datenbank „test1“ kann nicht erstellt werden; Datenbank existiert

Aus dem obigen Test können wir Folgendes erkennen: Vor dem Löschen müssen wir zunächst feststellen, ob die Datenbank vorhanden ist, da sonst eine Ausnahme gemeldet wird. Gleichzeitig müssen wir vor dem Erstellen auch feststellen, ob sie vorhanden ist. Wenn dies der Fall ist, wird eine Meldung angezeigt, dass sie bereits vorhanden ist.

Tabellenverwaltung

Tabelle erstellen

Das grundlegende Syntaxformat einer Tabelle in der Datenbank ist wie folgt:

 Tabelle tbname erstellen(
 Spaltenname_1 Spaltentyp_1 [(n)] [Einschränkungen] [Kommentar 'Kommentar1'], 
 Spaltenname_2 Spaltentyp_2 [(n)] [Einschränkungen] [Kommentar 'Kommentar2'],
 Spaltenname_3 Spaltentyp_3 [(n)] [Einschränkungen] [Kommentar 'Kommentar3']
 )[Tabellenoptionen];

Syntax

1. column_name bezieht sich auf den Feldnamen; column_type bezieht sich auf den Feldtyp (CHAR, INT usw.); n stellt die Feldbreite dar, die optional ist; constraints sind Einschränkungen, die optional sind; comment ist der Feldkommentar, der das Feld detailliert beschreiben kann.

2. In derselben Tabelle kann column_name nicht gleich sein

3. Feldname und -typ sind erforderlich, die anderen sind optionale Parameter

4. Der Typ begrenzt das Speicherformat des Feldes. Es muss in einem bestimmten Datentyp gespeichert werden und es können zusätzliche Einschränkungen hinzugefügt werden.

Einschränkung Beschreibung

nicht null: Nicht-Null-Einschränkung

mysql> Test verwenden;
Datenbank geändert

mysql> Tabelle erstellen, falls `user1` nicht existiert (Alter int Kommentar 'Alter', Name char(5) Kommentar 'Name' nicht null);
Abfrage OK, 0 Zeilen betroffen

mysql> in Benutzer1-Werte einfügen (8, null);
1048 - Spalte „Name“ darf nicht null sein

Beim Erstellen der Tabelle wird für das Namensfeld eine Nicht-Null-Einschränkung festgelegt. Wenn der übergebene Wert null ist, wird eine Fehlermeldung angezeigt. Der Zweck der Nicht-Leer-Einschränkung besteht also darin, sicherzustellen, dass das Feld nicht leer ist.

Standardwert: Liefert einen Standardwert für das Feld

mysql> Test verwenden;
Datenbank geändert

mysql> Tabelle erstellen, falls `user2` nicht existiert (Alter, Int, nicht null, Standard 0, Kommentar 'Alter', Name, char(50), Kommentar 'Name' nicht null);
Abfrage OK, 0 Zeilen betroffen

mysql> in Benutzer2 (Name) Werte ('Marke') einfügen;
Abfrage OK, 1 Zeile betroffen
mysql> wähle * von Benutzer2;
+-----+--------+
| Alter | Name |
+-----+--------+
| 0 | Marke |
+-----+--------+
1 Reihe im Set

Wenn Sie nach dem Festlegen des Standardwerts beim Schreiben von Daten keinen Wert angeben, wird automatisch der Standardwert 0 übernommen.

Primärschlüssel: Identifiziert die Primärschlüsseleinschränkung und legt dieses Feld als Primärschlüssel der Tabelle fest. Es handelt sich um eine global eindeutige Kennung und es wird ein Fehler gemeldet, wenn ein Duplikat eingefügt wird.

Es gibt zwei Möglichkeiten, dies auszudrücken: Entweder man lässt es direkt in der Feldeinschränkung folgen, oder man fügt es am Ende hinzu, nachdem alle Felder deklariert wurden, und trennt es durch ein Komma vom vorherigen Feld.

mysql> Test verwenden;
Datenbank geändert

mysql> Tabelle erstellen, falls `user3` nicht existiert (ID int Primärschlüssel, Alter int nicht null, Standard 0, Kommentar 'Alter', Name char(50) Kommentar 'Name' nicht null);
Abfrage OK, 0 Zeilen betroffen

mysql> in Benutzer3 Werte einfügen (1,20, „Marke“);
Abfrage OK, 1 Zeile betroffen

mysql> in Benutzer3-Werte einfügen (1,22, 'sol');
1062 - Doppelter Eintrag „1“ für Schlüssel „PRIMARY“

mysql> in Benutzer3-Werte einfügen (2,22, 'sol');
Abfrage OK, 1 Zeile betroffen

mysql> wähle * von Benutzer3;
+----+-----+-------+
| ID | Alter | Name |
+----+-----+-------+
| 1 | 20 | Marke |
| 2 | 22 | Sol |
+----+-----+-------+
2 Reihen im Set

Wie oben erwähnt, muss der Primärschlüssel die Eindeutigkeit des Wertes beibehalten. Wenn ein doppelter Wert eingefügt wird, weist dies darauf hin, dass die Primärschlüsseleinschränkung verletzt wird.

Eine andere Möglichkeit besteht darin, mehrere Primärschlüssel am Ende der Felddeklaration zu unterstützen, die durch Kommas getrennt und nicht wiederholbar sind, im Format des Primärschlüssels (Feld 1, Feld 2, Feld n). Dies wird als zusammengesetzter Primärschlüssel (oder zusammengesetzter Primärschlüssel) bezeichnet. Beispiel:

Tabelle erstellen, falls „Benutzer4“ nicht vorhanden ist (ID int, Alter int nicht null, Standard 0, Kommentar „Alter“, Name char(50), Kommentar „Name“ nicht null, Primärschlüssel(ID, Name));

Fremdschlüssel: identifiziert eine Fremdschlüsseleinschränkung. Syntax: Fremdschlüssel(t1_Spaltenname) verweist auf t2(Spaltenname), t1 ist die aktuelle Tabelle, t2 ist die Fremdschlüsseltabelle und die aktuelle Tabelle und die Fremdschlüsseltabelle haben ein Feld, das auf einen Fremdschlüssel beschränkt ist.

mysql> Tabelle erstellen, falls `Klasse` nicht vorhanden ist (Klassen-ID int Primärschlüssel, Klassenname varchar (50));
Abfrage OK, 0 Zeilen betroffen

mysql> Tabelle erstellen, falls `user4` nicht existiert (id int Primärschlüssel, Alter int Kommentar 'Alter', Name char(50) Kommentar 'Name', cid int nicht null, Fremdschlüssel(cid) verweist auf Klasse(classid));
Abfrage OK, 0 Zeilen betroffen

mysql> in „Benutzer4“ einfügen Werte (1,20, „Marke“, 1);
1452 – Eine untergeordnete Zeile kann nicht hinzugefügt oder aktualisiert werden: Eine Fremdschlüsseleinschränkung schlägt fehl (`test`.`user4`, CONSTRAINT `user4_ibfk_1` FOREIGN KEY (`cid`) REFERENCES `class` (`classid`))

mysql> in „Klasse“ einfügen Werte (1, „Grad 3“);
Abfrage OK, 1 Zeile betroffen

mysql> in „Benutzer4“ einfügen Werte (1,20, „Marke“, 1);
Abfrage OK, 1 Zeile betroffen

mysql> wähle a.age als „Alter“, a.name als „Studentenname“, b.classname als „Klasse“ von Benutzer4 a links verbinde Klasse b mit a.cid = b.classid;
+------+----------+--------+
| Alter| Name des Schülers| Klasse|
+------+----------+--------+
| 20 | Marke | Klasse 3 |
+------+----------+--------+
1 Reihe im Set

Einige Anmerkungen:

1. Beim Einfügen in die Tabelle user4 wird geprüft, ob der Wert des zugehörigen Fremdschlüssels classid vorhanden ist. Wenn er nicht vorhanden ist, wird ein Fehler gemeldet. Wie im dritten Absatz des obigen Codes gezeigt, existiert der Wert classid=1 nicht in der Klassentabelle.

2. Die entsprechenden Felder der beiden Tabellen, die eine Fremdschlüsselbeziehung herstellen, müssen vom gleichen Typ sein.

3. Das als Fremdschlüssel festgelegte Feld kann nicht der Primärschlüssel dieser Tabelle sein, aber das Feld der zugehörigen Tabelle muss der Primärschlüssel sein. (Daher wird der Fremdschlüssel cid dem Feld classid der Klassentabelle als Primärschlüssel zugeordnet.)

Eindeutiger Schlüssel: Die Eindeutigkeitsbeschränkung kann auf ein oder mehrere Felder festgelegt werden. Doppelte Werte sind nicht zulässig. Doppelte Werte verletzen die Eindeutigkeitsbeschränkung und führen zu Einfügungsfehlern.

Es gibt auch zwei Möglichkeiten, es zu definieren: Eine besteht darin, es direkt nach dem Feld festzulegen, und die andere besteht darin, es festzulegen, nachdem alle Felder definiert wurden. Das folgende Beispiel:

mysql> erstelle Tabelle „Benutzer5“ (ID int Primärschlüssel, Name varchar (50), ident char (18) eindeutiger Schlüssel);
Abfrage OK, 0 Zeilen betroffen

mysql> erstelle Tabelle „Benutzer6“ (ID int Primärschlüssel, Name varchar (50), Ident char (18) nicht null, Geschlecht int nicht null, eindeutiger Schlüssel (Ident, Geschlecht));
Abfrage OK, 0 Zeilen betroffen

mysql> in „Benutzer5“ einfügen Werte(1,„Marke“,„012345678901234567“);
Abfrage OK, 1 Zeile betroffen
mysql> in „Benutzer5“ einfügen Werte(2,„sol“,„012345678901234567“);
1062 - Doppelter Eintrag '012345678901234567' für Schlüssel 'ident'

Der zweite Absatz zeigt die Unterstützung für mehrere durch Kommas getrennte Felder mit dem Syntaxformat: eindeutiger Schlüssel (Feld 1, Feld 2, Feld n);

Im dritten Absatz wird der Wert von ident wiederholt eingegeben und er wird aufgefordert, ihn wiederholt einzugeben.

auto_inc: identifiziert automatisches Wachstum

mysql> Tabelle „Benutzer7“ erstellen (ID int auto_increment Primärschlüssel, Name varchar (50));
Abfrage OK, 0 Zeilen betroffen

mysql> in `user7`(Name) Werte einfügen ('Marke'), ('Sol'), ('Helen');
Abfrage OK, 3 Zeilen betroffen

Datensätze: 3 Duplikate: 0 Warnungen: 0
mysql> wähle * von `Benutzer7`;
+----+--------+
| Ich würde | Name |
+----+--------+
| 1 | Marke |
| 2 | Sol |
| 3 | Helene |
+----+--------+
3 Reihen im Set

auto_increment Beschreibung:

1. Das Feld auto_increacement wird automatisch erhöht, der Standardwert beginnt bei 1 und erhöht sich jedes Mal um 1.

2. Der Anfangswert und die Schrittweite des Autoinkrementfelds können in MySQL festgelegt werden. Beispielsweise wird der Anfangswert auf 10.000 festgelegt und die Schrittweite wird jedes Mal um 10 erhöht.

3. Der aktuelle Wert der Auto-Increment-Spalte wird im Speicher abgelegt. Nach dem Neustart der Datenbank wird der aktuelle Wert der Auto-Increment-Spalte max in der aktuellen Tabelle abgefragt.

4. Wenn die Tabellendaten gelöscht und die Datenbank neu gestartet wird, beginnt die Auto-Inkrement-Spalte mit dem Anfangswert.

Löschen einer Tabelle

Tabelle löschen [falls vorhanden] tname;

Tabellennamen und Kommentare ändern

 Tabelle ändern o_tname umbenennen [in] n_tname;
 Tabelle ändern, Tname-Kommentar 'Memo';

Tabelle kopieren

Kopieren Sie nur das Schema

Erstellen Sie die Tabelle tname wie from_tname.
mysql> wähle * von `Benutzer7`;
+----+--------+
| Ich würde | Name |
+----+--------+
| 1 | Marke |
| 2 | Sol |
| 3 | Helene |
+----+--------+
3 Reihen im Set

mysql> erstelle Tabelle ‚Benutzer8‘ wie ‚Benutzer7‘;
Abfrage OK, 0 Zeilen betroffen

mysql> wähle * von `Benutzer8`;
Leeres Set

Schema + Daten kopieren

Erstelle Tabelle tname [als] wähle Spalte1, Spalte2, ... aus from_tname [wobei Bedingung];
mysql> wähle * von `Benutzer7`;
+----+--------+
| Ich würde | Name |
+----+--------+
| 1 | Marke |
| 2 | Sol |
| 3 | Helene |
+----+--------+
3 Reihen im Set

mysql> Tabelle „Benutzer9“ erstellen, ID und Name aus „Benutzer7“ auswählen;
Abfrage OK, 3 Zeilen betroffen
Datensätze: 3 Duplikate: 0 Warnungen: 0

mysql> wähle * von `user9`;
+----+--------+
| Ich würde | Name |
+----+--------+
| 1 | Marke |
| 2 | Sol |
| 3 | Helene |
+----+--------+
3 Reihen im Set

Dabei werden sowohl die Daten als auch die Architektur übernommen, was super praktisch ist.

Felder verwalten

Felder hinzufügen

Tabelle ändern, Tname, Spalte hinzufügen, Spaltenname, Spaltentyp [Einschränkungen];
mysql> wähle * von `user9`;
+----+--------+
| Ich würde | Name |
+----+--------+
| 1 | Marke |
| 2 | Sol |
| 3 | Helene |
+----+--------+
3 Reihen im Set

mysql> alter table `user9` add column newcolumn int not null default 0;
Abfrage OK, 0 Zeilen betroffen
Datensätze: 0 Duplikate: 0 Warnungen: 0

mysql> wähle * von `user9`;
+----+-------+-------------+
| ID | Name | neue Spalte |
+----+-------+-------------+
| 1 | Marke | 0 |
| 2 | Sol | 0 |
| 3 | Helene | 0 |
+----+-------+-------------+
3 Reihen im Set

Felder ändern

alter table tname modify column col_name new_col_type [constraints]; -- Ändert den Typ und die Constraints, aber nicht den Feldnamen alter table tname change column col_name new_col_name new_col_type [constraints]; -- Ändert den Feldnamen, Typ und die Constraints

Nachfolgend sind Beispiele für „Modifizieren“ bzw. „Ändern“ aufgeführt:

mysql> Beschreibung `Benutzer9`;
+-----------+----------+------+-----+---------+---------+----------+
| Feld | Typ | Null | Schlüssel | Standard | Extra |
+-----------+----------+------+-----+---------+---------+-----------+
| Ich würde | int(11) | NEIN | | 0 | |
| Name | varchar(50) | JA | | NULL | |
| neue Spalte | int(11) | NEIN | | 0 | |
+-----------+----------+------+-----+---------+---------+----------+
3 Reihen im Set

mysql> alter table `user9` modify column name varchar(100);
Abfrage OK, 3 Zeilen betroffen
Datensätze: 3 Duplikate: 0 Warnungen: 0

mysql> Beschreibung `Benutzer9`;
+-----------+--------------+------+-----+---------+---------+----------+
| Feld | Typ | Null | Schlüssel | Standard | Extra |
+-----------+--------------+------+-----+---------+---------+----------+
| Ich würde | int(11) | NEIN | | 0 | |
| Name | varchar(100) | JA | | NULL | |
| neue Spalte | int(11) | NEIN | | 0 | |
+-----------+--------------+------+-----+---------+---------+----------+
3 Reihen im Set
mysql> Beschreibung `Benutzer9`;
+-----------+--------------+------+-----+---------+---------+----------+
| Feld | Typ | Null | Schlüssel | Standard | Extra |
+-----------+--------------+------+-----+---------+---------+----------+
| Ich würde | int(11) | NEIN | | 0 | |
| Name | varchar(100) | JA | | NULL | |
| neue Spalte | int(11) | NEIN | | 0 | |
+-----------+--------------+------+-----+---------+---------+----------+
3 Reihen im Set

mysql> alter table `user9` ändere Spaltennamen name1 varchar(100);
Abfrage OK, 0 Zeilen betroffen
Datensätze: 0 Duplikate: 0 Warnungen: 0

mysql> Beschreibung `Benutzer9`;
+-----------+--------------+------+-----+---------+---------+----------+
| Feld | Typ | Null | Schlüssel | Standard | Extra |
+-----------+--------------+------+-----+---------+---------+----------+
| Ich würde | int(11) | NEIN | | 0 | |
| name1 | varchar(100) | JA | | NULL | |
| neue Spalte | int(11) | NEIN | | 0 | |
+-----------+--------------+------+-----+---------+---------+----------+
3 Reihen im Set

Löschen eines Felds

Tabelle ändern, Tname, Spalte löschen, col_name;
mysql> Beschreibung `Benutzer9`;
+-----------+--------------+------+-----+---------+---------+----------+
| Feld | Typ | Null | Schlüssel | Standard | Extra |
+-----------+--------------+------+-----+---------+---------+----------+
| Ich würde | int(11) | NEIN | | 0 | |
| name1 | varchar(100) | JA | | NULL | |
| neue Spalte | int(11) | NEIN | | 0 | |
+-----------+--------------+------+-----+---------+---------+----------+
3 Reihen im Set

mysql> Tabelle „Benutzer9“ ändern, Spalte „neue Spalte“ löschen;
Abfrage OK, 0 Zeilen betroffen
Datensätze: 0 Duplikate: 0 Warnungen: 0

mysql> Beschreibung `Benutzer9`;
+-------+--------------+------+-----+---------+---------+----------+
| Feld | Typ | Null | Schlüssel | Standard | Extra |
+-------+--------------+------+-----+---------+---------+----------+
| Ich würde | int(11) | NEIN | | 0 | |
| name1 | varchar(100) | JA | | NULL | |
+-------+--------------+------+-----+---------+---------+----------+
2 Reihen im Set

Oben finden Sie detaillierte Informationen zur Verwendung von MySQL-DDL-Anweisungen. Weitere Informationen zu MySQL-DDL-Anweisungen finden Sie in den anderen verwandten Artikeln auf 123WORDPRESS.COM!

Das könnte Sie auch interessieren:
  • Zusammenfassung gängiger MySQL-DDL-Operationen
  • Detaillierte Erklärung der atomaren DDL-Syntax von MySQL 8.0
  • Detaillierte Erklärung der vier SQL-Sprachen: DDL DML DCL TCL
  • Grundlegende Anweisungen der MySQL-Datendefinitionssprache DDL
  • MySQL-Tutorial: Datendefinitionssprache (DDL), Beispiel, ausführliche Erklärung

<<:  Die Vor- und Nachteile von Nginx und LVS und ihre geeignete Nutzungsumgebung

>>:  JavaScript, um einen einheitlichen Animationseffekt zu erzielen

Artikel empfehlen

Mysql SQL-Anweisungskommentare

Sie können MySQL-SQL-Anweisungen Kommentare hinzu...

Grafisches Beispiel für die Verwaltung von Datenträgerkontingenten unter Linux

Das Datenträgerkontingent ist die Speichergrenze ...

Detaillierte Erläuterung der Redis-Master-Slave-Replikationspraxis mit Docker

Inhaltsverzeichnis 1. Hintergrund 2. Bedienungssc...

Detaillierte grafische Erklärung zur Verwendung von SVG im Vue3+Vite-Projekt

Heute habe ich bei der Verwendung von SVG in der ...

Farbverlauf für HTML-Hintergrund durch CSS erreicht

Screenshots der Effekte: Implementierungscode: Cod...

Tiefgreifendes Verständnis der JavaScript-Rückruffunktionen

Inhaltsverzeichnis Vorwort Kurzübersicht: JavaScr...

Mehrere Möglichkeiten zum Berechnen des Alters anhand des Geburtstags in MySQL

Ich habe MySQL vorher nicht sehr oft verwendet un...

Natives JS zum Erreichen von Spezialeffekt-Meldungsfeldern

In diesem Artikel wird ein Nachrichtenfeld mit Sp...

Analyse des Remote-Debuggings und des Timeout-Betriebsprinzips von Webdiensten

Remote-Debugging von Webdiensten In .NET ist die ...

Spezifische Schritte zur Verwendung des Vant-Frameworks im WeChat-Applet

Inhaltsverzeichnis 1. Öffnen Sie das Projektverze...

JavaScript fügt Prototyp-Methodenimplementierung für integrierte Objekte hinzu

Die Reihenfolge, in der Objekte Methoden aufrufen...