Mysql
 sql >> Datenbank >  >> RDS >> Mysql

CREATE TABLE MySQL vs. T-SQL mit Syntaxbeispielen

Sind Sie ein T-SQL-Entwickler, der die Grundlagen von MySQL lernt? Dann ist eines der Dinge, die Sie vielleicht lernen möchten, die MySQL CREATE TABLE-Anweisung. Außerdem lernen Sie eine neue SQL-Datenbankplattform am schnellsten kennen, indem Sie ihre gemeinsame Funktionalität und Syntax vergleichen.

Das werden wir heute tun. Aber die vollständige Syntax ist viel. Daher werden wir nur 5 grundlegende Punkte behandeln, um Sie mit dem MySQL-Befehl CREATE TABLE zum Laufen zu bringen.

Bevor wir jedoch fortfahren, lassen Sie uns einige Punkte klären:

  1. Die hier verwendete MySQL-Version ist MySQL 8 mit der InnoDB-Speicher-Engine.
  2. Die hier verwendete SQL Server-Version ist SQL Server 2019.

Hört sich gut an? Fangen wir an.

Tabellenanweisung in MySQL und T-SQL erstellen

Beginnen wir den Vergleich mit der Definition des Tabellennamens.

Einer der auffälligen Syntaxunterschiede in MySQL CREATE TABLE ist das Fehlen eines Schemanamens. So geht's:

CREATE TABLE database_name.table_name

Haben Sie den Tabellennamen bemerkt, dem der Datenbankname vorangestellt ist? Nun, hier ist ein T-SQL-äquivalentes Format, mit dem Sie vertraut sind:


CREATE TABLE database_name.schema_name.table_name

Wieso den? Denn in MySQL ist ein Schema gleichbedeutend mit einer Datenbank. Die Datenbank- und Schemanamen sind optional. Wenn Sie jedoch in demselben Skript eine Tabelle in einer anderen Datenbank erstellen müssen, ist dies ein Muss.

Stimmt. Die Verwendung von eckigen Klammern in Tabellen- und Spaltennamen löst einen Fehler in MySQL aus. Sie sollten stattdessen ein Paar Backticks verwenden, um Bezeichner einzuschließen. Abbildung 1 zeigt, wo Sie es auf einem US-Tastaturlayout finden:

Sehen Sie sich jetzt das Beispiel an:

-- MySQL CREATE TABLE

CREATE TABLE `testdatabase`.`person` (
  `BusinessEntityID` INT NOT NULL,
  `PersonType` NCHAR(2) NOT NULL,
  `Title` VARCHAR(8) NULL,
  `FirstName` NVARCHAR(50) NOT NULL,
  `MiddleName` VARCHAR(50) NULL,
  `LastName` VARCHAR(50) NOT NULL,
  `Suffix` NVARCHAR(10) NULL,
  `EmailPromotion` INT NOT NULL,
  `ModifiedDate` DATETIME NOT NULL DEFAULT NOW(),
  PRIMARY KEY (`BusinessEntityID`));

Aus dem obigen Codebeispiel sind die Bezeichner von Tabellen- und Spaltennamen in Backticks eingeschlossen. Wenn Sie es nicht gewohnt sind, Tabellen- und Spaltennamen damit einzuschließen, vertrauen Sie mir, Sie sind nicht allein.

Überprüfen Sie den entsprechenden Code in T-SQL unten:

-- T-SQL CREATE TABLE
CREATE TABLE [testdatabase].[dbo].[Person](
	[BusinessEntityID] [int] NOT NULL,
	[PersonType] [nchar](2) NOT NULL,
	[Title] [nvarchar](8) NULL,
	[FirstName] [nvarchar](50) NOT NULL,
	[MiddleName] [nvarchar](50) NULL,
	[LastName] [nvarchar](50) NOT NULL,
	[Suffix] [nvarchar](10) NULL,
	[EmailPromotion] [int] NOT NULL,
	[ModifiedDate] [datetime] NOT NULL DEFAULT GETDATE(),
 CONSTRAINT [PK_Person_BusinessEntityID] PRIMARY KEY  
  (
	[BusinessEntityID] ASC
  )
) ON [PRIMARY]

