Muitos desenvolvedores e administradores de banco de dados criam bancos de dados usando ferramentas GUI, como SQL Server Management Studio (SSMS), Azure Data Studio etc.
Mas pode ser muito mais rápido criar bancos de dados usando SQL. Isso é especialmente verdadeiro se você tiver vários ambientes nos quais precisa recriar o mesmo banco de dados. Você pode executar o mesmo script em cada ambiente e o banco de dados será criado em segundos a cada vez.
No SQL Server, fazemos isso com T-SQL. T-SQL significa Transact-SQL e é a extensão do SQL Server para SQL.
Abaixo está um exemplo de uso do T-SQL para criar um banco de dados no SQL Server.
Código Básico
CREATE DATABASE Music;Este é todo o código que você precisa para criar um banco de dados. Neste caso, ele cria um banco de dados chamado Música .
No entanto, isso é tudo o que ele cria. O banco de dados não contém tabelas ou outros objetos. Para fazer isso, você deve usar outras instruções para criar esses objetos conforme necessário.
Além disso, o
CREATE DATABASE acima instrução usa a sintaxe mais básica que não inclui nenhum argumento. Há muitas opções que podem ser incluídas com esta declaração. Por exemplo, você pode especificar seu próprio nome para os arquivos e seus grupos de arquivos. Você também pode criar um instantâneo de banco de dados ou anexar arquivos de banco de dados para criar um banco de dados dos arquivos desanexados de outro banco de dados.
Consulte a documentação da Microsoft para obter a sintaxe completa dessa instrução.
Criar tabelas
Aqui está um exemplo de criação de três tabelas para o banco de dados acima.
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
);O primeiro passo é mudar para o banco de dados correto (neste caso, o banco de dados Music). Para fazer isso, usamos
USE MUSIC . Depois de usar o banco de dados correto, você pode criar suas tabelas e outros objetos. Neste caso eu criei três tabelas. Cada vez que eu uso
CREATE TABLE , seguido pelo nome da tabela que desejo criar. Isto é seguido pela definição dessa tabela. A definição inclui as colunas da tabela e suas definições. Por exemplo,
ArtistId é uma coluna, ela usa um int tipo de dados e defini-o como a chave primária da tabela. Ser a chave primária significa que ela identifica exclusivamente cada linha no banco de dados. Também configurei esta coluna para ser uma
IDENTITY coluna, o que significa que cada linha usará um valor gerado automaticamente que é incrementado com cada linha. Nesse caso, ele começará em 1 e será incrementado em 1 (isso porque eu especifiquei IDENTITY(1,1) . Por fim, também defini esta coluna como
NOT NULL . Isso significa que ele deve conter um valor. Não pode ser nulo. Na verdade, isso é um requisito antes de definir a coluna como chave primária, mas você também pode definir outras colunas como NOT NULL conforme necessário (o que fiz neste exemplo). Criar relacionamentos
No exemplo acima, criei um relacionamento entre os
Albums e Artists mesas. Um relacionamento é um tipo de link entre tabelas com dados relacionados. Os relacionamentos ajudam a impor a integridade dos dados, pois permitem especificar que uma coluna só pode conter valores que correspondam aos valores de uma coluna específica em outra tabela.
Aqui está a seção específica do código do exemplo acima que cria o relacionamento:
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
);Criei o relacionamento ao mesmo tempo que criei os
Albums tabela. Consegui fazer isso porque já havia criado os Artists table (que é a outra tabela no relacionamento). Eu criei o relacionamento criando uma restrição de chave estrangeira (usando o
CONSTRAINT argumento) e especificando FOREIGN KEY juntamente com os detalhes do relacionamento. As REFERENCES palavra-chave especifica a qual tabela e coluna a chave estrangeira faz referência. Eu nomeei o relacionamento
FK_Albums_Artists . O
ON DELETE e ON UPDATE peças são opcionais. Eles especificam o que fazer no caso de alguém excluir ou atualizar uma linha da coluna pai/chave primária. O valor padrão é NO ACTION , o que significa que o Mecanismo de Banco de Dados gera um erro e a ação de atualização na linha da tabela pai é revertida. Meu artigo sobre Como criar um relacionamento no SQL lista as outras opções que você pode fornecer aqui, bem como o que cada opção faz.
Criar relacionamentos mais tarde
Você também pode criar um relacionamento em uma tabela existente.
Para fazer isso usando T-SQL, use o
ALTER TABLE demonstração. Então eu posso executar o seguinte código depois de executar o código anterior.
ALTER TABLE Albums
ADD CONSTRAINT FK_Albums_Genres FOREIGN KEY (GenreId)
REFERENCES dbo.Genres (GenreId)
ON DELETE NO ACTION
ON UPDATE NO ACTION
;Isso cria outro relacionamento, desta vez entre os
Albums e Genres mesas. Você pode ver que esse código faz praticamente a mesma coisa que o relacionamento anterior. A única diferença é que o relacionamento é entre
Artists e Genres em vez de Albums e Artists . Neste caso eu nomeei o relacionamento
FK_Albums_Genres . Inserir dados
O código acima criou um banco de dados adequado para dados. Agora podemos adicionar dados.
No SQL Server, você pode adicionar dados a um banco de dados usando o
INSERT demonstração. Ao usar essa instrução, você precisa fornecer o nome da tabela, bem como as colunas nas quais deseja inserir dados. Na verdade, fornecer as colunas é opcional se você estiver inserindo dados em todas as colunas, mas para maior clareza, aqui está um exemplo que inclui os nomes das colunas.
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);Como você pode ver, cada linha tem sua própria linha. Simplesmente adicionamos uma linha por linha com cada coluna separada por uma vírgula e entre parênteses. Uma vírgula também separa cada linha (após os parênteses).
A execução do código acima em nosso banco de dados recém-criado resulta na seguinte saída:
(16 rows affected) (8 rows affected) (20 rows affected)
Isso nos diz que os dados foram inseridos com sucesso.
Verifique o banco de dados
Podemos executar um teste rápido no banco de dados para verificar se ele foi criado e se nossos dados foram inseridos.
Por exemplo, podemos executar a seguinte consulta simples.
SELECT * FROM Artists;Resultado:
+------------+------------------------+--------------+ | 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 | +------------+------------------------+--------------+
E vamos executar outra consulta que usa dados de todas as três tabelas.
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';Resultado:
+----------------+-------------------------+---------------+ | 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 | +----------------+-------------------------+---------------+
Esta consulta demonstra a importância de criar relacionamentos entre tabelas com dados relacionados. Quando executamos consultas como essa, realmente precisamos que os dados sejam consistentes entre as tabelas.
O banco de dados está pronto para uso. Podemos executar consultas nele. Podemos inserir mais dados. Podemos adicionar mais tabelas, relacionamentos, visualizações, procedimentos armazenados, funções definidas pelo usuário e muito mais.
