Molti sviluppatori e amministratori di database creano database utilizzando strumenti della GUI come SQL Server Management Studio (SSMS), Azure Data Studio e così via.
Ma può essere molto più veloce creare database usando SQL. Ciò è particolarmente vero se si dispone di vari ambienti in cui è necessario ricreare lo stesso database. È possibile eseguire lo stesso script su ciascun ambiente e il database verrà creato ogni volta in pochi secondi.
In SQL Server, lo facciamo con T-SQL. T-SQL sta per Transact-SQL ed è l'estensione di SQL Server a SQL.
Di seguito è riportato un esempio di utilizzo di T-SQL per creare un database in SQL Server.
Codice Base
CREATE DATABASE Music;Questo è tutto il codice necessario per creare un database. In questo caso, crea un database chiamato Music .
Tuttavia, questo è tutto ciò che crea. Il database non contiene tabelle o altri oggetti. Per fare ciò, devi utilizzare ulteriori istruzioni per creare quegli oggetti come richiesto.
Inoltre, il precedente CREATE DATABASE istruzione utilizza la sintassi più semplice che non include argomenti. Ci sono molte opzioni che possono essere incluse in questa affermazione.
Ad esempio, puoi specificare il tuo nome per i file e i relativi filegroup. Puoi anche creare uno snapshot del database o allegare file di database per creare un database dai file staccati di un altro database.
Consulta la documentazione Microsoft per la sintassi completa di questa istruzione.
Crea tabelle
Ecco un esempio di creazione di tre tabelle per il database sopra.
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
);
Il primo passo è passare al database corretto (in questo caso, il database Music). Per fare ciò, utilizziamo USE MUSIC .
Dopo aver utilizzato il database corretto, puoi creare le tue tabelle e altri oggetti. In questo caso ho creato tre tabelle. Ogni volta che utilizzo CREATE TABLE , seguito dal nome della tabella che voglio creare. Segue la definizione di quella tabella.
La definizione include le colonne della tabella e le relative definizioni. Ad esempio, ArtistId è una colonna, utilizza un int tipo di dati e l'ho impostato come chiave primaria per la tabella. Essere la chiave primaria significa che identifica in modo univoco ogni riga nel database.
Ho anche impostato questa colonna come IDENTITY colonna, il che significa che ogni riga utilizzerà un valore generato automaticamente che aumenta con ogni riga. In questo caso inizierà da 1 e aumenterà di 1 (questo perché ho specificato IDENTITY(1,1) .
Infine, ho anche impostato questa colonna su NOT NULL . Ciò significa che deve contenere un valore. Non può essere nullo. Questo è in realtà un requisito prima di impostare la colonna come chiave primaria, ma puoi anche impostare altre colonne su NOT NULL come richiesto (cosa che ho fatto in questo esempio).
Crea relazioni
Nell'esempio sopra, ho creato una relazione tra gli Albums e Artists tavoli.
Una relazione è una sorta di collegamento tra tabelle con dati correlati. Le relazioni aiutano a rafforzare l'integrità dei dati, perché consentono di specificare che una colonna può contenere solo valori che corrispondono ai valori di una colonna specifica in un'altra tabella.
Ecco la sezione specifica del codice dell'esempio precedente che crea la relazione:
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
);
Ho creato la relazione nello stesso momento in cui ho creato gli Albums tavolo. Sono stato in grado di farlo perché avevo già creato gli Artists table (che è l'altra tabella nella relazione).
Ho creato la relazione creando un vincolo di chiave esterna (usando il CONSTRAINT argomento) e specificando FOREIGN KEY insieme ai dettagli della relazione. I REFERENCES la parola chiave specifica a quale tabella e colonna fa riferimento la chiave esterna.
Ho chiamato la relazione FK_Albums_Artists .
Il ON DELETE e ON UPDATE le parti sono opzionali. Specificano cosa fare nel caso in cui qualcuno elimini o aggiorni una riga dalla colonna della chiave principale/primaria. Il valore predefinito è NO ACTION , il che significa che Motore di database genera un errore e viene eseguito il rollback dell'azione di aggiornamento sulla riga nella tabella padre.
Il mio articolo su Come creare una relazione in SQL elenca le altre opzioni che puoi fornire qui, oltre alle funzioni di ciascuna opzione.
Crea relazioni in seguito
Puoi anche creare una relazione su una tabella esistente.
Per farlo usando T-SQL, usa ALTER TABLE dichiarazione.
Quindi posso eseguire il codice seguente dopo aver eseguito il codice precedente.
ALTER TABLE Albums
ADD CONSTRAINT FK_Albums_Genres FOREIGN KEY (GenreId)
REFERENCES dbo.Genres (GenreId)
ON DELETE NO ACTION
ON UPDATE NO ACTION
;
Questo crea un'altra relazione, questa volta tra gli Albums e Genres tavoli.
Puoi vedere che questo codice fa praticamente la stessa cosa della relazione precedente. L'unica differenza è che la relazione è tra Artists e Genres invece di Albums e Artists .
In questo caso ho chiamato la relazione FK_Albums_Genres .
Inserisci dati
Il codice sopra ha creato un database adatto ai dati. Ora possiamo aggiungere dati.
In SQL Server puoi aggiungere dati a un database utilizzando INSERT dichiarazione. Quando si utilizza questa istruzione, è necessario fornire il nome della tabella, nonché le colonne in cui si desidera inserire i dati.
In realtà, fornire le colonne è facoltativo se stai inserendo i dati in tutte le colonne, ma per motivi di chiarezza, ecco un esempio che include i nomi delle 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);Come puoi vedere, ogni riga ha la sua linea. Aggiungiamo semplicemente una riga per riga con ogni colonna separata da una virgola e racchiusa tra parentesi. Una virgola separa anche ogni riga (dopo le parentesi).
L'esecuzione del codice sopra sul nostro database appena creato risulta nel seguente output:
(16 rows affected) (8 rows affected) (20 rows affected)
Questo ci dice che i dati sono stati inseriti correttamente.
Controlla il database
Possiamo eseguire un rapido test sul database per verificare che sia stato creato e che i nostri dati siano stati inseriti.
Ad esempio, possiamo eseguire la seguente semplice query.
SELECT * FROM Artists;Risultato:
+------------+------------------------+--------------+ | 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 | +------------+------------------------+--------------+
Ed eseguiamo un'altra query che utilizza i dati di tutte e tre le tabelle.
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';Risultato:
+----------------+-------------------------+---------------+ | 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 | +----------------+-------------------------+---------------+
Questa query dimostra l'importanza di creare relazioni tra tabelle con dati correlati. Quando eseguiamo query come questa, abbiamo davvero bisogno che i dati siano coerenti tra le tabelle.
Il database è ora pronto per l'uso. Possiamo eseguire query su di esso. Possiamo inserire più dati. Possiamo aggiungere più tabelle, relazioni, viste, stored procedure, funzioni definite dall'utente e molto altro.