Natürlich müssen Sie diese Kennungen nicht einschließen. Aber wenn Sie Reservewörter oder Leerzeichen in Tabellen- oder Spaltennamen verwenden, tritt ein Fehler auf.

Anleitung Temporäre Tabelle erstellen

Magst du temporäre Tabellen? Dann lässt MySQL Sie mehr eingeben, um eine temporäre Tabelle zu definieren. Sehen Sie sich das Beispiel an:

-- MySQL Temporary Table

CREATE TEMPORARY TABLE `MyTempTable`

Inzwischen sind T-SQL-Codierer an das # gewöhnt Symbol vor dem Tabellennamen. Siehe den entsprechenden Code oben:


-- T-SQL Temporary Table

CREATE TABLE #MyTempTable

Wir sind mit Tabellendefinitionen und -namen fertig. Fahren wir mit den Spaltendefinitionen fort.

MySQL-Spaltensyntax

Sie können keine einfache SQL-Tabelle ohne Spalten haben. Welche Ähnlichkeiten und Unterschiede gibt es also zwischen MySQL und SQL Server?

Spaltennamen und Datentypen

Sie kennen bereits die Backticks. Alles andere Grundlegende zu Spaltennamen und Datentypen ist in MySQL und T-SQL gleich. Siehe das Beispiel unten:

CREATE TABLE `testdatabase`.`people`
(
    `ID` INT,
    `LastName` VARCHAR(50),
    ...
);

Es gibt jedoch noch mehr.

Spalten-Nullbarkeit

Spalten können nullable sein oder nicht. Sie können dies tun, indem Sie NULL oder NOT NULL in die Spaltendefinition einfügen.

Lassen Sie uns unser vorheriges Beispiel erweitern.

CREATE TABLE `testdatabase`.`people`
(
     `ID` INT NOT NULL,
     `LastName` VARCHAR(50) NOT NULL,
     `FirstName` VARCHAR(50) NOT NULL,
     `MiddleName` VARCHAR(50) NULL,
     ...
);

Es ist so ziemlich dasselbe wie T-SQL. Wie wäre es mit Standardwerten?

Spalten-Standardwerte

Als nächstes folgen die Standardwerte der Spalten. Diese sind praktisch, wenn Sie einen Datensatz einfügen, aber keinen bestimmten Wert für eine Spalte angegeben haben. Lassen Sie uns unser vorheriges Beispiel noch etwas erweitern:

CREATE TABLE `testdatabase`.`people`
(
     `ID` INT NOT NULL,
     `LastName` VARCHAR(50) NOT NULL,
     `FirstName` VARCHAR(50) NOT NULL,
     `MiddleName` VARCHAR(50) NULL,
     `ModifiedDate` DATETIME NOT NULL DEFAULT NOW(),
     ...
);

Das ModifiedDate Die Spalte enthält standardmäßig das aktuelle Systemdatum und die aktuelle Systemzeit. Wenn Sie in dieser Tabelle wie unten ein INSERT ausführen, wird es immer einen Wert für ModifiedDate geben .

INSERT INTO testdatabase.people
(ID, LastName, FirstName, MiddleName)
VALUES
(1,'Kirk','James','Tiberius');

Es funktioniert wie erwartet nach dem INSERT. Hier ist ein Screenshot von dbForge Studio für MySQL:

MySQL-Tabelle mit primären, fremden und eindeutigen Schlüsseln erstellen

Wie in jeder SQL-Plattform können Sie Regeln für Tabellenspaltendaten mithilfe von Einschränkungen in MySQL definieren. Da dies für das Tabellendesign wichtig ist, müssen wir diesen nächsten Punkt berücksichtigen.

Ein T-SQL-Entwickler sollte sich mit MySQL-Primärschlüsseln, Fremdschlüsseln und eindeutigen Schlüsseln wie zu Hause fühlen.

Primärschlüssel

Sie können eine oder mehrere Spalten als Primärschlüssel definieren. Die Syntax ist fast die gleiche wie in SQL Server. Irgendwelche Ausnahmen? Ja. Es ist die Verwendung von geclusterten und nicht geclusterten Indizes. Aber lassen Sie uns die Diskussion darüber im nächsten Abschnitt aufheben.

