Muchos desarrolladores y administradores de bases de datos crean bases de datos utilizando herramientas GUI como SQL Server Management Studio (SSMS), Azure Data Studio, etc.
Pero puede ser mucho más rápido crear bases de datos usando SQL. Esto es especialmente cierto si tiene varios entornos en los que necesita recrear la misma base de datos. Puede ejecutar el mismo script en cada entorno y la base de datos se creará en cuestión de segundos cada vez.
En SQL Server, hacemos esto con T-SQL. T-SQL significa Transact-SQL, y es la extensión de SQL Server para SQL.
A continuación se muestra un ejemplo del uso de T-SQL para crear una base de datos en SQL Server.
Código Básico
CREATE DATABASE Music;Este es todo el código que necesita para crear una base de datos. En este caso, crea una base de datos llamada Música .
Sin embargo, eso es todo lo que crea. La base de datos no contiene tablas u otros objetos. Para hacer eso, debe usar declaraciones adicionales para crear esos objetos según sea necesario.
Además, el anterior CREATE DATABASE declaración utiliza la sintaxis más básica que no incluye ningún argumento. Hay muchas opciones que se pueden incluir con esta declaración.
Por ejemplo, puede especificar su propio nombre para los archivos y sus grupos de archivos. También puede crear una instantánea de la base de datos o adjuntar archivos de base de datos para crear una base de datos a partir de los archivos separados de otra base de datos.
Consulte la documentación de Microsoft para conocer la sintaxis completa de esta instrucción.
Crear tablas
Este es un ejemplo de la creación de tres tablas para la base de datos anterior.
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
);
El primer paso es cambiar a la base de datos correcta (en este caso, la base de datos de Música). Para hacer esto, usamos USE MUSIC .
Una vez que esté utilizando la base de datos correcta, puede crear sus tablas y otros objetos. En este caso creé tres tablas. Cada vez que uso CREATE TABLE , seguido del nombre de la tabla que quiero crear. Esto es seguido por la definición de esa tabla.
La definición incluye las columnas de la tabla y sus definiciones. Por ejemplo, ArtistId es una columna, usa un int tipo de datos, y lo configuré como la clave principal para la tabla. Ser la clave principal significa que identifica de forma única cada fila en la base de datos.
También configuré esta columna para que sea una IDENTITY columna, lo que significa que cada fila utilizará un valor generado automáticamente que se incrementa con cada fila. En este caso, comenzará en 1 y se incrementará en 1 (eso se debe a que especifiqué IDENTITY(1,1) .
Finalmente, también configuré esta columna en NOT NULL . Esto significa que debe contener un valor. No puede ser nulo. En realidad, este es un requisito antes de establecer la columna como clave principal, pero también puede establecer otras columnas en NOT NULL según sea necesario (lo que he hecho en este ejemplo).
Crear relaciones
En el ejemplo anterior, creé una relación entre los Albums y Artists mesas.
Una relación es una especie de enlace entre tablas con datos relacionados. Las relaciones ayudan a reforzar la integridad de los datos porque le permiten especificar que una columna solo puede contener valores que coincidan con los valores de una columna específica en otra tabla.
Aquí está la sección específica del código del ejemplo anterior que crea la relación:
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
);
Creé la relación al mismo tiempo que creé los Albums mesa. Pude hacerlo porque ya había creado los Artists tabla (que es la otra tabla en la relación).
Creé la relación creando una restricción de clave externa (usando CONSTRAINT argumento) y especificando FOREIGN KEY junto con los detalles de la relación. Las REFERENCES La palabra clave especifica a qué tabla y columna hace referencia la clave externa.
Llamé a la relación FK_Albums_Artists .
El ON DELETE y ON UPDATE las piezas son opcionales. Especifican qué hacer en caso de que alguien elimine o actualice una fila de la columna de clave primaria/principal. El valor predeterminado es NO ACTION , lo que significa que Motor de base de datos genera un error y la acción de actualización en la fila de la tabla principal se revierte.
Mi artículo sobre Cómo crear una relación en SQL enumera las otras opciones que puede proporcionar aquí, así como lo que hace cada opción.
Crear relaciones más tarde
También puede crear una relación en una tabla existente.
Para hacer esto usando T-SQL, use ALTER TABLE declaración.
Entonces puedo ejecutar el siguiente código después de ejecutar el 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
;
Esto crea otra relación, esta vez entre los Albums y Genres mesas.
Puede ver que este código hace más o menos lo mismo que la relación anterior. La única diferencia es que la relación es entre Artists y Genres en lugar de Albums y Artists .
En este caso nombré a la relación FK_Albums_Genres .
Insertar datos
El código anterior ha creado una base de datos adecuada para los datos. Ahora podemos agregar datos.
En SQL Server, puede agregar datos a una base de datos usando INSERT declaración. Al usar esta declaración, debe proporcionar el nombre de la tabla, así como las columnas en las que desea insertar datos.
En realidad, proporcionar las columnas es opcional si está insertando datos en todas las columnas, pero en aras de la claridad, aquí hay un ejemplo que incluye los nombres de las columnas.
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 puede ver, cada fila tiene su propia línea. Simplemente agregamos una línea por fila con cada columna separada por una coma y rodeada por paréntesis. Una coma también separa cada fila (después de los paréntesis).
Ejecutar el código anterior en nuestra base de datos recién creada da como resultado el siguiente resultado:
(16 rows affected) (8 rows affected) (20 rows affected)
Esto nos dice que los datos se insertaron con éxito.
Comprobar la base de datos
Podemos ejecutar una prueba rápida contra la base de datos para verificar que se creó y se insertaron nuestros datos.
Por ejemplo, podemos ejecutar la siguiente consulta simple.
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 | +------------+------------------------+--------------+
Y ejecutemos otra consulta que use datos de las tres tablas.
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 demuestra la importancia de crear relaciones entre tablas con datos relacionados. Cuando ejecutamos consultas como esta, realmente necesitamos que los datos sean consistentes entre las tablas.
La base de datos ya está lista para su uso. Podemos ejecutar consultas en su contra. Podemos insertar más datos. Podemos agregar más tablas, relaciones, vistas, procedimientos almacenados, funciones definidas por el usuario y mucho más.
