Tutorial de SQL para principiantes

En este tutorial de SQL para principiantes, creará su propia base de datos, insertará datos en esa base de datos y luego ejecutará consultas en esa base de datos.

¡Este tutorial de SQL lo ayudará a ejecutar consultas SQL en muy poco tiempo!

Ejemplo SQL

Aquí hay una declaración SQL de ejemplo:

SELECT * 
FROM Pets;

Este es un ejemplo perfecto de lo fácil que puede ser escribir SQL. Esta simple instrucción SQL en realidad hace mucho. Devuelve toda la tabla. Devuelve todas las columnas y todas las filas de la tabla llamada Pets .

El asterisco (* ) es un carácter comodín, lo que significa "todas las columnas". Es una manera rápida y fácil de obtener todas las columnas sin tener que escribirlas todas.

Esa es una de las cosas hermosas de SQL. Las consultas SQL más simples suelen ser las más poderosas. Si quisiéramos devolver menos datos, en realidad necesitaríamos escribir más .

Por ejemplo, si solo quisiéramos mascotas llamadas Fetch , añadiríamos un WHERE cláusula que estipulaba ese requisito.

Así:

SELECT * 
FROM Pets
WHERE PetName = 'Fetch';

El WHERE La cláusula filtra nuestra consulta solo a las filas donde PetName la columna tiene un valor de Fetch .

Esta consulta asume que hay una columna llamada PetName y una tabla llamada Pets en la base de datos

En este tutorial de SQL, le mostraré cómo crear una base de datos de este tipo usando SQL.

También le mostraré cómo insertar datos en esa base de datos, actualizar datos, eliminar datos y ejecutar consultas en ella.

¿Qué es SQL?

SQL es un acrónimo de Structured Query Language.

SQL es el lenguaje de consulta estándar utilizado para trabajar con bases de datos relacionales.

Todos los principales sistemas de administración de bases de datos relacionales (RDBMS) utilizan SQL, incluidos:

• Acceso de Microsoft
• Servidor SQL
• Oráculo
• PostgreSQL
• MySQL
• SQLite

¿Qué puedo hacer con SQL?

Puede usar SQL para ejecutar consultas en una base de datos, insertar registros, actualizar registros y eliminar registros. También puede crear nuevos objetos de base de datos, como bases de datos y tablas. También puede realizar tareas de administración de bases de datos, como crear inicios de sesión, trabajos automatizados, copias de seguridad de bases de datos y mucho más.

Incluso cuando hace cosas usando una interfaz gráfica de usuario (GUI), su sistema de administración de base de datos (DBMS) seguramente usará SQL detrás de escena para llevar a cabo esa tarea.

Por ejemplo, cuando crea una base de datos haciendo clic en Crear base de datos e ingresando los detalles de la nueva base de datos en un cuadro de diálogo, una vez que haga clic en Aceptar o Crear o lo que sea que lea el botón, su sistema de base de datos usará el SQL CREATE DATABASE declaración para seguir adelante y crear la base de datos como se especifica.

Lo mismo ocurre con otras tareas, como ejecutar consultas, insertar datos, etc.

SQL también le permite realizar acciones más avanzadas, como crear procedimientos almacenados (scripts independientes), vistas (consultas prefabricadas) y establecer permisos en objetos de base de datos (como tablas, procedimientos almacenados y vistas).

Dicho esto, no necesita aprender todas las cosas avanzadas para comenzar con SQL. Lo bueno de SQL es que algunas de las tareas más comunes son las más fáciles de escribir.

Estándar SQL

SQL se estandarizó en ANSI X3.135 en 1986 y, en unos pocos meses, ISO lo adoptó como ISO 9075-1987. La norma internacional (ahora ISO/IEC 9075) ha sido revisada periódicamente desde entonces y actualmente existe en 9 partes.

La mayoría de los principales proveedores de bases de datos tienden a adherirse al estándar SQL. Lo bueno de eso es que no tiene que aprender un nuevo lenguaje de consulta cada vez que aprende un nuevo DBMS.

Sin embargo, en la práctica, existen variaciones entre cómo cada proveedor de bases de datos implementa el estándar SQL. Por lo tanto, es posible que el código que escribe en un DBMS no siempre funcione en otro sin necesidad de modificaciones.

La buena noticia es que todos los DBMS principales admiten las tareas más comunes generalmente de la misma manera.

Pronunciación SQL

SQL se suele pronunciar de una de estas dos formas:

• “ess-que-el ” (es decir, deletreando cada letra)
• “secuela ” (como en la ortografía/pronunciación original).

Consulte ¿Se pronuncia S-Q-L o Sequel si se pregunta por qué?

¿Qué necesito para este tutorial de SQL?

Para beneficiarse realmente de este tutorial de SQL, debe seguir los ejemplos. Eso significa que necesitará un lugar para ingresar las consultas SQL. Necesitarás tener algo como esto:

Si va a ejecutar consultas SQL, necesitará:

• Un RDBMS instalado (como SQL Server, MySQL, PostgreSQL, SQLite, etc.).
• Una herramienta de base de datos que le permite ejecutar consultas SQL en ese RDBMS (como MySQL WorkBench, Azure Data Studio (en la imagen), DBeaver y SSMS).

Si ya tienes uno de cada uno instalado, ¡genial! Puedes continuar con el tutorial.

Si no los tiene instalados, consulte ¿Qué necesito para ejecutar SQL? para obtener instrucciones sobre cómo instalar un RDBMS y su herramienta de administración de base de datos relevante, antes de regresar a este tutorial de SQL.

Crear una base de datos

Una vez que haya instalado su RDBMS y la herramienta de base de datos adecuada, estará listo para crear una base de datos:

CREATE DATABASE PetHotel;

¡Hecho!

Esa declaración en realidad creó una base de datos. Una base de datos vacía, pero una base de datos al fin y al cabo.

