Många utvecklare och databasadministratörer skapar databaser med GUI-verktyg som SQL Server Management Studio (SSMS), Azure Data Studio, etc.
Men det kan gå mycket snabbare att skapa databaser med SQL. Detta gäller särskilt om du har olika miljöer som du behöver återskapa samma databas på. Du kan köra samma skript mot varje miljö, och databasen kommer att skapas inom några sekunder varje gång.
I SQL Server gör vi detta med T-SQL. T-SQL står för Transact-SQL, och det är SQL Servers tillägg till SQL.
Nedan är ett exempel på hur man använder T-SQL för att skapa en databas i SQL Server.
Grundläggande kod
CREATE DATABASE Music;Detta är all kod du behöver för att skapa en databas. I det här fallet skapar den en databas som heter Musik .
Men det är allt det skapar. Databasen innehåller inga tabeller eller andra objekt. För att göra det måste du använda ytterligare satser för att skapa dessa objekt efter behov.
Också ovanstående CREATE DATABASE uttalandet använder den mest grundläggande syntaxen som inte innehåller några argument. Det finns många alternativ som kan inkluderas i detta uttalande.
Du kan till exempel ange ditt eget namn för filerna och deras filgrupper. Du kan också skapa en ögonblicksbild av databasen eller bifoga databasfiler för att skapa en databas från de frigjorda filerna i en annan databas.
Se Microsofts dokumentation för den fullständiga syntaxen för detta uttalande.
Skapa tabeller
Här är ett exempel på hur du skapar tre tabeller för databasen ovan.
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örsta steget är att byta till rätt databas (i det här fallet Musikdatabasen). För att göra detta använder vi USE MUSIC .
När du väl använder rätt databas kan du skapa dina tabeller och andra objekt. I det här fallet skapade jag tre tabeller. Varje gång jag använder CREATE TABLE , följt av tabellnamnet som jag vill skapa. Detta följs av den tabellens definition.
Definitionen inkluderar tabellens kolumner och deras definitioner. Till exempel ArtistId är en kolumn använder den en int datatyp, och jag har angett den som den primära nyckeln för tabellen. Att vara den primära nyckeln innebär att den unikt identifierar varje rad i databasen.
Jag har också ställt in den här kolumnen som en IDENTITY kolumn, vilket innebär att varje rad kommer att använda ett automatiskt genererat värde som ökar med varje rad. I det här fallet börjar den med 1 och ökar med 1 (det beror på att jag har angett IDENTITY(1,1) .
Slutligen har jag också ställt in den här kolumnen till NOT NULL . Det betyder att den måste innehålla ett värde. Den kan inte vara null. Detta är faktiskt ett krav innan du ställer in kolumnen som en primärnyckel, men du kan också ställa in andra kolumner till NOT NULL som krävs (vilket jag har gjort i det här exemplet).
Skapa relationer
I exemplet ovan skapade jag en relation mellan Albums och Artists tabeller.
En relation är en slags länk mellan tabeller med relaterade data. Relationer hjälper till att upprätthålla dataintegritet, eftersom de låter dig ange att en kolumn bara kan innehålla värden som matchar värdena i en specifik kolumn i en annan tabell.
Här är den specifika kodavsnittet från exemplet ovan som skapar relationen:
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
);
Jag skapade relationen samtidigt som jag skapade Albums tabell. Jag kunde göra det eftersom jag redan hade skapat Artists tabell (som är den andra tabellen i relationen).
Jag skapade relationen genom att skapa en främmande nyckel-begränsning (med hjälp av CONSTRAINT argument), och anger FOREIGN KEY tillsammans med detaljerna i förhållandet. REFERENCES nyckelordet anger vilken tabell och kolumn den främmande nyckeln refererar till.
Jag döpte förhållandet till FK_Albums_Artists .
ON DELETE och ON UPDATE delar är valfria. De anger vad som ska göras om någon tar bort eller uppdaterar en rad från kolumnen för överordnad/primär nyckel. Standardvärdet är NO ACTION , vilket innebär att databasmotorn ger upphov till ett fel, och uppdateringsåtgärden på raden i den överordnade tabellen återställs.
Min artikel om hur man skapar en relation i SQL listar de andra alternativen du kan tillhandahålla här, samt vad varje alternativ gör.
Skapa relationer senare
Du kan också skapa en relation på en befintlig tabell.
För att göra detta med T-SQL, använd ALTER TABLE uttalande.
Så jag kan köra följande kod efter att ha kört föregående kod.
ALTER TABLE Albums
ADD CONSTRAINT FK_Albums_Genres FOREIGN KEY (GenreId)
REFERENCES dbo.Genres (GenreId)
ON DELETE NO ACTION
ON UPDATE NO ACTION
;
Detta skapar ytterligare en relation, denna gång mellan Albums och Genres tabeller.
Du kan se att den här koden gör ungefär samma sak som den tidigare relationen. Den enda skillnaden är att förhållandet är mellan Artists och Genres istället för Albums och Artists .
I det här fallet döpte jag förhållandet till FK_Albums_Genres .
Infoga data
Ovanstående kod har skapat en databas som är lämplig för data. Vi kan nu lägga till data.
I SQL Server kan du lägga till data till en databas genom att använda INSERT påstående. När du använder den här satsen måste du ange namnet på tabellen, samt de kolumner du vill infoga data i.
Egentligen är det valfritt att tillhandahålla kolumnerna om du infogar data i alla kolumner, men för tydlighetens skull är här ett exempel som inkluderar kolumnnamnen.
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 varje rad sin egen linje. Vi lägger helt enkelt till en rad per rad med varje kolumn separerad av ett kommatecken och omgiven av parenteser. Ett kommatecken skiljer också varje rad åt (efter parenteserna).
Att köra ovanstående kod mot vår nyskapade databas resulterar i följande utdata:
(16 rows affected) (8 rows affected) (20 rows affected)
Detta talar om för oss att data har infogats.
Kontrollera databasen
Vi kan köra ett snabbtest mot databasen för att verifiera att den skapades och att vår data infogades.
Till exempel kan vi köra följande enkla fråga.
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 | +------------+------------------------+--------------+
Och låt oss köra en annan fråga som använder data från alla tre tabellerna.
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 | +----------------+-------------------------+---------------+
Den här frågan visar vikten av att skapa relationer mellan tabeller med relaterade data. När vi kör frågor som denna behöver vi verkligen att data är konsekventa mellan tabellerna.
Databasen är nu klar att användas. Vi kan köra frågor mot det. Vi kan infoga mer data. Vi kan lägga till fler tabeller, relationer, vyer, lagrade procedurer, användardefinierade funktioner och mycket mer.