De nombreux développeurs et administrateurs de bases de données créent des bases de données à l'aide d'outils graphiques tels que SQL Server Management Studio (SSMS), Azure Data Studio, etc.
Mais il peut être beaucoup plus rapide de créer des bases de données en utilisant SQL. Cela est particulièrement vrai si vous avez plusieurs environnements sur lesquels vous devez recréer la même base de données. Vous pouvez exécuter le même script sur chaque environnement et la base de données sera créée en quelques secondes à chaque fois.
Dans SQL Server, nous le faisons avec T-SQL. T-SQL signifie Transact-SQL, et c'est l'extension de SQL Server à SQL.
Vous trouverez ci-dessous un exemple d'utilisation de T-SQL pour créer une base de données dans SQL Server.
Code de base
CREATE DATABASE Music;C'est tout le code dont vous avez besoin pour créer une base de données. Dans ce cas, il crée une base de données appelée Music .
Cependant, c'est tout ce qu'il crée. La base de données ne contient aucune table ni aucun autre objet. Pour ce faire, vous devez utiliser d'autres instructions pour créer ces objets selon vos besoins.
En outre, le CREATE DATABASE ci-dessus L'instruction utilise la syntaxe la plus basique qui n'inclut aucun argument. De nombreuses options peuvent être incluses dans cette déclaration.
Par exemple, vous pouvez spécifier votre propre nom pour les fichiers et leurs groupes de fichiers. Vous pouvez également créer un instantané de base de données ou joindre des fichiers de base de données pour créer une base de données à partir des fichiers détachés d'une autre base de données.
Consultez la documentation Microsoft pour la syntaxe complète de cette instruction.
Créer des tableaux
Voici un exemple de création de trois tables pour la base de données ci-dessus.
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
);
La première étape consiste à basculer vers la bonne base de données (dans ce cas, la base de données Musique). Pour ce faire, nous utilisons USE MUSIC .
Une fois que vous utilisez la bonne base de données, vous pouvez créer vos tables et autres objets. Dans ce cas, j'ai créé trois tables. Chaque fois que j'utilise CREATE TABLE , suivi du nom de la table que je souhaite créer. Ceci est suivi de la définition de cette table.
La définition inclut les colonnes du tableau et leurs définitions. Par exemple, ArtistId est une colonne, elle utilise un int type de données, et je l'ai défini comme clé primaire pour la table. Être la clé primaire signifie qu'elle identifie de manière unique chaque ligne de la base de données.
J'ai également défini cette colonne comme étant une IDENTITY colonne, ce qui signifie que chaque ligne utilisera une valeur générée automatiquement qui s'incrémente à chaque ligne. Dans ce cas, il commencera à 1 et augmentera de 1 (c'est parce que j'ai spécifié IDENTITY(1,1) .
Enfin, j'ai également défini cette colonne sur NOT NULL . Cela signifie qu'il doit contenir une valeur. Il ne peut pas être nul. Il s'agit en fait d'une exigence avant de définir la colonne comme clé primaire, mais vous pouvez également définir d'autres colonnes sur NOT NULL selon les besoins (ce que j'ai fait dans cet exemple).
Créer des relations
Dans l'exemple ci-dessus, j'ai créé une relation entre les Albums et Artists les tables.
Une relation est une sorte de lien entre des tables avec des données liées. Les relations aident à renforcer l'intégrité des données, car elles vous permettent de spécifier qu'une colonne ne peut contenir que des valeurs qui correspondent aux valeurs d'une colonne spécifique dans une autre table.
Voici la section de code spécifique de l'exemple ci-dessus qui crée la relation :
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
);
J'ai créé la relation en même temps que j'ai créé les Albums table. J'ai pu le faire car j'avais déjà créé les Artists table (qui est l'autre table de la relation).
J'ai créé la relation en créant une contrainte de clé étrangère (en utilisant la CONSTRAINT argument), et en spécifiant FOREIGN KEY ainsi que les détails de la relation. Les REFERENCES mot-clé spécifie à quelle table et colonne la clé étrangère fait référence.
J'ai nommé la relation FK_Albums_Artists .
Le ON DELETE et ON UPDATE les pièces sont facultatives. Ils spécifient ce qu'il faut faire au cas où quelqu'un supprimerait ou mettrait à jour une ligne de la colonne parent/clé primaire. La valeur par défaut est NO ACTION , ce qui signifie que le moteur de base de données génère une erreur et que l'action de mise à jour sur la ligne de la table parent est annulée.
Mon article sur Comment créer une relation en SQL répertorie les autres options que vous pouvez fournir ici, ainsi que ce que fait chaque option.
Créer des relations plus tard
Vous pouvez également créer une relation sur une table existante.
Pour ce faire en utilisant T-SQL, utilisez le ALTER TABLE déclaration.
Je peux donc exécuter le code suivant après avoir exécuté le code précédent.
ALTER TABLE Albums
ADD CONSTRAINT FK_Albums_Genres FOREIGN KEY (GenreId)
REFERENCES dbo.Genres (GenreId)
ON DELETE NO ACTION
ON UPDATE NO ACTION
;
Cela crée une autre relation, cette fois entre les Albums et Genres les tables.
Vous pouvez voir que ce code fait à peu près la même chose que la relation précédente. La seule différence est que la relation est entre Artists et Genres au lieu de Albums et Artists .
Dans ce cas, j'ai nommé la relation FK_Albums_Genres .
Insérer des données
Le code ci-dessus a créé une base de données adaptée aux données. Nous pouvons maintenant ajouter des données.
Dans SQL Server, vous pouvez ajouter des données à une base de données en utilisant le INSERT déclaration. Lorsque vous utilisez cette instruction, vous devez fournir le nom de la table, ainsi que les colonnes dans lesquelles vous souhaitez insérer des données.
En fait, fournir les colonnes est facultatif si vous insérez des données dans toutes les colonnes, mais par souci de clarté, voici un exemple qui inclut les noms de colonne.
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);Comme vous pouvez le voir, chaque ligne a sa propre ligne. Nous ajoutons simplement une ligne par ligne avec chaque colonne séparée par une virgule et entourée de parenthèses. Une virgule sépare également chaque ligne (après les parenthèses).
L'exécution du code ci-dessus sur notre base de données nouvellement créée donne le résultat suivant :
(16 rows affected) (8 rows affected) (20 rows affected)
Cela nous indique que les données ont été insérées avec succès.
Vérifiez la base de données
Nous pouvons exécuter un test rapide sur la base de données pour vérifier qu'elle a été créée et que nos données ont été insérées.
Par exemple, nous pouvons exécuter la requête simple suivante.
SELECT * FROM Artists;Résultat :
+------------+------------------------+--------------+ | 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 | +------------+------------------------+--------------+
Et exécutons une autre requête qui utilise les données des trois tables.
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';Résultat :
+----------------+-------------------------+---------------+ | 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 | +----------------+-------------------------+---------------+
Cette requête montre l'importance de créer des relations entre les tables avec des données liées. Lorsque nous exécutons des requêtes comme celle-ci, nous avons vraiment besoin que les données soient cohérentes entre les tables.
La base de données est maintenant prête à être utilisée. Nous pouvons exécuter des requêtes contre elle. Nous pouvons insérer plus de données. Nous pouvons ajouter plus de tables, de relations, de vues, de procédures stockées, de fonctions définies par l'utilisateur et bien plus encore.
