Viele Entwickler und Datenbankadministratoren erstellen Datenbanken mit GUI-Tools wie SQL Server Management Studio (SSMS), Azure Data Studio usw.
Aber es kann viel schneller gehen, Datenbanken mit SQL zu erstellen. Dies gilt insbesondere, wenn Sie über verschiedene Umgebungen verfügen, in denen Sie dieselbe Datenbank neu erstellen müssen. Sie können dasselbe Skript für jede Umgebung ausführen, und die Datenbank wird jedes Mal innerhalb von Sekunden erstellt.
In SQL Server machen wir das mit T-SQL. T-SQL steht für Transact-SQL und ist die Erweiterung von SQL Server für SQL.
Nachfolgend finden Sie ein Beispiel für die Verwendung von T-SQL zum Erstellen einer Datenbank in SQL Server.
Basiscode
CREATE DATABASE Music;Dies ist der gesamte Code, den Sie zum Erstellen einer Datenbank benötigen. In diesem Fall erstellt es eine Datenbank namens Musik .
Das ist jedoch alles, was es schafft. Die Datenbank enthält keine Tabellen oder andere Objekte. Dazu müssen Sie weitere Anweisungen verwenden, um diese Objekte nach Bedarf zu erstellen.
Auch das obige CREATE DATABASE -Anweisung verwendet die grundlegendste Syntax, die keine Argumente enthält. Es gibt viele Optionen, die in diese Anweisung aufgenommen werden können.
Sie können beispielsweise Ihren eigenen Namen für die Dateien und ihre Dateigruppen angeben. Sie können auch einen Datenbank-Snapshot erstellen oder Datenbankdateien anhängen, um eine Datenbank aus den getrennten Dateien einer anderen Datenbank zu erstellen.
Die vollständige Syntax für diese Anweisung finden Sie in der Microsoft-Dokumentation.
Tabellen erstellen
Hier ist ein Beispiel für die Erstellung von drei Tabellen für die obige Datenbank.
USE Music;
CREATE TABLE Artists (
ArtistId int IDENTITY(1,1) NOT NULL PRIMARY KEY,
ArtistName nvarchar(255) NOT NULL,
ActiveFrom date
);
CREATE TABLE Genres (
GenreId int IDENTITY(1,1) NOT NULL PRIMARY KEY,
Genre nvarchar(50) NOT NULL
);
CREATE TABLE Albums (
AlbumId int IDENTITY(1,1) NOT NULL PRIMARY KEY,
AlbumName nvarchar(255) NOT NULL,
ReleaseDate date NOT NULL,
ArtistId int NOT NULL,
GenreId int NOT NULL
CONSTRAINT FK_Albums_Artists FOREIGN KEY (ArtistId)
REFERENCES dbo.Artists (ArtistId)
ON DELETE NO ACTION
ON UPDATE NO ACTION
);
Der erste Schritt besteht darin, zur richtigen Datenbank (in diesem Fall die Musikdatenbank) zu wechseln. Dazu verwenden wir USE MUSIC .
Sobald Sie die richtige Datenbank verwenden, können Sie Ihre Tabellen und andere Objekte erstellen. In diesem Fall habe ich drei Tabellen erstellt. Jedes Mal, wenn ich CREATE TABLE verwende , gefolgt vom Tabellennamen, den ich erstellen möchte. Darauf folgt die Definition dieser Tabelle.
Die Definition umfasst die Spalten der Tabelle und ihre Definitionen. Beispiel:ArtistId eine Spalte ist, verwendet sie ein int Datentyp, und ich habe ihn als Primärschlüssel für die Tabelle festgelegt. Der Primärschlüssel zu sein bedeutet, dass er jede Zeile in der Datenbank eindeutig identifiziert.
Ich habe diese Spalte auch als IDENTITY festgelegt Spalte, was bedeutet, dass jede Zeile einen automatisch generierten Wert verwendet, der mit jeder Zeile erhöht wird. In diesem Fall beginnt es bei 1 und erhöht sich um 1 (das liegt daran, dass ich IDENTITY(1,1) angegeben habe .
Schließlich habe ich diese Spalte auch auf NOT NULL gesetzt . Das bedeutet, dass es einen Wert enthalten muss. Es darf nicht null sein. Dies ist eigentlich eine Voraussetzung, bevor Sie die Spalte als Primärschlüssel festlegen, aber Sie können auch andere Spalten auf NOT NULL setzen wie erforderlich (was ich in diesem Beispiel getan habe).
Beziehungen erstellen
Im obigen Beispiel habe ich eine Beziehung zwischen den Albums erstellt und Artists Tische.
Eine Beziehung ist eine Art Verknüpfung zwischen Tabellen mit verwandten Daten. Beziehungen tragen zur Durchsetzung der Datenintegrität bei, da sie es Ihnen ermöglichen, anzugeben, dass eine Spalte nur Werte enthalten darf, die mit den Werten in einer bestimmten Spalte in einer anderen Tabelle übereinstimmen.
Hier ist der spezifische Codeabschnitt aus dem obigen Beispiel, der die Beziehung erstellt:
CREATE TABLE Albums (
AlbumId int IDENTITY(1,1) NOT NULL PRIMARY KEY,
AlbumName nvarchar(255) NOT NULL,
ReleaseDate date NOT NULL,
ArtistId int NOT NULL,
GenreId int NOT NULL
CONSTRAINT FK_Albums_Artists FOREIGN KEY (ArtistId)
REFERENCES dbo.Artists (ArtistId)
ON DELETE NO ACTION
ON UPDATE NO ACTION
);
Ich habe die Beziehung gleichzeitig mit den Albums erstellt Tisch. Das war mir möglich, weil ich die Artists bereits erstellt hatte Tabelle (die die andere Tabelle in der Beziehung ist).
Ich habe die Beziehung erstellt, indem ich eine Fremdschlüsseleinschränkung erstellt habe (unter Verwendung der CONSTRAINT -Argument) und Angabe von FOREIGN KEY zusammen mit den Details der Beziehung. Die REFERENCES Das Schlüsselwort gibt an, auf welche Tabelle und Spalte der Fremdschlüssel verweist.
Ich habe die Beziehung FK_Albums_Artists genannt .
Der ON DELETE und ON UPDATE Teile sind optional. Sie geben an, was zu tun ist, falls jemand eine Zeile aus der Eltern-/Primärschlüsselspalte löscht oder aktualisiert. Der Standardwert ist NO ACTION , was bedeutet, dass die Datenbank-Engine einen Fehler auslöst und die Aktualisierungsaktion für die Zeile in der übergeordneten Tabelle rückgängig gemacht wird.
Mein Artikel zum Erstellen einer Beziehung in SQL listet die anderen Optionen auf, die Sie hier angeben können, sowie die Funktionsweise der einzelnen Optionen.
Beziehungen später erstellen
Sie können auch eine Beziehung für eine vorhandene Tabelle erstellen.
Um dies mit T-SQL zu tun, verwenden Sie ALTER TABLE Aussage.
So kann ich den folgenden Code ausführen, nachdem ich den vorherigen Code ausgeführt habe.
ALTER TABLE Albums
ADD CONSTRAINT FK_Albums_Genres FOREIGN KEY (GenreId)
REFERENCES dbo.Genres (GenreId)
ON DELETE NO ACTION
ON UPDATE NO ACTION
;
Dadurch entsteht eine weitere Beziehung, diesmal zwischen den Albums und Genres Tische.
Sie können sehen, dass dieser Code so ziemlich dasselbe macht wie die vorherige Beziehung. Der einzige Unterschied besteht darin, dass die Beziehung zwischen Artists besteht und Genres statt Albums und Artists .
In diesem Fall habe ich die Beziehung FK_Albums_Genres genannt .
Daten einfügen
Der obige Code hat eine Datenbank erstellt, die für Daten geeignet ist. Wir können jetzt Daten hinzufügen.
In SQL Server können Sie Daten zu einer Datenbank hinzufügen, indem Sie INSERT verwenden Erklärung. Wenn Sie diese Anweisung verwenden, müssen Sie den Namen der Tabelle sowie die Spalten angeben, in die Sie Daten einfügen möchten.
Eigentlich ist das Bereitstellen der Spalten optional, wenn Sie Daten in alle Spalten einfügen, aber der Übersichtlichkeit halber ist hier ein Beispiel, das die Spaltennamen enthält.
INSERT INTO Artists (ArtistName, ActiveFrom)
VALUES
('Iron Maiden','1975-12-25'),
('AC/DC','1973-01-11'),
('Allan Holdsworth','1969-01-01'),
('Buddy Rich','1919-01-01'),
('Devin Townsend','1993-01-01'),
('Jim Reeves','1948-01-01'),
('Tom Jones','1963-01-01'),
('Maroon 5','1994-01-01'),
('The Script','2001-01-01'),
('Lit','1988-06-26'),
('Black Sabbath','1968-01-01'),
('Michael Learns to Rock','1988-03-15'),
('Carabao','1981-01-01'),
('Karnivool','1997-01-01'),
('Birds of Tokyo','2004-01-01'),
('Bodyjar','1990-01-01');
INSERT INTO Genres (Genre)
VALUES
('Rock'),
('Jazz'),
('Country'),
('Pop'),
('Blues'),
('Hip Hop'),
('Rap'),
('Punk');
INSERT INTO Albums (AlbumName, ReleaseDate, ArtistId, GenreId)
VALUES
('Powerslave', '1984-09-03', 1, 1),
('Powerage', '1978-05-05', 2, 1),
('Singing Down the Lane', '1956-01-01', 6, 3),
('Ziltoid the Omniscient', '2007-05-21', 5, 1),
('Casualties of Cool', '2014-05-14', 5, 1),
('Epicloud', '2012-09-18', 5, 1),
('Somewhere in Time', '1986-09-29', 1, 1),
('Piece of Mind', '1983-05-16', 1, 1),
('Killers', '1981-02-02', 1, 1),
('No Prayer for the Dying', '1990-10-01', 1, 1),
('No Sound Without Silence', '2014-09-12', 9, 4),
('Big Swing Face', '1967-06-01', 4, 2),
('Blue Night', '2000-11-01', 12, 4),
('Eternity', '2008-10-27', 12, 4),
('Scandinavia', '2012-06-11', 12, 4),
('Long Lost Suitcase', '2015-10-09', 7, 4),
('Praise and Blame', '2010-06-26', 7, 4),
('Along Came Jones', '1965-05-21', 7, 4),
('All Night Wrong', '2002-05-05', 3, 2),
('The Sixteen Men of Tain', '2000-03-20', 3, 2);Wie Sie sehen können, hat jede Zeile eine eigene Zeile. Wir fügen einfach eine Zeile pro Zeile hinzu, wobei jede Spalte durch ein Komma getrennt und von Klammern umgeben ist. Außerdem wird jede Zeile durch ein Komma getrennt (nach den Klammern).
Das Ausführen des obigen Codes für unsere neu erstellte Datenbank führt zu folgender Ausgabe:
(16 rows affected) (8 rows affected) (20 rows affected)
Dies sagt uns, dass die Daten erfolgreich eingefügt wurden.
Überprüfen Sie die Datenbank
Wir können einen schnellen Test mit der Datenbank durchführen, um zu überprüfen, ob sie erstellt und unsere Daten eingefügt wurden.
Beispielsweise können wir die folgende einfache Abfrage ausführen.
SELECT * FROM Artists;Ergebnis:
+------------+------------------------+--------------+ | ArtistId | ArtistName | ActiveFrom | |------------+------------------------+--------------| | 1 | Iron Maiden | 1975-12-25 | | 2 | AC/DC | 1973-01-11 | | 3 | Allan Holdsworth | 1969-01-01 | | 4 | Buddy Rich | 1919-01-01 | | 5 | Devin Townsend | 1993-01-01 | | 6 | Jim Reeves | 1948-01-01 | | 7 | Tom Jones | 1963-01-01 | | 8 | Maroon 5 | 1994-01-01 | | 9 | The Script | 2001-01-01 | | 10 | Lit | 1988-06-26 | | 11 | Black Sabbath | 1968-01-01 | | 12 | Michael Learns to Rock | 1988-03-15 | | 13 | Carabao | 1981-01-01 | | 14 | Karnivool | 1997-01-01 | | 15 | Birds of Tokyo | 2004-01-01 | | 16 | Bodyjar | 1990-01-01 | +------------+------------------------+--------------+
Und lassen Sie uns eine weitere Abfrage ausführen, die Daten aus allen drei Tabellen verwendet.
SELECT
ArtistName,
AlbumName,
ReleaseDate
FROM Artists ar
INNER JOIN Albums al
ON ar.ArtistId = al.ArtistId
INNER JOIN Genres g
ON al.GenreId = g.GenreId
WHERE g.Genre = 'Rock';Ergebnis:
+----------------+-------------------------+---------------+ | ArtistName | AlbumName | ReleaseDate | |----------------+-------------------------+---------------| | Iron Maiden | Powerslave | 1984-09-03 | | AC/DC | Powerage | 1978-05-05 | | Devin Townsend | Ziltoid the Omniscient | 2007-05-21 | | Devin Townsend | Casualties of Cool | 2014-05-14 | | Devin Townsend | Epicloud | 2012-09-18 | | Iron Maiden | Somewhere in Time | 1986-09-29 | | Iron Maiden | Piece of Mind | 1983-05-16 | | Iron Maiden | Killers | 1981-02-02 | | Iron Maiden | No Prayer for the Dying | 1990-10-01 | +----------------+-------------------------+---------------+
Diese Abfrage zeigt, wie wichtig es ist, Beziehungen zwischen Tabellen mit verwandten Daten zu erstellen. Wenn wir Abfragen wie diese ausführen, brauchen wir wirklich, dass die Daten zwischen den Tabellen konsistent sind.
Die Datenbank ist nun einsatzbereit. Wir können Abfragen dafür ausführen. Wir können weitere Daten einfügen. Wir können weitere Tabellen, Beziehungen, Ansichten, gespeicherte Prozeduren, benutzerdefinierte Funktionen und vieles mehr hinzufügen.
