Veel ontwikkelaars en databasebeheerders maken databases met GUI-tools zoals SQL Server Management Studio (SSMS), Azure Data Studio, enz.
Maar het kan veel sneller zijn om databases te maken met SQL. Dit is met name het geval als u verschillende omgevingen hebt waarop u dezelfde database opnieuw moet maken. U kunt hetzelfde script voor elke omgeving uitvoeren en de database wordt elke keer binnen enkele seconden gemaakt.
In SQL Server doen we dit met T-SQL. T-SQL staat voor Transact-SQL en is de uitbreiding van SQL Server op SQL.
Hieronder ziet u een voorbeeld van het gebruik van T-SQL om een database in SQL Server te maken.
Basiscode
CREATE DATABASE Music;Dit is alle code die je nodig hebt om een database te maken. In dit geval creëert het een database genaamd Muziek .
Dat is echter alles wat het creëert. De database bevat geen tabellen of andere objecten. Om dat te doen, moet u verdere instructies gebruiken om die objecten naar wens te maken.
Ook de bovenstaande CREATE DATABASE statement gebruikt de meest elementaire syntaxis die geen argumenten bevat. Er zijn veel opties die kunnen worden opgenomen in deze verklaring.
U kunt bijvoorbeeld uw eigen naam opgeven voor de bestanden en hun bestandsgroepen. U kunt ook een database-snapshot maken of databasebestanden bijvoegen om een database te maken van de losgekoppelde bestanden van een andere database.
Zie de Microsoft-documentatie voor de volledige syntaxis van deze verklaring.
Tabellen maken
Hier is een voorbeeld van het maken van drie tabellen voor de bovenstaande 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
);
De eerste stap is om over te schakelen naar de juiste database (in dit geval de muziekdatabase). Om dit te doen, gebruiken we USE MUSIC .
Zodra u de juiste database gebruikt, kunt u uw tabellen en andere objecten maken. In dit geval heb ik drie tabellen gemaakt. Elke keer dat ik CREATE TABLE gebruik , gevolgd door de tabelnaam die ik wil maken. Dit wordt gevolgd door de definitie van die tabel.
De definitie omvat de kolommen van de tabel en hun definities. Bijvoorbeeld ArtistId is een kolom, het gebruikt een int gegevenstype, en ik heb het ingesteld als de primaire sleutel voor de tabel. Omdat het de primaire sleutel is, betekent dit dat het elke rij in de database op unieke wijze identificeert.
Ik heb deze kolom ook ingesteld als een IDENTITY kolom, wat betekent dat elke rij een automatisch gegenereerde waarde gebruikt die met elke rij wordt verhoogd. In dit geval begint het met 1 en wordt het met 1 verhoogd (dat komt omdat ik IDENTITY(1,1) heb opgegeven .
Ten slotte heb ik deze kolom ook ingesteld op NOT NULL . Dit betekent dat het een waarde moet bevatten. Het kan niet nul zijn. Dit is eigenlijk een vereiste voordat u de kolom als primaire sleutel instelt, maar u kunt ook andere kolommen instellen op NOT NULL zoals vereist (wat ik in dit voorbeeld heb gedaan).
Relaties creëren
In het bovenstaande voorbeeld heb ik een relatie gemaakt tussen de Albums en Artists tafels.
Een relatie is een soort koppeling tussen tabellen met gerelateerde gegevens. Relaties helpen de gegevensintegriteit af te dwingen, omdat u hiermee kunt specificeren dat een kolom alleen waarden mag bevatten die overeenkomen met de waarden in een specifieke kolom in een andere tabel.
Hier is het specifieke gedeelte van de code uit het bovenstaande voorbeeld dat de relatie creëert:
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
);
Ik heb de relatie gemaakt op hetzelfde moment dat ik de Albums . heb gemaakt tafel. Ik kon dat doen omdat ik de Artists . al had gemaakt tabel (dit is de andere tabel in de relatie).
Ik heb de relatie gemaakt door een externe sleutelbeperking te maken (met behulp van de CONSTRAINT argument), en het specificeren van FOREIGN KEY samen met de details van de relatie. De REFERENCES trefwoord specificeert naar welke tabel en kolom de refererende sleutel verwijst.
Ik noemde de relatie FK_Albums_Artists .
De ON DELETE en ON UPDATE onderdelen zijn optioneel. Ze specificeren wat te doen in het geval dat iemand een rij verwijdert of bijwerkt uit de bovenliggende/primaire sleutelkolom. De standaardwaarde is NO ACTION , wat betekent dat de database-engine een fout genereert en de update-actie op de rij in de bovenliggende tabel wordt teruggedraaid.
Mijn artikel over het maken van een relatie in SQL geeft een overzicht van de andere opties die u hier kunt bieden, evenals wat elke optie doet.
Maak later relaties aan
U kunt ook een relatie maken op een bestaande tafel.
Om dit te doen met T-SQL, gebruikt u de ALTER TABLE verklaring.
Dus ik kan de volgende code uitvoeren nadat ik de vorige code heb uitgevoerd.
ALTER TABLE Albums
ADD CONSTRAINT FK_Albums_Genres FOREIGN KEY (GenreId)
REFERENCES dbo.Genres (GenreId)
ON DELETE NO ACTION
ON UPDATE NO ACTION
;
Dit creëert een nieuwe relatie, dit keer tussen de Albums en Genres tafels.
Je kunt zien dat deze code vrijwel hetzelfde doet als de vorige relatie. Het enige verschil is dat er een relatie is tussen Artists en Genres in plaats van Albums en Artists .
In dit geval noemde ik de relatie FK_Albums_Genres .
Gegevens invoegen
De bovenstaande code heeft een database gecreëerd die geschikt is voor gegevens. We kunnen nu gegevens toevoegen.
In SQL Server kunt u gegevens aan een database toevoegen met behulp van de INSERT uitspraak. Wanneer u deze verklaring gebruikt, moet u de naam van de tabel opgeven, evenals de kolommen waarin u gegevens wilt invoegen.
Het verstrekken van de kolommen is eigenlijk optioneel als u gegevens in alle kolommen invoegt, maar voor de duidelijkheid volgt hier een voorbeeld dat de kolomnamen bevat.
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);Zoals je kunt zien, heeft elke rij zijn eigen regel. We voegen eenvoudig één regel per rij toe, waarbij elke kolom wordt gescheiden door een komma en wordt omgeven door haakjes. Een komma scheidt ook elke rij (na de haakjes).
Het uitvoeren van de bovenstaande code tegen onze nieuw gemaakte database resulteert in de volgende uitvoer:
(16 rows affected) (8 rows affected) (20 rows affected)
Dit vertelt ons dat de gegevens met succes zijn ingevoerd.
Controleer de database
We kunnen een snelle test uitvoeren met de database om te verifiëren dat deze is gemaakt en dat onze gegevens zijn ingevoegd.
We kunnen bijvoorbeeld de volgende eenvoudige query uitvoeren.
SELECT * FROM Artists;Resultaat:
+------------+------------------------+--------------+ | 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 | +------------+------------------------+--------------+
En laten we nog een query uitvoeren die gegevens uit alle drie de tabellen gebruikt.
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';Resultaat:
+----------------+-------------------------+---------------+ | 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 | +----------------+-------------------------+---------------+
Deze query toont het belang aan van het maken van relaties tussen tabellen met gerelateerde gegevens. Als we dergelijke zoekopdrachten uitvoeren, hebben we de gegevens echt nodig om consistent te zijn tussen de tabellen.
De database is nu klaar voor gebruik. We kunnen er query's tegen uitvoeren. We kunnen meer gegevens invoeren. We kunnen meer tabellen, relaties, views, opgeslagen procedures, door de gebruiker gedefinieerde functies en nog veel meer toevoegen.