Im Moment konzentrieren wir uns auf die Syntax von Primärschlüsseln. Hier ist dasselbe Beispiel wie zuvor, aber wir fügen die ID-Spalte als Primärschlüssel hinzu:

CREATE TABLE `testdatabase`.`people`
(
     `ID` INT NOT NULL PRIMARY KEY,
     `LastName` VARCHAR(50) NOT NULL,
     `FirstName` VARCHAR(50) NOT NULL,
     `MiddleName` VARCHAR(50) NULL,
     `ModifiedDate` DATETIME NOT NULL DEFAULT NOW()
);

Einfach, nicht wahr?

Aber was ist, wenn Sie mehrere Spalten benötigen? Wie in T-SQL haben Sie 2 Möglichkeiten. Sehen Sie sich die folgenden Beispiele an:

-- OPTION 1: Let MySQL generate the constraint name

CREATE TABLE `testdatabase`.`people`
(
     `ID` INT NOT NULL,
     `LastName` VARCHAR(50) NOT NULL,
     `FirstName` VARCHAR(50) NOT NULL,
     `MiddleName` VARCHAR(50) NOT NULL DEFAULT '',
     `ModifiedDate` DATETIME NOT NULL DEFAULT NOW(),
     PRIMARY KEY (`LastName`,`FirstName`,`MiddleName`)
);

-- OPTION 2: Specify your constraint name

CREATE TABLE `testdatabase`.`people`
(
     `ID` INT NOT NULL,
     `LastName` VARCHAR(50) NOT NULL,
     `FirstName` VARCHAR(50) NOT NULL,
     `MiddleName` VARCHAR(50) NOT NULL DEFAULT '',
     `ModifiedDate` DATETIME NOT NULL DEFAULT NOW(),
    CONSTRAINT `pk_name` PRIMARY KEY (`LastName`, `FirstName`, `MiddleName`)
);

Das war's für Primärschlüssel.

Fremdschlüssel

Eine weitere wichtige Einschränkung ist der Fremdschlüssel. Dies wird verwendet, um eine Tabelle auf eine andere Tabelle zu verweisen:

CREATE TABLE `testdatabase`.`address`
(
    `ID` int NOT NULL PRIMARY KEY,
    `parent_id` int NOT NULL,
    `full_address` varchar(100) NOT NULL,
    CONSTRAINT `FK_address_parent_id` FOREIGN KEY (`parent_id`)
    REFERENCES `people` (`ID`)
);

Haben Sie die Ähnlichkeit mit T-SQL gesehen?

Eindeutiger Schlüssel

Manchmal möchten Sie sicherstellen, dass die in eine Tabelle eingefügten Daten eindeutig sind. MySQL unterstützt auch eindeutige Schlüssel. Hier ist ein Beispiel:

CREATE TABLE `testdatabase`.`people`
(
     `ID` INT NOT NULL,
     `LastName` VARCHAR(50) NOT NULL,
     `FirstName` VARCHAR(50) NOT NULL,
     `MiddleName` VARCHAR(50) NOT NULL DEFAULT '',
     `ModifiedDate` DATETIME NOT NULL DEFAULT NOW(),
    CONSTRAINT `PK_people_id` PRIMARY KEY (`ID`),
    CONSTRAINT `IDX_name` UNIQUE KEY (`LastName`,`FirstName`,`MiddleName`)

);

Der obige Code stellt sicher, dass nur eindeutige Namen zur Tabelle hinzugefügt werden.

Beispiele zum Erstellen von Tabellenindizes (geclustert und nicht geclustert)

In den vorherigen Beispielen haben Sie gesehen, wie Primär- und Sekundärschlüssel erstellt wurden. Aber wo sind geclusterte und nicht geclusterte Indizes? Das fällt auf, weil Sie in SQL Server explizit das Schlüsselwort CLUSTERED angeben, um einen Clustered-Index zu erstellen.