Esta base de datos contendrá las tablas y los datos utilizados en este tutorial de SQL. Cuando creamos una tabla o insertamos datos, lo haremos dentro de esta base de datos.

Debo mencionar que SQLite usa una sintaxis diferente para crear bases de datos. Si está utilizando SQLite, aquí le mostramos cómo crear una base de datos en SQLite.

Conectarse a la base de datos

Antes de comenzar a crear tablas, insertar datos, etc., debe asegurarse de estar en la base de datos correcta. Crear una base de datos (como acabamos de hacer) no necesariamente te conecta a esa base de datos.

En muchos DBMS (como SQL Server , MySQL y MariaDB ), podemos usar lo siguiente para cambiar a la base de datos especificada:

USE PetHotel;

Eso hace que PetHotel la base de datos actual.

En SQLite , probablemente ya esté en la base de datos después de crearla. De lo contrario, puede adjuntar la base de datos (que también la creará si aún no existe):

ATTACH DATABASE 'PetHotel.db' AS Pets;

En PostgreSQL , si está usando la herramienta psql, puede usar lo siguiente:

\connect PetHotel

O la versión abreviada:

\c PetHotel

Debo mencionar que el proceso de creación y conexión a bases de datos puede diferir ampliamente entre los DBMS.

Afortunadamente, la mayoría de las herramientas GUI le permiten conectarse a una base de datos haciendo doble clic en la base de datos o haciendo clic con el botón derecho en el nombre de la base de datos y seleccionando una nueva pestaña de consulta en el menú contextual. Si se encuentra atascado en este paso, simplemente use la GUI para crear y/o conectarse a su base de datos.

Crear una tabla

Ahora que se conectó a la base de datos correcta, puede continuar y crear algunas tablas.

Para crear una tabla en SQL, use CREATE TABLE declaración.

Cuando crea una tabla, debe especificar qué columnas estarán en la tabla, así como sus tipos de datos. También puedes especificar otros detalles, pero no nos adelantemos.

Vamos a crear una tabla:

CREATE TABLE PetTypes
(
    PetTypeId   int NOT NULL PRIMARY KEY,
    PetType     varchar(60) NOT NULL
);

En este caso creamos una tabla llamada PetTypes . Lo sabemos porque el nombre de la tabla viene inmediatamente después de CREATE TABLE poco.

Después de eso viene una lista de columnas, entre paréntesis.

La tabla anterior contiene las siguientes columnas:

• PetIdId
• PetType

Cada columna va seguida de su tipo de datos:

• int significa que esta columna acepta números enteros. Hasta donde yo sé, la mayoría de los principales DBMS admiten la declaración de columnas como int . Si tiene algún problema, intente usar integer .
• varchar(60) significa que esta columna acepta cadenas de hasta 60 caracteres. varchar las columnas son cadenas de longitud variable. Otro tipo de datos de cadena es char (que es una cadena de longitud fija). Si tiene problemas al intentar definir una columna como varchar(60) , intenta usar char(60) .

NOT NULL Restricciones

En este ejemplo, ambas columnas se definen con NOT NULL restricciones El NOT NULL restricción significa que esta columna no puede estar vacía. Cuando se inserta una nueva fila, cualquier NOT NULL columnas deben contener un valor. Otras columnas pueden permanecer vacías si no hay datos para esas columnas.

Si NULL se permiten valores en la columna, puede omitir NOT NULL parte, o declararlo como NULL (es decir, NULL se permiten valores en esta columna).

Algunos DBMS (como DB2) no admiten NULL palabra clave de todos modos, por lo que deberá omitirla cuando trabaje con tales DBMS.

Claves primarias

También creamos el PetTypeId columna la clave principal. La clave principal es una o más columnas que identifican de forma única cada fila de la tabla. Usted especifica su(s) columna(s) seleccionada(s) como la clave principal mediante el uso de una restricción de clave principal. Puedes hacer esto en CREATE TABLE declaración (como hicimos aquí), o puede agregar una más tarde con un ALTER TABLE declaración.

Las claves primarias deben contener valores únicos. Es decir, para cada fila de esa tabla, el valor de la columna o columnas de la clave principal debe ser diferente en cada fila. Esto podría ser tan simple como tener números incrementales (como 1, 2, 3... etc.) o podría ser un código de producto (como pr4650, pr2784, pr5981... etc.).

Además, las claves primarias deben contener un valor. No puede ser NULL .

Aunque no se requieren claves principales, generalmente se considera una buena práctica definir una clave principal en cada tabla.

Crear más tablas

Vamos a crear dos tablas más:

CREATE TABLE Owners
(
    OwnerId     int NOT NULL PRIMARY KEY,
    FirstName   varchar(60) NOT NULL,
    LastName    varchar(60) NOT NULL,
    Phone       varchar(20) NOT NULL,
    Email       varchar(254)
);

CREATE TABLE Pets
(
    PetId       int NOT NULL PRIMARY KEY,
    PetTypeId   int NOT NULL REFERENCES PetTypes (PetTypeId),
    OwnerId     int NOT NULL REFERENCES Owners (OwnerId),
    PetName     varchar(60) NOT NULL,
    DOB         date NULL
);

Ambas tablas son similares a la primera, excepto que tienen más filas y un par de piezas adicionales, que explicaré a continuación.

Si está interesado, consulte SQL CREATE TABLE for Beginners para ver algunos ejemplos más simples de creación de tablas en SQL.

Relaciones

Cuando creamos nuestras Pets tabla, en realidad creamos una relación entre las tres tablas.

Esa relación se representa en el siguiente diagrama.

Las relaciones de la base de datos son una parte crucial de SQL. Las relaciones nos permiten consultar varias tablas en busca de datos relacionados y obtener resultados precisos y coherentes.

