Mange udviklere og databaseadministratorer opretter databaser ved hjælp af GUI-værktøjer såsom SQL Server Management Studio (SSMS), Azure Data Studio osv.
Men det kan være meget hurtigere at oprette databaser ved hjælp af SQL. Dette gælder især, hvis du har forskellige miljøer, som du skal genskabe den samme database på. Du kan køre det samme script mod hvert miljø, og databasen vil blive oprettet inden for få sekunder hver gang.
I SQL Server gør vi dette med T-SQL. T-SQL står for Transact-SQL, og det er SQL Servers udvidelse til SQL.
Nedenfor er et eksempel på brug af T-SQL til at oprette en database i SQL Server.
Grundlæggende kode
CREATE DATABASE Music;Dette er al den kode, du behøver for at oprette en database. I dette tilfælde opretter den en database kaldet Musik .
Det er dog alt, hvad det skaber. Databasen indeholder ingen tabeller eller andre objekter. For at gøre det skal du bruge yderligere sætninger til at oprette disse objekter efter behov.
Også ovenstående CREATE DATABASE sætning bruger den mest grundlæggende syntaks, som ikke inkluderer nogen argumenter. Der er mange muligheder, der kan inkluderes i denne erklæring.
Du kan f.eks. angive dit eget navn for filerne og deres filgrupper. Du kan også oprette et database-øjebliksbillede eller vedhæfte databasefiler for at oprette en database fra de frigjorte filer i en anden database.
Se Microsoft-dokumentationen for den fulde syntaks for denne erklæring.
Opret tabeller
Her er et eksempel på oprettelse af tre tabeller til ovenstående database.
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
);
Det første trin er at skifte til den korrekte database (i dette tilfælde Musikdatabasen). For at gøre dette bruger vi USE MUSIC .
Når du bruger den korrekte database, kan du oprette dine tabeller og andre objekter. I dette tilfælde oprettede jeg tre tabeller. Hver gang jeg bruger CREATE TABLE , efterfulgt af det tabelnavn, jeg vil oprette. Dette efterfølges af tabellens definition.
Definitionen inkluderer tabellens kolonner og deres definitioner. For eksempel ArtistId er en kolonne, bruger den en int datatype, og jeg har sat den som den primære nøgle til tabellen. At være den primære nøgle betyder, at den entydigt identificerer hver række i databasen.
Jeg har også indstillet denne kolonne til at være en IDENTITY kolonne, hvilket betyder, at hver række vil bruge en automatisk genereret værdi, der stiger med hver række. I dette tilfælde starter den ved 1 og stiger med 1 (det er fordi jeg har angivet IDENTITY(1,1) .
Endelig har jeg også sat denne kolonne til NOT NULL . Det betyder, at den skal indeholde en værdi. Det kan ikke være nul. Dette er faktisk et krav, før du indstiller kolonnen som en primær nøgle, men du kan også indstille andre kolonner til NOT NULL efter behov (hvilket jeg har gjort i dette eksempel).
Opret relationer
I eksemplet ovenfor oprettede jeg en relation mellem Albums og Artists tabeller.
En relation er en slags forbindelse mellem tabeller med relaterede data. Relationer hjælper med at håndhæve dataintegritet, fordi de giver dig mulighed for at angive, at en kolonne kun kan indeholde værdier, der matcher værdierne i en specifik kolonne i en anden tabel.
Her er den specifikke sektion af kode fra ovenstående eksempel, der skaber forholdet:
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
);
Jeg oprettede forholdet på samme tid, som jeg oprettede Albums bord. Jeg var i stand til at gøre det, fordi jeg allerede havde oprettet Artists tabel (som er den anden tabel i forholdet).
Jeg oprettede relationen ved at oprette en fremmednøgle-begrænsning (ved at bruge CONSTRAINT argument), og angiver FOREIGN KEY sammen med detaljerne i forholdet. REFERENCES nøgleordet angiver, hvilken tabel og kolonne den fremmede nøgle refererer til.
Jeg kaldte forholdet FK_Albums_Artists .
ON DELETE og ON UPDATE dele er valgfrie. De specificerer, hvad der skal gøres i tilfælde af, at nogen sletter eller opdaterer en række fra kolonnen overordnet/primær nøgle. Standardværdien er NO ACTION , hvilket betyder, at databasemotoren rejser en fejl, og opdateringshandlingen på rækken i den overordnede tabel rulles tilbage.
Min artikel om, hvordan man opretter et forhold i SQL, viser de andre muligheder, du kan give her, samt hvad hver mulighed gør.
Opret relationer senere
Du kan også oprette en relation på en eksisterende tabel.
For at gøre dette ved hjælp af T-SQL, brug ALTER TABLE erklæring.
Så jeg kan køre følgende kode efter at have kørt den forrige kode.
ALTER TABLE Albums
ADD CONSTRAINT FK_Albums_Genres FOREIGN KEY (GenreId)
REFERENCES dbo.Genres (GenreId)
ON DELETE NO ACTION
ON UPDATE NO ACTION
;
Dette skaber endnu et forhold, denne gang mellem Albums og Genres tabeller.
Du kan se, at denne kode stort set gør det samme som det tidligere forhold. Den eneste forskel er, at forholdet er mellem Artists og Genres i stedet for Albums og Artists .
I dette tilfælde kaldte jeg forholdet FK_Albums_Genres .
Indsæt data
Ovenstående kode har skabt en database, der er egnet til data. Vi kan nu tilføje data.
I SQL Server kan du tilføje data til en database ved at bruge INSERT udmelding. Når du bruger denne erklæring, skal du angive navnet på tabellen samt de kolonner, du gerne vil indsætte data i.
Faktisk er det valgfrit at angive kolonnerne, hvis du indsætter data i alle kolonner, men for overskuelighedens skyld er her et eksempel, der inkluderer kolonnenavnene.
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);Som du kan se, har hver række sin egen linje. Vi tilføjer blot en linje pr. række med hver kolonne adskilt af et komma og omgivet af parenteser. Et komma adskiller også hver række (efter parenteserne).
Kørsel af ovenstående kode mod vores nyoprettede database resulterer i følgende output:
(16 rows affected) (8 rows affected) (20 rows affected)
Dette fortæller os, at dataene blev indsat.
Tjek databasen
Vi kan køre en hurtig test mod databasen for at bekræfte, at den blev oprettet og vores data blev indsat.
For eksempel kan vi køre følgende simple forespørgsel.
SELECT * FROM Artists;Resultat:
+------------+------------------------+--------------+ | 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 | +------------+------------------------+--------------+
Og lad os køre en anden forespørgsel, der bruger data fra alle tre tabeller.
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';Resultat:
+----------------+-------------------------+---------------+ | 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 | +----------------+-------------------------+---------------+
Denne forespørgsel demonstrerer vigtigheden af at skabe relationer mellem tabeller med relaterede data. Når vi kører forespørgsler som denne, har vi virkelig brug for, at dataene er konsistente mellem tabellerne.
Databasen er nu klar til brug. Vi kan køre forespørgsler mod det. Vi kan indsætte flere data. Vi kan tilføje flere tabeller, relationer, visninger, lagrede procedurer, brugerdefinerede funktioner og meget mere.