Wielu programistów i administratorów baz danych tworzy bazy danych za pomocą narzędzi GUI, takich jak SQL Server Management Studio (SSMS), Azure Data Studio itp.
Jednak tworzenie baz danych przy użyciu SQL może być znacznie szybsze. Jest to szczególnie ważne, jeśli masz różne środowiska, w których musisz odtworzyć tę samą bazę danych. Możesz uruchomić ten sam skrypt w każdym środowisku, a baza danych zostanie za każdym razem utworzona w ciągu kilku sekund.
W SQL Server robimy to za pomocą T-SQL. T-SQL oznacza Transact-SQL i jest rozszerzeniem SQL Server do SQL.
Poniżej znajduje się przykład użycia T-SQL do stworzenia bazy danych w SQL Server.
Kod podstawowy
CREATE DATABASE Music;To wszystko, czego potrzebujesz do stworzenia bazy danych. W tym przypadku tworzy bazę danych o nazwie Muzyka .
Jednak to wszystko, co tworzy. Baza danych nie zawiera żadnych tabel ani innych obiektów. Aby to zrobić, musisz użyć dalszych instrukcji, aby utworzyć te obiekty zgodnie z wymaganiami.
Ponadto powyższy CREATE DATABASE instrukcja używa najbardziej podstawowej składni, która nie zawiera żadnych argumentów. Istnieje wiele opcji, które można uwzględnić w tym oświadczeniu.
Możesz na przykład określić własną nazwę plików i ich grup plików. Możesz także utworzyć migawkę bazy danych lub dołączyć pliki bazy danych, aby utworzyć bazę danych z odłączonych plików innej bazy danych.
Zapoznaj się z dokumentacją firmy Microsoft, aby uzyskać pełną składnię tej instrukcji.
Utwórz tabele
Oto przykład tworzenia trzech tabel dla powyższej bazy danych.
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
);
Pierwszym krokiem jest przejście do właściwej bazy danych (w tym przypadku bazy danych Muzyka). Aby to zrobić, używamy USE MUSIC .
Gdy już użyjesz właściwej bazy danych, możesz tworzyć swoje tabele i inne obiekty. W tym przypadku stworzyłem trzy tabele. Za każdym razem, gdy używam CREATE TABLE , po którym następuje nazwa tabeli, którą chcę utworzyć. Po nim następuje definicja tej tabeli.
Definicja zawiera kolumny tabeli i ich definicje. Na przykład ArtistId jest kolumną, używa int typ danych i ustawiłem go jako klucz podstawowy dla tabeli. Bycie kluczem podstawowym oznacza, że jednoznacznie identyfikuje każdy wiersz w bazie danych.
Ustawiłem również tę kolumnę jako IDENTITY kolumna, co oznacza, że każdy wiersz będzie używał automatycznie wygenerowanej wartości, która zwiększa się z każdym wierszem. W tym przypadku zacznie się od 1 i zwiększy się o 1 (to dlatego, że określiłem IDENTITY(1,1) .
Na koniec ustawiłem również tę kolumnę na NOT NULL . Oznacza to, że musi zawierać wartość. Nie może być zerowa. W rzeczywistości jest to wymagane przed ustawieniem kolumny jako klucza podstawowego, ale możesz również ustawić inne kolumny na NOT NULL zgodnie z wymaganiami (co zrobiłem w tym przykładzie).
Tworzenie relacji
W powyższym przykładzie stworzyłem relację między Albums i Artists tabele.
Relacja to rodzaj połączenia między tabelami z powiązanymi danymi. Relacje pomagają wymusić integralność danych, ponieważ pozwalają określić, że kolumna może zawierać tylko wartości, które odpowiadają wartościom w określonej kolumnie w innej tabeli.
Oto konkretna sekcja kodu z powyższego przykładu, która tworzy relację:
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
);
Utworzyłem relację w tym samym czasie, w którym tworzyłem Albums stół. Udało mi się to zrobić, ponieważ stworzyłem już Artists tabela (która jest drugą tabelą w relacji).
Utworzyłem relację, tworząc ograniczenie klucza obcego (za pomocą CONSTRAINT argument) i określając FOREIGN KEY wraz ze szczegółami relacji. REFERENCES słowo kluczowe określa, do której tabeli i kolumny odwołuje się klucz obcy.
Nazwałem relację FK_Albums_Artists .
ON DELETE i ON UPDATE części są opcjonalne. Określają, co zrobić w przypadku, gdy ktoś usunie lub zaktualizuje wiersz z kolumny klucza nadrzędnego/podstawowego. Wartość domyślna to NO ACTION , co oznacza, że Aparat Bazy Danych zgłasza błąd, a akcja aktualizacji w wierszu w tabeli nadrzędnej jest wycofywana.
Mój artykuł na temat tworzenia relacji w SQL zawiera listę innych opcji, które możesz tu podać, a także ich działania.
Utwórz relacje później
Możesz także utworzyć relację w istniejącej tabeli.
Aby to zrobić za pomocą T-SQL, użyj ALTER TABLE oświadczenie.
Więc mogę uruchomić następujący kod po uruchomieniu poprzedniego kodu.
ALTER TABLE Albums
ADD CONSTRAINT FK_Albums_Genres FOREIGN KEY (GenreId)
REFERENCES dbo.Genres (GenreId)
ON DELETE NO ACTION
ON UPDATE NO ACTION
;
Tworzy to kolejną relację, tym razem między Albums i Genres tabele.
Widać, że ten kod robi prawie to samo, co poprzedni związek. Jedyna różnica polega na tym, że związek jest między Artists i Genres zamiast Albums i Artists .
W tym przypadku nazwałem relację FK_Albums_Genres .
Wstaw dane
Powyższy kod stworzył bazę danych, która jest odpowiednia dla danych. Możemy teraz dodawać dane.
W SQL Server możesz dodawać dane do bazy danych za pomocą INSERT oświadczenie. Korzystając z tej instrukcji, musisz podać nazwę tabeli, a także kolumny, do których chcesz wstawić dane.
Właściwie podanie kolumn jest opcjonalne, jeśli wstawiasz dane do wszystkich kolumn, ale dla jasności, oto przykład zawierający nazwy kolumn.
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);Jak widać, każdy wiersz ma swoją własną linię. Po prostu dodajemy po jednym wierszu w każdym wierszu, z każdą kolumną oddzieloną przecinkiem i otoczoną nawiasami. Przecinek również oddziela każdy wiersz (po nawiasach).
Uruchomienie powyższego kodu w naszej nowo utworzonej bazie danych daje następujące dane wyjściowe:
(16 rows affected) (8 rows affected) (20 rows affected)
To mówi nam, że dane zostały pomyślnie wstawione.
Sprawdź bazę danych
Możemy przeprowadzić szybki test w bazie danych, aby sprawdzić, czy została utworzona, a nasze dane zostały wstawione.
Na przykład możemy uruchomić następujące proste zapytanie.
SELECT * FROM Artists;Wynik:
+------------+------------------------+--------------+ | 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 | +------------+------------------------+--------------+
I uruchommy kolejne zapytanie, które wykorzystuje dane ze wszystkich trzech tabel.
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';Wynik:
+----------------+-------------------------+---------------+ | 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 | +----------------+-------------------------+---------------+
To zapytanie pokazuje, jak ważne jest tworzenie relacji między tabelami z powiązanymi danymi. Kiedy uruchamiamy takie zapytania, naprawdę potrzebujemy, aby dane między tabelami były spójne.
Baza danych jest teraz gotowa do użycia. Możemy uruchomić przeciwko niemu zapytania. Możemy wstawić więcej danych. Możemy dodać więcej tabel, relacji, widoków, procedur składowanych, funkcji zdefiniowanych przez użytkownika i wiele więcej.