Der interessante Teil ist, dass MySQL keine CLUSTERED- oder NONCLUSTERED-Schlüsselwörter hat. Wie erstellt man geclusterte Indizes?

Einfach. Geben Sie einfach die Spalte(n) als Primärschlüssel an, und die InnoDB-Speicher-Engine macht daraus einen Clustered-Index. Im folgenden Beispiel ID ist der Primärschlüssel UND der gruppierte Index.

CREATE TABLE `testdatabase`.`people`
(
     `ID` INT NOT NULL PRIMARY KEY AUTO_INCREMENT,
     `LastName` VARCHAR(50) NOT NULL,
     `FirstName` VARCHAR(50) NOT NULL,
     `MiddleName` VARCHAR(50) NOT NULL DEFAULT '',
     `ModifiedDate` DATETIME NOT NULL DEFAULT NOW(),
    CONSTRAINT `IDX_name` UNIQUE KEY (`LastName`,`FirstName`,`MiddleName`)
);

Wenn Sie keinen Primärschlüssel angeben, wird jeder eindeutige Index als gruppierter Index verwendet.

Wenn Sie andererseits keinen Primärschlüssel und keinen eindeutigen Index haben, erstellt InnoDB einen versteckten gruppierten Index. Überprüfen Sie den Beweis hier.

Die nächste Frage ist, wie wäre es mit einem nicht geclusterten Index?

Wenn Sie bereits einen Primärschlüssel als gruppierten Index haben, sind alle anderen Indizes nicht gruppiert oder sekundär. Außerdem können Sie nur einen geclusterten Index haben.

Der nächste Abschnitt behandelt eine einzigartige Syntax für MySQL CREATE TABLE, die in T-SQL nicht gefunden wird.

Syntax zum Klonen und Kopieren von MySQL-Tabellen

Lassen Sie uns über das Klonen von Tabellen sprechen. Wir können es in MySQL CREATE TABLE machen. Dann zeigen wir das T-SQL-Äquivalent.

Das folgende Beispiel erstellt die Tabelle mit der gleichen Struktur wie die erste Tabelle mit CREATE TABLE…LIKE.

CREATE TABLE `people2` LIKE `people`

Wir haben gerade die Menschen geklont Tabelle in Personen2 . Es ist jedoch nur die Struktur der Menschen Tabelle, die kopiert wurde, nicht die Daten. Es kopierte auch die Schlüsseleinschränkungen und -indizes der ursprünglichen Tabelle. Ziemlich praktisch, wenn Sie mich fragen.

Das nächste T-SQL-Äquivalent ist dieses:

-- T-SQL way of cloning a table. The indexes & key constraints are not included, 
-- though

SELECT * INTO people2
FROM people
WHERE 1=0     -- this will cause the SELECT to return an empty result set.

Aber was, wenn Sie die Daten wollen? Dann ist CREATE TABLE…SELECT die Antwort:

CREATE TABLE `people3` AS
SELECT * FROM `people`;

Welche Daten auch immer in den Personen sind Tabelle, wird sie in die people3 kopiert Tisch. Dieser Befehl enthält jedoch keine Indizes und Einschränkungen.

Nun, das nächste T-SQL-Äquivalent ist dieses:

-- T-SQL table copying

SELECT * INTO people3 
FROM people

Schlussfolgerung

Ich hoffe, dass die oben genannten Punkte Ihnen helfen konnten, MySQL CREATE TABLE aus der Perspektive eines SQL Server T-SQL-Entwicklers zu verwenden.

Einige von Ihnen werden es vorziehen, grafische Tools zu verwenden. Aber später werden Sie feststellen, dass Sie nach einer Referenz suchen, wenn Sie Arbeitstabellen in Ihren gespeicherten Prozeduren oder Ad-hoc-Skripten erstellen müssen. Oder Sie sind einfach der Typ, der mehr Kontrolle sucht, indem Sie alles eingeben. In jedem Fall kann ein One-Stop-Shop, der die grundlegende Syntax vergleicht, lebensrettend sein.

Wenn Ihnen dieser Artikel gefällt, können Sie ihn gerne in Ihren bevorzugten sozialen Medien teilen.

Allen viel Spaß beim Programmieren.