En nuestro caso, queremos poder buscar mascotas por dueño, o mascotas por tipo de mascota, etc. Y queremos que nuestros resultados sean precisos y consistentes.

Para lograr esto, debemos insistir en que todas las mascotas se ingresen junto con su dueño y tipo de mascota. Por lo tanto, debemos asegurarnos de que, cada vez que se agregue una nueva mascota a las Pets tabla, ya hay un propietario correspondiente en Owners y un tipo de mascota correspondiente en PetTypes mesa.

Básicamente, nuestros requisitos son los siguientes:

• Cualquier valor en Pets.PetTypeId la columna debe coincidir con un valor en PetTypes.PetTypeId columna.
• Cualquier valor en Pets.OwnerId la columna debe coincidir con un valor en Owners.OwnerId columna.

Podemos garantizar los requisitos anteriores creando una restricción de clave externa en las columnas correspondientes. Una clave externa La restricción se usa para especificar que una determinada columna hace referencia a la clave principal de otra tabla.

De hecho, el código anterior creó dos restricciones de clave externa en Pets mesa.

Observe que el PetTypeId y OwnerId las columnas tienen un código adicional que comienza con REFERENCES... . Esas son las partes que crearon las dos claves foráneas.

Cuando creamos las Pets tabla, su PetTypeId la columna tiene un bit que dice REFERENCES PetTypes (PetTypeId) . Esto significa que Pets.PetTypeId la columna hace referencia al PetTypeId columna en PetTypes mesa.

Es el mismo trato para el OwnerId columna. Hace referencia al OwnerId columna de los Owners mesa.

En la mayoría de los DBMS, las claves foráneas también se pueden crear en una tabla existente, utilizando ALTER TABLE declaración, pero no vamos a repasar eso aquí. Consulte Cómo crear una relación en SQL para obtener más información al respecto.

De todos modos, nuestras claves foráneas han sido creadas. Ahora, cada vez que alguien inserte una nueva mascota en Pets tabla, el PetTypeId y OwnerId los valores deberán tener un valor correspondiente en PetTypes y Owners tablas respectivamente. Si alguno de ellos no lo hace, la base de datos devolverá un error.

Este es el beneficio de las claves foráneas. Ayuda a evitar que se introduzcan datos incorrectos. Ayuda a mantener la integridad de los datos y, más específicamente, la integridad referencial.

Comprobar restricciones

Una restricción de verificación es otro tipo de restricción que debe tener en cuenta. Una restricción de verificación verifica los datos antes de ingresar a la base de datos. Cuando una tabla tiene habilitada una restricción de verificación, los datos solo pueden ingresar a la tabla si no viola esa restricción. Los datos que violan la restricción no pueden ingresar a la tabla.

Por ejemplo, puede crear una restricción de verificación en un Price columna para asegurarse de que solo acepta valores que son mayores que cero. O podríamos aplicar una restricción de verificación a nuestras Pets para asegurarse de que DOB la columna no está en el futuro.

Para ver un ejemplo, consulte ¿Qué es una restricción CHECK?

Espacio en blanco

Es posible que haya notado que mis ejemplos incluyen espacios en blanco. Por ejemplo, espacié el código en varias líneas y usé tabulaciones para sangrar los tipos de datos, etc.

Esto es perfectamente válido en SQL. Puede hacer esto de manera segura y no afectará el resultado. SQL le permite distribuir su código en varias líneas si lo desea, y le permite usar múltiples espacios o tabulaciones para mejorar la legibilidad.

Comentarios

También puede incluir comentarios dentro de su código. Los comentarios pueden ser útiles una vez que comience a escribir secuencias de comandos SQL más largas. Una vez que una secuencia de comandos se vuelve bastante larga, los comentarios pueden facilitar la identificación rápida de lo que hace cada parte.

Comentarios en línea

Puede crear comentarios en línea prefijando su comentario con dos guiones (-- ):

SELECT * FROM Pets; --This is a comment

-- This is a comment
SELECT * FROM Owners;

En este ejemplo, ambas consultas se ejecutarán sin problemas. El DBMS ignorará los comentarios.

Comentarios de varias líneas

Puede distribuir comentarios en varias líneas rodeando el comentario con /* y */ :

/*
This is a longer comment so
it's spread across multiple lines
*/
SELECT * FROM Pets;

En este ejemplo, ambas consultas se ejecutarán sin problemas. El DBMS ignorará los comentarios.

MySQL

Si usa MySQL, también puede usar el signo de número/almohadilla (# ) para comentarios de una sola línea.

# This is a comment
SELECT * FROM Pets;

Comentar código

Otro beneficio interesante de los comentarios es que puedes comentar código. Por ejemplo, si tiene un script SQL largo que hace muchas cosas, pero solo desea ejecutar una o dos partes, puede comentar el resto del guión.

He aquí un ejemplo:

-- SELECT * FROM Pets;

SELECT * FROM Owners;

En este caso, el primer SELECT declaración ha sido comentada, por lo que sólo el segundo SELECT se ejecutará la declaración.

También puede usar comentarios de varias líneas para esta técnica.

Insertar datos

Ahora que hemos creado tres tablas y creado las claves foráneas apropiadas, podemos continuar y agregar datos.

La forma más común de insertar datos en SQL es con INSERT declaración. Es algo como esto:

INSERT INTO MyTable( Column1, Column2, Column3, ... )
VALUES( Value1, Value2, Value3, ... );

Simplemente reemplaza MyTable con el nombre de la tabla en la que está insertando datos. Del mismo modo, reemplaza Column1 , etc. con los nombres de las columnas y Value1 , etc. con los valores que van en esas columnas.

Por ejemplo, podríamos hacer esto:

INSERT INTO Pets( PetId, PetTypeId, OwnerId, PetName, DOB )
VALUES( 1, 2, 3, 'Fluffy', '2020-12-20' );

Cada valor está en el mismo orden en que se especifica la columna.

Tenga en cuenta que los nombres de las columnas coinciden con los nombres que usamos cuando creamos la tabla.

Puede omitir los nombres de las columnas si está insertando datos en todas las columnas. Así que podríamos cambiar el ejemplo anterior para que se vea así:

INSERT INTO Pets
VALUES( 1, 2, 3, 'Fluffy', '2020-12-20' );

Para este tutorial, agregaremos bastantes filas más, por lo que agregaremos más INSERT INTO declaraciones:una para cada fila que queremos insertar.

Así que sigamos adelante y llenemos nuestras tablas.

INSERT INTO Owners( OwnerId, FirstName, LastName, Phone, Email )
VALUES( 1, 'Homer', 'Connery', '(308) 555-0100', '[email protected]' );
INSERT INTO Owners(OwnerId, FirstName, LastName, Phone, Email)
VALUES( 2, 'Bart', 'Pitt', '(231) 465-3497', '[email protected]' );
INSERT INTO Owners(OwnerId, FirstName, LastName, Phone)
VALUES( 3, 'Nancy', 'Simpson', '(489) 591-0408' );
INSERT INTO Owners(OwnerId, FirstName, LastName, Phone)
VALUES( 4, 'Boris', 'Trump', '(349) 611-8908' ); 

INSERT INTO PetTypes( PetTypeId, PetType )
VALUES( 1, 'Bird' );
INSERT INTO PetTypes( PetTypeId, PetType )
VALUES( 2, 'Cat' );
INSERT INTO PetTypes( PetTypeId, PetType )
VALUES( 3, 'Dog' );
INSERT INTO PetTypes( PetTypeId, PetType )
VALUES( 4, 'Rabbit' );

INSERT INTO Pets( PetId, PetTypeId, OwnerId, PetName, DOB )
VALUES( 1, 2, 3, 'Fluffy', '2020-11-20' );
INSERT INTO Pets( PetId, PetTypeId, OwnerId, PetName, DOB )
VALUES( 2, 3, 3, 'Fetch', '2019-08-16' );
INSERT INTO Pets( PetId, PetTypeId, OwnerId, PetName, DOB )
VALUES( 3, 2, 2, 'Scratch', '2018-10-01' );
INSERT INTO Pets( PetId, PetTypeId, OwnerId, PetName, DOB )
VALUES( 4, 3, 3, 'Wag', '2020-03-15' );
INSERT INTO Pets( PetId, PetTypeId, OwnerId, PetName, DOB )
VALUES( 5, 1, 1, 'Tweet', '2020-11-28' );
INSERT INTO Pets( PetId, PetTypeId, OwnerId, PetName, DOB )
VALUES( 6, 3, 4, 'Fluffy', '2020-09-17' );
INSERT INTO Pets( PetId, PetTypeId, OwnerId, PetName )
VALUES( 7, 3, 2, 'Bark' );
INSERT INTO Pets( PetId, PetTypeId, OwnerId, PetName )
VALUES( 8, 2, 4, 'Meow' );

Tenga en cuenta que rellenamos las Pets última mesa. Hay una razón para esto.

Si hubiéramos intentado insertar datos en las Pets table antes de llenar los otros dos, habríamos recibido un error, debido a nuestra restricción de clave externa. Y por una buena razón. Después de todo, habríamos intentado insertar valores en las columnas de clave externa que aún no existían en las columnas de clave principal de las otras tablas. Ese es un gran "no no" cuando se trata de claves externas.

Entonces, al completar los Owners y PetTypes tablas primero, nos aseguramos de que los valores apropiados ya estuvieran en las columnas de clave principal antes de completar las columnas de clave externa en Pets mesa.

Consulte SQL INSERT para principiantes para obtener más ejemplos de cómo insertar datos en tablas.

Consulta nuestros datos

¡Uf! Finalmente podemos comenzar a ejecutar consultas en nuestra base de datos.

Revisemos los datos en todas nuestras tablas.

SELECT * FROM Pets;
SELECT * FROM PetTypes;
SELECT * FROM Owners;

Resultado:

+---------+-------------+-----------+-----------+------------+
| PetId   | PetTypeId   | OwnerId   | PetName   | DOB        |
|---------+-------------+-----------+-----------+------------|
| 1       | 2           | 3         | Fluffy    | 2020-11-20 |
| 2       | 3           | 3         | Fetch     | 2019-08-16 |
| 3       | 2           | 2         | Scratch   | 2018-10-01 |
| 4       | 3           | 3         | Wag       | 2020-03-15 |
| 5       | 1           | 1         | Tweet     | 2020-11-28 |
| 6       | 3           | 4         | Fluffy    | 2020-09-17 |
| 7       | 3           | 2         | Bark      | NULL       |
| 8       | 2           | 4         | Meow      | NULL       |
+---------+-------------+-----------+-----------+------------+
(8 rows affected)
+-------------+-----------+
| PetTypeId   | PetType   |
|-------------+-----------|
| 1           | Bird      |
| 2           | Cat       |
| 3           | Dog       |
| 4           | Rabbit    |
+-------------+-----------+
(4 rows affected)
+-----------+-------------+------------+----------------+-------------------+
| OwnerId   | FirstName   | LastName   | Phone          | Email             |
|-----------+-------------+------------+----------------+-------------------|
| 1         | Homer       | Connery    | (308) 555-0100 | [email protected] |
| 2         | Bart        | Pitt       | (231) 465-3497 | [email protected]  |
| 3         | Nancy       | Simpson    | (489) 591-0408 | NULL              |
| 4         | Boris       | Trump      | (349) 611-8908 | NULL              |
+-----------+-------------+------------+----------------+-------------------+
(4 rows affected)

Genial, parece que los datos se insertaron correctamente.

Seleccionar columnas específicas

Por lo general, se considera una mala práctica seleccionar todas las filas y todas las columnas de una tabla (como hicimos en el ejemplo anterior), a menos que realmente lo necesites. Hacer esto puede afectar el rendimiento de su servidor de base de datos, especialmente si hay muchas filas en la tabla.

No es un problema cuando usa conjuntos de datos pequeños como los que estamos aquí, o si está en un entorno de desarrollo o similar. De lo contrario, normalmente es mejor seleccionar solo las columnas que necesita.

Por lo tanto, si quisiéramos los ID, nombres y fechas de nacimiento de todas las mascotas, podríamos hacer esto:

SELECT PetId, PetName, DOB 
FROM Pets; 

Resultado:

+---------+-----------+------------+
| PetId   | PetName   | DOB        |
|---------+-----------+------------|
| 1       | Fluffy    | 2020-11-20 |
| 2       | Fetch     | 2019-08-16 |
| 3       | Scratch   | 2018-10-01 |
| 4       | Wag       | 2020-03-15 |
| 5       | Tweet     | 2020-11-28 |
| 6       | Fluffy    | 2020-09-17 |
| 7       | Bark      | NULL       |
| 8       | Meow      | NULL       |
+---------+-----------+------------+

Si quisiéramos las identificaciones y la fecha de nacimiento de todas las mascotas llamadas Fluffy, podríamos usar esto:

SELECT PetId, DOB
FROM Pets
WHERE PetName = 'Fluffy';

Resultado:

+---------+------------+
| PetId   | DOB        |
|---------+------------|
| 1       | 2020-11-20 |
| 6       | 2020-09-17 |
+---------+------------+

También puede usar el SELECT instrucción para devolver datos sin tabla. Es decir, puede devolver datos que no están almacenados en una tabla. Ver SQL SELECT Declaración para principiantes para ver un ejemplo.

Clasificación

SQL proporciona el ORDER BY cláusula que nos permite ordenar los datos.

Podemos agregar un ORDER BY cláusula a nuestro ejemplo anterior para que las mascotas se ordenen por sus nombres:

SELECT PetId, PetName, DOB 
FROM Pets
ORDER BY PetName ASC;

Resultado:

+---------+-----------+------------+
| PetId   | PetName   | DOB        |
|---------+-----------+------------|
| 7       | Bark      | NULL       |
| 2       | Fetch     | 2019-08-16 |
| 1       | Fluffy    | 2020-11-20 |
| 6       | Fluffy    | 2020-09-17 |
| 8       | Meow      | NULL       |
| 3       | Scratch   | 2018-10-01 |
| 5       | Tweet     | 2020-11-28 |
| 4       | Wag       | 2020-03-15 |
+---------+-----------+------------+

El ASC parte significa ascendente . Cuando usas el ORDER BY cláusula, por defecto es ascendente, por lo que puede omitir el ASC parte si lo desea.

Para ordenarlo en descendente orden, use DESC .

SELECT PetId, PetName, DOB 
FROM Pets
ORDER BY PetName DESC;

Resultado:

+---------+-----------+------------+
| PetId   | PetName   | DOB        |
|---------+-----------+------------|
| 4       | Wag       | 2020-03-15 |
| 5       | Tweet     | 2020-11-28 |
| 3       | Scratch   | 2018-10-01 |
| 8       | Meow      | NULL       |
| 1       | Fluffy    | 2020-11-20 |
| 6       | Fluffy    | 2020-09-17 |
| 2       | Fetch     | 2019-08-16 |
| 7       | Bark      | NULL       |
+---------+-----------+------------+

También puede ordenar los resultados utilizando varias columnas. Ordenará por la primera columna especificada, luego, si hay duplicados en esa columna, ordenará esos duplicados por la segunda columna especificada, y así sucesivamente.

SELECT PetId, PetName, DOB 
FROM Pets
ORDER BY PetName DESC, DOB ASC;

Resultado:

+---------+-----------+------------+
| PetId   | PetName   | DOB        |
|---------+-----------+------------|
| 4       | Wag       | 2020-03-15 |
| 5       | Tweet     | 2020-11-28 |
| 3       | Scratch   | 2018-10-01 |
| 8       | Meow      | NULL       |
| 6       | Fluffy    | 2020-09-17 |
| 1       | Fluffy    | 2020-11-20 |
| 2       | Fetch     | 2019-08-16 |
| 7       | Bark      | NULL       |
+---------+-----------+------------+

Mira cómo los dos Fluffys han intercambiado su posición.

Si no usa el ORDER BY cláusula, no hay garantía en qué orden estarán sus resultados. Aunque puede parecer como su base de datos está ordenando los resultados por una columna en particular, este puede no ser el caso. En general, sin un ORDER BY cláusula, los datos se ordenarán en el orden en que se cargaron en la tabla. Sin embargo, si las filas se eliminaron o actualizaron, el orden se verá afectado por la forma en que el DBMS reutiliza el espacio de almacenamiento reclamado.

Por lo tanto, no confíe en el DBMS para clasificar los resultados en un orden significativo.

En pocas palabras:si desea ordenar los resultados, use ORDER BY .

Ver SQL ORDER BY Cláusula para principiantes para ver más ejemplos.

Contar las filas en un conjunto de resultados

Puedes usar el COUNT() función agregada para contar las filas que se devolverán en una consulta.

SELECT COUNT(*) AS Count
FROM Pets;

Resultado:

+---------+
| Count   |
|---------|
| 8       |
+---------+

Esto nos dice que hay 8 filas en la tabla. Lo sabemos porque seleccionamos todas las filas y todas las columnas.

Puedes usar COUNT() en cualquier consulta, por ejemplo consultas que usan un WHERE cláusula para filtrar los resultados.

También puede especificar una columna en particular para contar. El COUNT() la función solo cuenta no NULL resultados, por lo que si especifica una columna que contiene NULL valores, esos valores no se contarán.

Aquí hay un ejemplo para demostrar lo que quiero decir.

SELECT COUNT(DOB) AS Count
FROM Pets;

Resultado:

+---------+
| Count   |
|---------|
| 6       |
+---------+
Warning: Null value is eliminated by an aggregate or other SET operation.

Tal vez recuerdes que las Pets la tabla contiene dos NULL valores en el DOB columna (dos mascotas no han proporcionado su fecha de nacimiento), por lo que COUNT(DOB) devuelve 6, en lugar de 8 cuando usamos COUNT(*) . El motivo COUNT(*) devolvió todas las filas, es porque esas dos filas lo hicieron tener datos en las otras columnas.

En mi ejemplo, mi DBMS también devolvió una advertencia sobre esto. Es posible que reciba o no una advertencia, según su DBMS y su configuración específica.

Ver SQL COUNT para principiantes para ver más ejemplos.

Otras funciones agregadas incluyen:AVG() , SUM() , MIN() y MAX() .

Agrupar por

Otra cláusula útil es GROUP BY cláusula. Esto hace más o menos lo que promete su nombre. Te permite agrupar los resultados por una columna dada.

SELECT 
    PetTypeId, 
    COUNT(PetTypeId) AS Count
FROM Pets
GROUP BY PetTypeId
ORDER BY Count DESC;

Resultado:

+-------------+---------+
| PetTypeId   | Count   |
|-------------+---------|
| 3           | 4       |
| 2           | 3       |
| 1           | 1       |
+-------------+---------+

En este ejemplo, estamos contando cuántas mascotas tenemos para cada tipo de mascota, luego las clasificamos en orden descendente (con el conteo más alto en la parte superior).

Ver SQL GROUP BY Cláusula para principiantes para ver más ejemplos.

El HAVING Cláusula

Podemos usar el HAVING cláusula para filtrar los resultados en el GROUP BY cláusula. El HAVING cláusula devuelve filas donde los valores agregados cumplen condiciones específicas.

He aquí un ejemplo.

SELECT 
    PetTypeId, 
    COUNT(PetTypeId) AS Count
FROM Pets
GROUP BY PetTypeId
HAVING COUNT(PetTypeId) > 2
ORDER BY Count DESC;

Resultado:

+-------------+---------+
| PetTypeId   | Count   |
|-------------+---------|
| 3           | 4       |
| 2           | 3       |
+-------------+---------+

En este caso, devolvimos datos solo para los tipos de mascotas que tienen más de 2 mascotas asignadas a ese tipo.

Ver SQL HAVING Cláusula para principiantes para ver más ejemplos.

Únete

En SQL, una unión es donde ejecuta una consulta que combina datos de varias tablas.

Los dos ejemplos anteriores están bien, pero serían mejores si mostraran los tipos de mascotas reales (p. ej., gato, perro, pájaro, etc.) en lugar de la ID (p. ej., 1, 2, 3, etc.).

El único problema es que las Pets la tabla no contiene esos datos. Esos datos están en PetTypes mesa.

Afortunadamente para nosotros, podemos unir estas dos tablas. Aquí hay un ejemplo que usa un LEFT JOIN :

SELECT 
    PetTypes.PetType,
    COUNT(Pets.PetTypeId) AS Count
FROM Pets 
LEFT JOIN PetTypes 
ON Pets.PetTypeId = PetTypes.PetTypeId
GROUP BY PetTypes.PetType
ORDER BY Count DESC;

Resultado:

+-----------+---------+
| PetType   | Count   |
|-----------+---------|
| Dog       | 4       |
| Cat       | 3       |
| Bird      | 1       |
+-----------+---------+

Este conjunto de resultados es mucho más fácil de leer que los anteriores. Es más fácil entender cuántos de cada tipo de mascota hay en la tabla.

La sintaxis usa el tipo de unión (en este caso LEFT JOIN ), seguida de la primera tabla (izquierda), seguida de ON , seguido de la condición de unión.

Usemos un INNER JOIN para devolver todos los nombres de mascotas con sus respectivos tipos de mascotas.

SELECT 
    Pets.PetName,
    PetTypes.PetType
FROM Pets 
INNER JOIN PetTypes 
ON Pets.PetTypeId = PetTypes.PetTypeId;

Resultado:

+-----------+-----------+
| PetName   | PetType   |
|-----------+-----------|
| Fluffy    | Cat       |
| Fetch     | Dog       |
| Scratch   | Cat       |
| Wag       | Dog       |
| Tweet     | Bird      |
| Fluffy    | Dog       |
| Bark      | Dog       |
| Meow      | Cat       |
+-----------+-----------+

Las uniones realmente abren nuestras opciones, porque ahora podemos obtener datos de varias tablas y presentarlos como si fueran una sola tabla.

Notará que en los ejemplos de combinación, calificamos nuestros nombres de columna con los nombres de tabla. La razón por la que hacemos esto es para evitar cualquier ambigüedad con respecto a los nombres de las columnas entre las tablas. Ambas tablas pueden tener columnas con el mismo nombre (como en nuestro ejemplo) y, en tales casos, el DBMS no sabrá a qué columna se refiere. Prefijar los nombres de las columnas con sus nombres de tabla asegura que está haciendo referencia a la columna correcta y evita cualquier error que pueda resultar de cualquier ambigüedad sobre a qué columna se está refiriendo.

Consulte mi Tutorial de uniones SQL para obtener más ejemplos y una explicación de los distintos tipos de uniones.

Alias

Podemos ir un paso más allá y asignar un alias a cada nombre de tabla y nombre de columna.

SELECT 
    p.PetName AS Pet,
    pt.PetType AS "Pet Type"
FROM PetTypes pt
LEFT JOIN Pets p
ON p.PetTypeId = pt.PetTypeId;

Resultado:

+---------+------------+
| Pet     | Pet Type   |
|---------+------------|
| Tweet   | Bird       |
| Fluffy  | Cat        |
| Scratch | Cat        |
| Meow    | Cat        |
| Fetch   | Dog        |
| Wag     | Dog        |
| Fluffy  | Dog        |
| Bark    | Dog        |
| NULL    | Rabbit     |
+---------+------------+

Esto ha resultado en nuevos encabezados de columna, además el código es más conciso.

Un alias le permite asignar temporalmente otro nombre a una tabla o columna durante la duración de un SELECT consulta. Esto puede ser particularmente útil cuando las tablas y/o columnas tienen nombres muy largos o complejos.

Se asigna un alias mediante el uso de AS palabra clave, aunque esta palabra clave es opcional, por lo que puede omitirla con seguridad. Tenga en cuenta que Oracle no es compatible con AS palabra clave en alias de tabla (pero lo hace en alias de columna).

En el ejemplo anterior, he incluido el AS palabra clave al asignar los alias de columna, pero la omitió al asignar los alias de tabla.

Un nombre de alias puede ser cualquier cosa, pero generalmente se mantiene corto para facilitar la lectura.

En nuestro caso, cambiamos las dos tablas a p y pt , y los nombres de las columnas a Pet y PetType . Tenga en cuenta que rodeé PetType entre comillas dobles. Hice esto, porque hay un espacio en el nombre. Para alias sin espacios, no necesita hacer esto. En SQL Server, también puede usar corchetes ([] ) en lugar de comillas dobles (aunque también admite comillas dobles).

La práctica de usar espacios en columnas y alias generalmente se desaconseja, ya que puede causar todo tipo de problemas con algunas aplicaciones cliente.

Tenga en cuenta que aún necesitábamos usar los nombres completos de las columnas al hacer referencia a ellos en la unión (después de ON palabra clave).

Debo señalar que asignar un alias en realidad no cambia el nombre de la columna o tabla.

Consulte Explicación de alias de SQL para obtener más ejemplos.

Actualización de datos

Puedes usar el UPDATE declaración para actualizar los datos en sus tablas.

La sintaxis básica es bastante simple:

UPDATE Owners
SET LastName = 'Stallone'
WHERE OwnerId = 3;

En ese ejemplo, actualizamos el LastName columna para tener un nuevo valor de Stallone donde el OwnerId es 3 .

Para actualizar varias columnas, use una coma para separar cada par de columna/valor.

Pero hagas lo que hagas, no olvides el WHERE cláusula (a menos que tenga la intención de actualizar cada fila de la tabla con el mismo valor).

Ver SQL UPDATE para principiantes para obtener más ejemplos y una explicación más detallada.

Eliminación de datos

Puedes usar el DELETE instrucción para eliminar datos de sus tablas.

La sintaxis básica es aún más simple que UPDATE declaración:

DELETE FROM Owners
WHERE OwnerId = 5;

Here, we’re deleting owner number 5 from the Owners mesa.

As with the UPDATE statement, don’t forget the WHERE clause (unless you intend to delete every row in the table ).

See SQL DELETE for Beginners for more examples and a detailed explanation.

Dropping Objects

While we’re on the subject of deleting things, when you delete a database object (such as a table, view, stored procedure, etc), it’s said that you “drop” that object. For example, if you no longer need a table, you “drop it”.

The syntax is extremely simple, and it goes like this:

DROP TABLE Customers;

Those three words completely obliterated a table called Customers . The table and all its data is now gone.

As you can imagine, this can be a very dangerous statement, and should be used with extreme caution.

The same syntax can be used for other object types, except you would replace table with the object type (for example DROP VIEW vPets drops a view called vPets ).

If you try to drop a table that is referenced by a foreign key, you’ll probably get an error. In this case, you’ll need to either drop the foreign key (using the ALTER TABLE statement) or the child table itself.

SQL Operators

In SQL, an operator is a symbol specifying an action that is performed on one or more expressions.

Operators manipulate individual data items and return a result. The data items are called operands or arguments . In SQL, operators are represented by special characters or by keywords.

We’ve already seen some operators in action. Some of our previous example queries had a WHERE clause that included the Equals operator (= ). We also ran a query that used the Greater Than operator (> ). These are both comparison operators – they compare two expressions.

See 12 Commonly Used Operators in SQL for examples of operators that you’re likely to need when working with SQL.

You can also use this list of SQL Operators as a reference for the operators available in SQL.

SQL Views

In SQL, a view is a query that’s saved to the database as a database object (just like a table). The term can also be used to refer to the result set of a stored query. Views are often referred to as virtual tables .

To create a view, you write a query, then save it as a view. You do this using the CREATE VIEW sintaxis.

Here’s an example of creating a view:

CREATE VIEW vPetTypeCount AS
SELECT 
    PetTypes.PetType,
    COUNT(Pets.PetTypeId) AS Count
FROM Pets 
LEFT JOIN PetTypes 
ON Pets.PetTypeId = PetTypes.PetTypeId
GROUP BY PetTypes.PetType;

Running that code creates the view and stores it as an object in the database.

We can now query the view, just like we’d query a table.

Resultado:

SELECT * FROM vPetTypeCount;

+-----------+---------+
| PetType   | Count   |
|-----------+---------|
| Bird      | 1       |
| Cat       | 3       |
| Dog       | 4       |
+-----------+---------+

So we get the same result as we would have got if we’d run the original query, but saving it in a view made it a lot easier to query.

This benefit would become greater, the more complex the query is.

Views and the ORDER BY Clause

One thing I should point out is that the original query had an ORDER BY clause, but I didn’t include that in the view. The SQL standard does not allow the ORDER BY clause in any view definition. Also, most RDBMSs will raise an error if you try to include an ORDER BY cláusula.

This isn’t a problem though, because you can sort the results when you query the view. Therefore, we can do something like this:

SELECT * FROM vPetTypeCount
ORDER BY Count DESC;

Resultado:

+-----------+---------+
| PetType   | Count   |
|-----------+---------|
| Dog       | 4       |
| Cat       | 3       |
| Bird      | 1       |
+-----------+---------+

Most RDBMSs also include a large set of system views that you can use to retrieve information about the system.

For more about views, see What is a View?

Stored Procedures

A stored procedure is a series of SQL statements compiled and saved to the database. Stored procedures are similar to views in some respects, but very different in other respects.

One of the benefits of stored procedures is that they allow you to store complex scripts on the server. Stored procedures often contain conditional programming such as IF... ELSE statements, for example. Stored procedures can also accept parameters.

Here’s an example of creating a simple stored procedure in SQL Server to get pet information from our database:

CREATE PROCEDURE uspGetPetById
    @PetId int
AS
    SET NOCOUNT ON;
    SELECT 
        p.PetName, 
        p.DOB, 
        pt.PetType,
        CONCAT(o.FirstName, ' ', o.LastName) AS OwnerName
    FROM Pets p 
    INNER JOIN PetTypes pt 
    ON p.PetTypeId = pt.PetTypeId
    INNER JOIN Owners o 
    ON o.OwnerId = p.OwnerId
    WHERE p.PetId = @PetId;

This stored procedure accepts a parameter called @PetId . This means that when you call the procedure, you need to pass the ID of the pet that you’d like information about. The procedure then selects data from various tables and returns it.

To call the stored procedure, use the EXECUTE declaración. You can alternatively shorten it to EXEC . In PostgreSQL, use the CALL declaración.

EXEC uspGetPetById @PetId = 3;

Resultado:

+-----------+------------+-----------+-------------+
| PetName   | DOB        | PetType   | OwnerName   |
|-----------+------------+-----------+-------------|
| Scratch   | 2018-10-01 | Cat       | Bart Pitt   |
+-----------+------------+-----------+-------------+

In this case I was interested in pet number 3, and so that’s the info that I got.

I should mention that the syntax for creating stored procedures can differ quite significantly between DBMSs (as well as their implementations of various SQL statements and commands that you’d use inside a procedure), so I would suggest that you look at the documentation for your particular DBMS if you want to create a stored procedure.

Most RDBMSs also include a large set of system stored procedures that you can use to perform various administration tasks, and to retrieve information about the system.

For a basic overview of stored procedures, including their benefits, see What is a Stored Procedure?

Also, if you’re interested, see How to Create a Stored Procedure in SQL Server to see another example of creating a stored procedure in SQL Server. That example includes some screenshots.

SQL Triggers

A trigger is a special type of stored procedure that automatically executes when an event occurs in the database server.

Most major RDBMSs support DML triggers, which execute when a user tries to modify data through a data manipulation language (DML) event. DML events are INSERT , UPDATE o DELETE declaraciones.

Some DBMSs (such as SQL Server and PostgreSQL) allow triggers to be associated with both tables and views. Others only allow triggers to be associated with tables.

SQL Server also supports DDL triggers and logon triggers.

DDL triggers execute in response to DDL events, such as CREATE , ALTER , and DROP statements, and certain system stored procedures that perform DDL-like operations.

Logon triggers are fired in response to the LOGON event that’s raised when a user’s session is being established.

Here are some articles explaining how to do various things with triggers in SQL Server:

• Create a DML Trigger in SQL Server
• Create a “last modified” column
• Automatically send an email when someone tries to delete a record
• Update a column’s value whenever another column is updated
• Update a column’s value whenever certain other columns are updated

SQL Transactions

SQL transactions are an important part of transactional databases, where data consistency is paramount.

A transaction manages a sequence of SQL statements that must be executed as a single unit of work. This is to ensure that the database never contains the results of partial operations.

When a transaction makes multiple changes to the database, either all the changes succeed when the transaction is committed, or all the changes are undone when the transaction is rolled back.

Transactions help maintain data integrity by ensuring that a sequence of SQL statements execute completely or not at all.

A classic example of a transaction is to move money from one bank account to another. You wouldn’t want money to be deducted from the first bank account, but not appear in the second bank account.

Therefore, you could use a transaction which goes along the lines of this:

START TRANSACTION
Debit account 1
Credit account 2
Record transaction in transaction journal
END TRANSACTION 

You could write conditional logic inside that transaction that rolls back the transaction if anything goes wrong.

The end result is that, either the transaction is completed in its entirety, or it’s not completed at all. It’s never half-done.

See my SQL Transactions Tutorial for examples of SQL transactions.

SQL Functions

A function is a routine that can take parameters, perform calculations or other actions, and return a result.

Most DBMSs provide you with the ability to create your own functions, while also providing a range of inbuilt functions.

User-Defined Functions

A user-defined function (UDF) is a function that you create for a specific purpose, and save to the database. You would create such a function for tasks that aren’t catered for by an inbuilt function.

See Introduction to User-Defined Functions in SQL Server for an overview. Although that article is written for SQL Server, most of the general concepts also apply to other DBMSs.

Inbuilt Functions

Most DBMSs have a large range of inbuilt functions that you can use in your SQL queries. For example, there are functions that return the current date and time, functions that format dates and numbers, functions that convert data from one data type to another, and more.

The range of inbuilt functions can be pretty extensive, and depend on the DBMS in use, so I won’t go over them in this SQL tutorial. But I would encourage you to try to find out what inbuilt functions your DBMS supports.

To get you started, the following articles contain some of the most commonly used functions in SQL programming.

SQL Server

• SQL Server String Functions
• SQL Server Mathematical Functions
• SQL Server Date &Time Functions

MySQL

• MySQL String Functions
• MySQL Mathematical Functions

PostgreSQL

• PostgreSQL Date &Time Functions
• PostgreSQL Math Functions

SQLite

• SQLite Aggregate Functions
• SQLite Date &Time Functions