Acabamos de publicar un curso en el canal de YouTube de freeCodeCamp en español que te guiará paso a paso a través de los fundamentos de SQL. Aprenderás los conceptos básicos que necesitas para comenzar y crearás dos proyectos.

El curso fue creado por Sergie Code. Sergie es ingeniero de software y creador de contenido a quien le encanta enseñar y compartir sus conocimientos. Su trabajo se centra en JavaScript, incluyendo React.js, Angular.js y otros frameworks.

Antes de adentrarnos en el contenido del curso, veamos qué es SQL y por qué deberías aprenderlo.

Los datos están en todas partes. Las plataformas y organizaciones modernas dependen de las bases de datos todos los días. Cada vez que inicias sesión en un sitio web, estás utilizando el poder de las bases de datos. Al dominar SQL, podrás extraer información valiosa a partir de los datos almacenados, una habilidad que es muy valorada en la ingeniería de software, la ciencia de datos y en los negocios.

SQL es un lenguaje especializado diseñado para gestionar datos almacenados en bases de datos relacionales. Con SQL, puedes crear bases de datos, definir su estructura y realizar operaciones clave como crear, insertar, actualizar y eliminar registros. Una de sus características principales es que te permite acceder a los datos a través de consultas (queries) para encontrar de forma eficiente los datos exactos que tú o tu aplicación necesitan.

Curso de SQL en español

Genial. Ahora que ya sabes más sobre SQL, veamos lo que aprenderás durante el curso:

• Introducción a SQL y bases de datos.
• SQL vs. MySQL, PostgreSQL y SQL Server.
• Jerarquía de bases de datos relacionales.
• DBngin y TablePlus.
• Lenguaje de Definición de Datos (DDL): CREATE, DROP, ALTER y DESCRIBE.
• Trabajo con tablas, atributos y restricciones.
• Claves foráneas y relaciones entre tablas.
• Lenguaje de Manipulación de Datos (DML): INSERT, UPDATE, DELETE y TRUNCATE.
• Lenguaje de Consulta de Datos (DQL): SELECT, WHERE y ORDER BY.
• Funciones de agregación (COUNT, SUM, AVG).
• INNER JOIN, LEFT JOIN, RIGHT JOIN, y Joins de 3 tablas.
• Subconsultas, GROUP BY y HAVING.
• Gestión de SQL con Docker y variables de entorno.
• Buenas prácticas y ejemplos prácticos.

Al final del curso, conocerás los fundamentos de SQL y podrás comenzar a crear y gestionar tus propias bases de datos relacionales.

Te invitamos a ver el curso en el canal de YouTube de freeCodeCamp.org en español:

✍️ Curso creado por Sergie Code.

• Youtube: @SergieCode
• Instagram: sergiecode
• LinkedIn: Sergie Code
• GitHub: sergiecode
• Facebook: sergiecodeok
• TikTok: @sergiecode
• Twitter: @sergiecode
• Threads: @sergiecode

SQL (Structured Query Language) es un lenguaje de programación popular, utilizado para bases de datos relacionales y  existen muchos recursos gratis muy buenos que puedes usar para aprenderlo.

En este artículo, te compartiré 8 cursos gratis para principiantes con los que podrás aprender SQL, PostgreSQL y MySQL.

Cursos gratis de SQL

1. Relational Database Curriculum (freeCodeCamp)
2. SQL Tutorial - Full Database Course for Beginners (freeCodeCamp)
3. Learn SQL In 60 Minutes (Web Dev Simplified)
4. SQL For Beginners Tutorial (Amigoscode)
5. MySQL Database - Full Course (freeCodeCamp)
6. MySQL Tutorial for Beginners - Full Course (Programming with Mosh)
7. MySQL Crash Course | Learn SQL (Traversy Media)
8. SQL for Data Science (UC Davis)

Curso de Bases de Datos Relacionales de freeCodeCamp

En septiembre de 2021, freeCodeCamp lanzó la versión beta de su curso de Bases de datos relacionales. Esta versión beta corre completamente en Visual Studio Code utilizando Docker y la extensión CodeRoad.

En este curso aprenderás acerca de Git, GitHub, Bash, Nano, SQL, PostgreSQL y mucho más. Este es un curso completamente basado en proyectos.

Algunos de los proyectos que construirás son, una base de datos de Mario, una base de datos mundial, una base de datos de cuerpos celestes y una tienda de renta de bicicletas.

Para aprender más, puedes leer este artículo de Tom Mondloch, creador del curso.

Tutorial de SQL- Curso completo de bases de datos para principiantes

En este curso de freeCodeCamp en YouTube, Mike Dane, te enseñará las bases de SQL. Aprenderás sobre cómo crear tablas, insertar datos, comodines, uniones y mucho más.

En este curso, aprenderás cómo instalar MySQL en tu Mac o computadora Windows. También practicarás tus habilidades en SQL al construir la base de datos de una compañía y un diagrama entidad-relación

Si te gusta este curso de Mike Dace, puedes visitar su canal de YouTube, para más cursos gratis.

Aprende SQL en 60 minutos

En este curso de Desarrollo Web en YouTube, Kyle te enseñará las bases para empezar con SQL. Aprenderás a crear de tablas, insertar datos a tablas, llaves primarias, llaves foráneas, agregar funciones y más.

Este es un gran curso que te servirá de introducción, a partir de aquí podrás crear tus propios proyectos usando SQL.

Tutorial de SQL para principiantes

En este curso de Amigoscode en YouTube, Nelson te enseñará como configurar PostgreSQL en Mac y Windows. También aprenderás las bases de SQL, incluyendo, la creación de tablas, llaves primarias, llaves foráneas, agregar funciones y más.

Si disfrutas este curso gratis en YouTube de Nelson, puedes ver sus otros cursos en su canal o visitar su sitio web para ver sus cursos de pago.

Base De Datos Con MySQL - Curso Completo

En este curso gratis de freeCodeCamp en YouTube, Bharath te enseñará cómo instalar MySQL en tu máquina local. Aprenderás como crear tablas, insertar datos en tablas, hacer modelado de datos, bloquear, a usar SQL Explain y mucho más.

Bharath también ofrece recursos útiles para acompañar el curso, como una guía de inicio y un repositorio en GitHub con los códigos MySQL.

Si disfrutas este curso, puedes visitar más cursos en su canal de YouTube.

Tutorial MySQL para Principiantes - Curso Completo

En este curso de Programming with Mosh en YouTube, Mosh te enseñará como instalar MySQL en Mac o Windows. Aprenderás acerca de, crear tablas, insertar datos en tablas, uniones, operadores, cláusulas SQL, operadores SQL y más.

Si disfrutas este curso de Mosh, puedes visitar su canal de YouTube o visitar su sitio web para ver sus cursos de pago.

Curso intensivo de MySQL | Aprende SQL

En este curso de Traversy Media en YouTube, Brad te enseñará las bases para empezar con SQL, aprenderás a crear tablas, insertar datos en tablas, modificar tablas, llaves primarias, llaves foráneas, agregar funciones y más.

Esta es una gran introducción para comenzar a aprender lo básico. A partir de aquí podrás comenzar a construir tus primeros proyectos usando MySQL.

Brad también incluye un acordeón de MySQL en el curso.

SQL para Ciencias de Datos

En este curso de UC Davis, aprenderás las bases para usar SQL en un contexto de Ciencias de Datos, aprenderás a como crear tablas, insertar datos en tablas, llaves primarias, llaves foráneas, agregar funciones, uniones, sub-consultas y más.

Este curso es de acceso gratis en Coursera y es parte de la especialización, aprende las bases de SQL para Ciencias de Datos.

Si te interesa continuar con esta especialización, te sugiero mirar los otros tres cursos ofrecidos después de este curso introductorio.

Hagamos un repaso rápido de que es una base de datos y sus tipos. Una base de datos es una herramienta que nos permite almacenar datos de forma permanente. Existen 2 tipos de bases de datos que difieren en su forma de almacenar y recuperar los datos pero cumplen el objetivo anteriormente descrito, veamos un poco en detalle esto.

Tipos de bases de datos:

• Relacionales o SQL. Los datos se almacenan en tablas y campos, donde una tabla puede tener múltiples campos y estos campos almacenan un dato, que puede ser cadena de caracteres, textos (cadenas con más de 255 caracteres), números (enteros y decimales), fecha, fecha y hora, datos binarios. Cada herramientas de gestión de base de datos SQL puede tener algunos tipos de campos adicionales.
• NoSQL o no solo SQL. Los datos se van a almacenar de acuerdo a como la herramienta lo implemente, siendo las más usadas: colecciones y documentos, par registros de la forma llave-valor, columnas anchas (donde se generan tablas y campos pero con la ventaja de cada registro puede tener diferentes campos), grafos.

De acuerdo la necesidad que se tenga, se selecciona el tipo de base de datos a utilizar. Nuestro foco en este artículo es el de las bases de datos relacionales o SQL. Para ello vamos a partir de un ejemplo que tenemos pre-construido, donde la base de datos posee 3 tablas, relacionadas entre sí, de acuerdo con el siguiente módelo: entidad-relación (es el modelo usado por excelencia para representar bases de datos SQL):

Base de datos de ejemplo:

En nuestro caso partimos de una base de datos que simula un sistema de gestión de tickets o turnos, que está compuesto de 3 tablas, que representan las 3 entidades envueltas:

• users, es la tabla que nos permite representar los usuarios o clientes que van a solicitar turnos o tickets.
• stores, almacena los datos de las tiendas o comercios que ofrecen los servicios y que desean tener control de los turnos o tickets de sus clientes.
• tickets, tabla que almacena los turnos o tickets de los clientes en las tiendas o comercios.

De acuerdo al modelo anterior, podemos entender que un usuario (registro en la tabla users) puede tener n turnos, en este caso hablamos de una relación 1 -> N, luego podemos observar que una tienda (registro en la tabla stores) va a disponer o habilitar n turnos, entonces la relación será de la misma forma: 1 -> N. Luego es posible observar que un usuario va a n turnos en n tiendas, por lo tanto la relación de usuarios con tiendas será N -> M.

Puedes obtener la base de datos de ejemplo para práctica en el siguiente link:
https://github.com/ljcl79/practica-joins

Como realizar consultas sobre una base de datos SQL

Para realizar una consulta sobre una base de datos SQL, recordemos que usamos el comando SELECT, el cual nos retorna los campos de los registros que cumplan la condición de búsqueda. La anatomía de un SELECT sigue a continuación:

En este video podrás encontrar un mejor detalle de como realizar consultas básicas, hacemos uso de la misma base de datos del documento actual.

Con el contexto anterior, podemos avanzar un nivel en cuanto a consultas de base de datos SQL, es el uso de JOINs. Los JOINs nos permites relacionar tablas por campos, que generalmente corresponden a campos que identifican registros en la tabla principal y referencia a un campo en la tabla destino.

Por ejemplo en el modelo que estamos usando como ejemplo, tenemos las relaciones indicadas anteriormente:

• Tabla users por el campo id está relacionado con la tabla tickets por el campo user_id.
• Tabla stores por el campo id está relacionado con la tabla tickets por el campo store_id

Ahora pensemos en como hacer una consulta que relacione las tablas, ejemplo, saber que usuarios tienen turnos, ya sea realizados o agendados. Para ello podemos aplicar el uso de JOIN, en este caso veamos la siguiente figura:

En el caso anterior la tabla A será la tabla users y la tabla B será la tabla tickets, la consulta a ejecutar para obtener que usuarios tienen turnos, como indicamos anteriormente será:

SELECT * FROM users A INNER JOIN tickets B ON A.id = B.user_id;

Observando la gráfica podemos obtener los distintos tipos de JOINs que SQL permite realizar:

INNER JOIN

LEFT JOIN

RIGHT JOIN

FULL JOIN

Para profundizar sobre el tema de JOINs puedes acceder a este artículo de freeCodeCamp.org en español: https://www.freecodecamp.org/espanol/news/tutorial-de-uniones-en-sql/.

De igual forma, en el siguiente video podrás entrar en detalle de como realizar consultas usando JOINs.

Consultas a realizar

Con el modelo anterior indicado, pensemos en algunas consultas que serán interesantes realizar:

• Cantidad de usuarios con ticket por día en un periodo
• Promedio de turnos por día en un periodo
• Cantidad de turnos mayor o menor por dia.
• Cantidad de turnos ejecutados mayor o menor por dia.
• Cantidad de turnos por Tienda por día en un periodo
• Top 10 de las tiendas con mayor cantidad de turnos ejecutados.

Todas las consultas anteriores tienen un elemento en común, es que necesitan agruparse para poder hacer las operaciones de cálculo, para ello, SQL tiene un palabra reservada que podemos ejecutar en nuestras queries: GROUP BY, que adicionalmente se puede filtrar usando la palabra reserva HAVING.

Además de ello, de las consultas podemos entender que debemos conseguir el valor mayor, el valor menor, el promedio por ejemplo, todo lo anterior se denomina, funciones de agregado, veamos esto en detalle.

Agrupando los resultados por campos

Cuando realizamos una consulta, podemos definir que los resultados se agrupen por los valores de un campo, de esta forma, luego podemos obtener valores como conteo, suma o promedio de valores, incluso obtener el mayor o el menor valor de un campo . Adicionalmente cuando agrupamos podemos filtrar esos resultados agrupados aplicando los criterios anteriomente indicados (conteo, suma, etc);

Anatamía de un GROUP BY con HAVING:

Ordenando los resultados

Al momento de realizar consultas, es posible querer que estas se ordenen por algun campo, siendo los criterios disponibles: de forma ascendente y de forma descendente. Esto nos permite obtener los datos con una visual definida de tal forma que sea facil ubicar los datos y también poder comparar sus valores.

Para ordenar una consulta simplemente agregamos al final de ella, las palabras reservadas ORDER BY y luego el o los campos los cuales deseamos ordenar, siendo posible ordenar por multiples campos y cada campo tenga su criterio (ascendente o descendente).

Limitando los resultados

En alguna oportunidades queremos solo obtener el primer registro de la consulta (aunque sea haya retornado una cantidad mayor de registros), o por ejemplo queremos obtener el top 10 de registros con cierta condición, para ello usamos cada herramienta de base de datos posee una palabra reservada, en nuestro caso, usando MySQL o PostgreSQL,  la palabra reservada será LIMIT.

Más adelante usaremos tanto el orden como la limitación para ajustar nuestras consultas.

Funciones de agregado

Estas son funciones de SQL (Si SQL así como un lenguaje de programación tienen funciones, lo que lo haces aún más poderoso 😎), que realizan un calculo, en base a un campo o expresión de campos, sobre un conjunto de datos y retornan un resultado.

Tomando en cuenta lo indicado en punto anterior, las funciones de agregado generalmente van acompañadas de las palabras reservadas GROUP BY y en algunos casos de la palabra HAVING (estas trabajan en conjunto se mencionó anteriormente), pero esto no es regla, es decir no es necesario ello. Entendido esto, podemos obtener una única fila como resultado de una consulta con una función de agregado, o una fila por cada grupo generado en la query (usando GROUP BY)

Anatomía de las funciones de agregado

Las consultas o SELECT usando funciones de agregado van a seguir la siguiente forma:

Ejemplo de consultas que retornarian un único resultado:

• Día del primer turno registrado
• Día del último turno registrado
• Cantidad de turnos procesados por el sistema
• Si le agregamos a la tabla de tickets, los minutos de cada turno ejecutado, podemos obtener la suma de tiempo ejecutado.

Estos 4 ejemplos nos van a retornar una fila de resultado solamente, porque no estamos agrupando por ningún elemento.

Ahora bien, veamos cuales son esas funciones de agregado:

COUNT

Nos permite hacer el conteo, o contar cuantos registros o filas que cumplen la condición de la consulta. Su sintaxis es muy simple: ]

SELECT COUNT(campo o *) FROM tabla1 INNER JOIN tabla2 ON (tabla1.key = tabla2.key) WHERE <condicion> 

Ahora vemos la siguiente consulta:

SELECT COUNT(campo o *) FROM tabla1 INNER JOIN tabla2 ON (tabla1.key = tabla2.key) WHERE <condicion> GROUP BY <campo1>

SUM

Nos permite hacer la suma de los valores del campo de los registros o filas que cumplen la condición de la consulta. Tiene sentido cuando el campo es numérico. Su sintaxis sigue a continuación:

SELECT SUM(campo) FROM tabla1 INNER JOIN tabla2 ON (tabla1.key = tabla2.key) WHERE <condicion> 

Agrupando por algún campo queda:

SELECT SUM(campo) FROM tabla1 INNER JOIN tabla2 ON (tabla1.key = tabla2.key) WHERE <condicion> GROUP BY <campo1>

AVG

Esta función calcula el promedio de los valores del campo de los registros o filas que cumplen la condición de la consulta, se entiende como el promedio a la suma de los valores dividido entre la cantidad de registros, sería algo como SUM/COUNT. Sólo funciona si el campo es numérico. La sintaxis es:

SELECT AVG(campo) FROM tabla1 INNER JOIN tabla2 ON (tabla1.key = tabla2.key) WHERE <condicion> 

Agrupando por algún campo queda:

SELECT AVG(campo) FROM tabla1 INNER JOIN tabla2 ON (tabla1.key = tabla2.key) WHERE <condicion> GROUP BY <campo1>

MAX

La función MAX, nos permite calcular el máximo o mayor valor de un conjunto de registros o filas que cumplen la condición de la consulta (siempre comento esto porque estas funciones se pueden o no combinar con condiciones de consulta). A diferencia de las anteriores, es posible usarla en cualquier tipo de dato que sea ordenable, por ejemplo, textos y números. La usamos de la siguiente forma es:

SELECT MAX(campo) FROM tabla1 INNER JOIN tabla2 ON (tabla1.key = tabla2.key) WHERE <condicion> 

Agrupando por algún campo queda:

SELECT MAX(campo) FROM tabla1 INNER JOIN tabla2 ON (tabla1.key = tabla2.key) WHERE <condicion> GROUP BY <campo1>

MIN

La función MIN, nos permite calcular el menor valor o el valor mínimo de un conjunto de registros o filas devueltos a realizar una consulta, esta puede tener o no condiciones. Como su antecesora (MAX), es posible usarla en cualquier tipo de dato que sea ordenable, caso más usado: textos y números. Para ejecutarla, lo indicamos de la siguiente forma:

SELECT MIN(campo) FROM tabla1 INNER JOIN tabla2 ON (tabla1.key = tabla2.key) WHERE <condicion> 

Agrupando por algún campo queda:

SELECT MIN(campo) FROM tabla1 INNER JOIN tabla2 ON (tabla1.key = tabla2.key) WHERE <condicion> GROUP BY <campo1>

Implementando las consultas solicitadas en SQL

Vamos a realizar el código SQL para cada una de las consultas planteadas anteriormente, para ello vamos a usar lo que hemos aprendido: Funciones de agregado, agrupamiento y relacionamiento.

• Cantidad de usuarios con ticket por día en un periodo. Definamos ese periodo para el ejemplo como el mes de julio de 2023.

En este caso, lo que requerimos es cantidad de registros, es contar por lo tanto la función de agregado que vamos a usar es COUNT, adicionalmente nos piden que ese conteo, sea realizado por día, es decir debemos agrupar los datos por el día del turno.

Con lo anterior la consulta a construir será:

SELECT COUNT(*) FROM users INNER JOIN tickets ON (users.id = tickets.user_id) WHERE date_time >= '2023-07-01' AND date_time < '2023-08-01' GROUP BY date_time 

La consulta está correcta de sintaxis, pero el campo date_time es de tipo fecha y hora, por lo tanto, esta agrupando siempre que el ticket fuese realizado en el mismo día y a la misma hora, lo cual no es lo solicitado, para ello vamos a hacer uso de una función especial que nos retorne la fecha solamente en el caso de un campo de tipo datetime, en ese caso la función es DATE, luego es necesario que ademas del conteo, mostremos el día, por lo que la consulta queda:

SELECT DATE(date_time), COUNT(*) FROM users INNER JOIN tickets ON (users.id = tickets.user_id) WHERE date_time >= '2023-07-01' AND date_time < '2023-08-01' GROUP BY DATE(date_time)

• Promedio de turnos por día en un periodo

Para esta consulta debemos hacer uso de la función AVG, ya que lo nos piden es el promedio de turnos por dia, en un periodo, en ese caso, tomamos la consulta anterior, y sobre esa consulta aplicamos un concepto que se denomina SUBSELECT. Cuando hacemos uso de SUBSELECT debemos encerrar entre () la consulta original y luego le damos un nombre, observa como queda la consulta:

SELECT AVG(total) FROM 
(SELECT DATE(date_time), COUNT(*) as total FROM users INNER JOIN tickets ON (users.id = tickets.user_id) WHERE date_time >= '2023-07-01' AND date_time < '2023-08-01' GROUP BY DATE(date_time)) as t1

El texto as t1 es el que nos permite indicarle a SQL que ese SUBSELECT que está entre parentesis: (SELECT DATE(date_time), COUNT(*) as total FROM users INNER JOIN tickets ON (users.id = tickets.user_id) WHERE date_time >= '2023-07-01' AND date_time < '2023-08-01' GROUP BY DATE(date_time))

Otro punto interesante es que le dimos un nombre al valor de conteo, para poder luego obtener su promedio, eso lo hicimos de esta forma: COUNT(*) as total

• Cantidad de turnos mayor o menor por dia.

En este caso debemos usar las funciones de MAX y MIN, vamos a realizar 2 consultas para ello. Para obtener el día con mayor cantidad de turnos esperados (es decir sin importar su status), hacemos la siguiente consulta:

SELECT MAX(t1.total) FROM 
(
SELECT DATE(date_time) as fecha, COUNT(*) as total FROM users INNER JOIN tickets ON (users.id = tickets.user_id) 
WHERE date_time >= '2023-07-01' AND date_time < '2023-08-01' GROUP BY DATE(date_time)
) as t1;

La consulta anterior nos devuelve la cantidad máximas de turnos, pero no obtenemos el día, lo cual sería importante, por lo que en ese caso podemos hacer uso de otra herramienta que no es función de agregado, pero que es básica para cualquier consulta, el ordenar, luego si solo queremos un registro, nos apoyamos en otra herramientas disponible que es la de limitar como vimos anteriormente.

Como queda nuestra consulta para obtener el día com mayor cantidad de turnos, usando orden y limitación:

SELECT DATE(date_time) as fecha, COUNT(*) as total FROM users INNER JOIN tickets ON (users.id = tickets.user_id) 
WHERE date_time >= '2023-07-01' AND date_time < '2023-08-01' 
GROUP BY DATE(date_time) 
ORDER BY 2 DESC LIMIT 1

Para obtener la cantidad menor de turnos en un día usamos las mismas consultas, sólo ajustando las funciones de agregado o el criterio de orden.

SELECT MIN(t1.total) FROM 
(
SELECT DATE(date_time) as fecha, COUNT(*) as total FROM users INNER JOIN tickets ON (users.id = tickets.user_id) 
WHERE date_time >= '2023-07-01' AND date_time < '2023-08-01' GROUP BY DATE(date_time)
) as t1;

Observa que en este caso cambiamos MAX por MIN.

Ahora usando orden y limitación:

SELECT DATE(date_time) as fecha, COUNT(*) as total FROM users INNER JOIN tickets ON (users.id = tickets.user_id) 
WHERE date_time >= '2023-07-01' AND date_time < '2023-08-01' 
GROUP BY DATE(date_time) 
ORDER BY 2 ASC LIMIT 1

Para este caso solo cambiamos es  DESC por ASC.

• Día con mayor o menor cantidad de turnos ejecutados

Esta consulta es similar a la anterior, solo que en este caso vamos a agregar una condición del valor del campo status, que sea igual a realizado, observa como quedan las consultas:

Primero veamos el día con mayor cantidad de turnos realizados o ejecutados:

SELECT MAX(t1.total) FROM 
(
SELECT DATE(date_time) as fecha, COUNT(*) as total FROM users INNER JOIN tickets ON (users.id = tickets.user_id) 
WHERE date_time >= '2023-07-01' AND date_time < '2023-08-01' AND status = 'Realizado' GROUP BY DATE(date_time)
) as t1;

Recordando que si queremos la fecha, usamos orden y limitación:

SELECT DATE(date_time) as fecha, COUNT(*) as total FROM users INNER JOIN tickets ON (users.id = tickets.user_id) 
WHERE date_time >= '2023-07-01' AND date_time < '2023-08-01' AND status = 'Realizado'
GROUP BY DATE(date_time) 
ORDER BY 2 DESC LIMIT 1

Ahora veamos el día con menor cantidad de turnos realizados o ejecutados:

SELECT MIN(t1.total) FROM 
(
SELECT DATE(date_time) as fecha, COUNT(*) as total FROM users INNER JOIN tickets ON (users.id = tickets.user_id) 
WHERE date_time >= '2023-07-01' AND date_time < '2023-08-01' AND status = 'Realizado' GROUP BY DATE(date_time)
) as t1;

Usando orden y limitación, obtenemos tanto la cantidad como la fecha que sucedió:

SELECT DATE(date_time) as fecha, COUNT(*) as total FROM users INNER JOIN tickets ON (users.id = tickets.user_id) 
WHERE date_time >= '2023-07-01' AND date_time < '2023-08-01' AND status = 'Realizado'
GROUP BY DATE(date_time) 
ORDER BY 2 ASC LIMIT 1

• Cantidad de turnos por Tienda por día en un periodo

Veamos ahora este ejemplo, donde la función de agregado es la de conteo, pero debemos agrupar por 2 campos, en este será la fecha del turno y el nombre de la tienda, los campos están en 2 tablas diferentes pero esto no será problema para nuestra consulta. Veamos como queda:

SELECT store_name, DATE(date_time) as fecha, COUNT(*) as total FROM stores INNER JOIN tickets ON (stores.id = tickets.store_id) 
WHERE date_time >= '2023-07-01' AND date_time < '2023-08-01' GROUP BY store_name, DATE(date_time)

En la consulta apreciamos que el agrupamiento se realizó por el nombre de la tienda y la fecha del turno: GROUP BY store_name, DATE(date_time)

• Top 10 de las tiendas con mayor cantidad de turnos ejecutados.

En este caso, analicemos la consulta, vamos a necesitar contar los turnos, función COUNT, luego debemos agruparlos por cada tienda, de esta forma obtenemos la cantidad por tienda, luego aplicamos un criterio de orden descendente, para que las primeras sean las tiendas de mayor cantidad de turnos y luego lo limitamos a 10. Excelente!, veamos la query.

SELECT store_name, COUNT(*) as total FROM stores INNER JOIN tickets ON (stores.id = tickets.store_id) 
WHERE date_time >= '2023-07-01' AND date_time < '2023-08-01' GROUP BY store_name ORDER BY total DESC LIMIT 10

Resultando lo siguiente:

Veamos aquellas consultas que sabemos que no tienen agrupamiento:

• Día del primer turno registrado

SELECT MIN(date_time) FROM tickets t 

De forma rápida apreciamos que usando la función MIN, obtemos el valor mínimo de ese campo.

• Día del último turno registrado

SELECT MAX(date_time) FROM tickets t

Acá apreciamos que logramos obtener el valor máximo del campo fecha del turno.

• Cantidad de turnos procesados por el sistema

Consulta básica:

SELECT COUNT(*) FROM tickets WHERE status = 'Realizado'

• Si le agregamos a la tabla de tickets, los minutos de cada turno ejecutado, podemos obtener la suma de tiempo ejecutado.

SELECT SUM(tiempo) FROM tickets WHERE status = 'Realizado'

Recuerden que para poder ejecutar la consulta anterior debe agregarse la columna tiempo en la tabla tickets.

Todo lo realizado hasta aquí lo puedes ver en la práctica en el siguiente video:

Los joins o combinaciones de SQL permiten que nuestros sistemas de administración de base de datos relacionales estén bien "relacionados".

Los joins o combinaciones nos permiten reconstruir de nuevo nuestras tablas de base de datos separadas en relaciones que impulsan nuestras aplicaciones.

En este artículo, hablaremos de cada uno de los diferentes tipos de joins o combinaciones de SQL y como usarlas.

Lo que cubriremos:

• ¿Qué es un join o combinación de SQL?
• Configurando tu base de datos
• CROSS JOIN
• Configurando nuestra data ejemplo (directorios y películas)
• FULL OUTER JOIN
• INNER JOIN
• LEFT JOIN / RIGHT JOIN
• Filtrar usando LEFT JOIN
• Múltiples joins o combinaciones
• Joins o combinaciones con condiciones extra
• La verdad sobre escribir queries con joins o combinaciones

(Alerta de spoiler: cubriremos cinco diferentes tipos—pero solamente necesitas conocer dos de ellos!)

¿Qué es un join o combinación en SQL?

Un join es una operación que combina dos filas juntas en una fila.

Estas filas usualmente pertenecen a dos tablas diferentes —pero no necesariamente tiene que ser así.

Antes de ver como escribir un join, veamos como se vería su resultado.

Tomemos como ejemplo un sistema que almacena información acerca de sus usuarios y sus direcciones.

Las filas de la tabla que almacena la información del usuario se vería así:

 id |     nombre     |        email        | edad
----+--------------+---------------------+-----
  1 | John Smith     | johnsmith@gmail.com |  25
  2 | Jane Doe       | janedoe@Gmail.com   |  28
  3 | Xavier Wills   | xavier@wills.io     |  3
...
(7 filas)

Y las filas de la tabla que almacena direcciones podría verse así:

 id |      calle        |     ciudad    | estado| id_usuario
----+-------------------+---------------+-------+---------
  1 | 1234 Main Street  | Oklahoma City | OK    |       1
  2 | 4444 Broadway Ave | Oklahoma City | OK    |       2
  3 | 5678 Party Ln     | Tulsa         | OK    |       3
(3 rows)

Podríamos escribir por separado consultas que nos traiga tanto información relacionada con los usuarios como la información de la dirección — pero idealmente podemos escribir una consulta y recibir todos los usuarios y las direcciones al mismo tiempo.

¡Esto es exactamente lo que nos permiten hacer los joins!

Veremos como escribir estos joins pronto, pero si combinamos nuestra información del usuario a la información de dirección conseguiremos un resultado como este:

 id |     nombre     |        email        | edad | id |      calle      |    ciudad      | estado | id_usuario
----+--------------+---------------------+-----+----+-------------------+---------------+-------+---------
  1 | John Smith   | johnsmith@gmail.com |  25 |  1 | 1234 Main Street  | Oklahoma City | OK    |       1
  2 | Jane Doe     | janedoe@Gmail.com   |  28 |  2 | 4444 Broadway Ave | Oklahoma City | OK    |       2
  3 | Xavier Wills | xavier@wills.io     |  35 |  3 | 5678 Party Ln     | Tulsa         | OK    |       3
(3 filas)

Aquí vemos todos los usuarios y sus direcciones en un buen conjunto de resultadoa.

Además de producir un conjunto de resultado combinado, otro uso importante de los joins es obtener información adicional contra la que podemos filtrar.

Por ejemplo, si queremos enviar un correo físico a todos los usuarios que viven en la ciudad de Oklahoma, podríamos usar el conjunto de resultado combinado y filtrarlo basado en la columna ciudad.

Ahora que sabemos el propósito de los Joins, ¡empecemos escribiendo algunos!

Configurando tu base de datos

Antes de que podamos escribir nuestras consultas necesitamos configurar nuestra base de datos.

Para estos ejemplos estaremos usando PostgreSQL, pero las consultas y conceptos mostrados aquí serán facilmente traducidos a cualquier sistema moderno de base de datos (como MySQL, SQL Server, etc.).

Para trabajar con nuestra base de datos en  PostgreSQL, podemos usar psql—el programa interactivo de línea de comandos de PostgreSQL. Si tienes otro cliente de base de datos con el que disfrutes trabajar puedes usarlo también.

Para comenzar vamos a crear nuestra base de datos. Con el PostgreSQL ya instalado, corremos el comando createdb <nombre de la base de datos> en nuestra terminal para crear nuestra base de datos. Llamé a la mia fcc:

$ createdb fcc

Ahora iniciemos la consola interactiva usando el comando psql y nos conectamos a la base de datos que acabamos de crear usando \c <nombre de la base de datos>:

$ psql
psql (11.5)
Type "help" for help.

john=# \c fcc
You are now connected to database "fcc" as user "john".
fcc=#

Nota: Limpié la salida de psql en estos ejemplos para hacerlos más fáciles de leer, así que no te preocupes si la salida que te muestro aquí no es exactamente igual a la que estás viendo en tu terminal.

Te recomiendo que hagas estos ejemplos conmigo y que corras estas consultas tu mismo. Aprenderás y recordarás mucho más trabajando sobre estos ejemplos en lugar de solo leerlos.  

¡Ahora veamos las combinaciones o joins!

CROSS JOIN

Los joins más simples que podemos hacer son los  CROSS JOIN o "Producto cartesiano."

Este join toma cada fila de una tabla y la une a cada fila de otra tabla.

Si tenemos dos listas —una que contiene 1, 2, 3 y otra que contiene A, B, C—el producto cartesiano de las dos listas sería:

1A, 1B, 1C
2A, 2B, 2C
3A, 3B, 3C

Cada valor de la primera lista es emparejado con cada valor de la segunda lista.

Escribamos este mismo ejemplo como un query en SQL.

Primero creamos dos tablas muy simples e insertemos algunos datos en ellas:

CREATE TABLE letras(
  letra TEXT
);

INSERT INTO letras(letra) VALUES ('A'), ('B'), ('C');

CREATE TABLE numeros(
  num TEXT
);

INSERT INTO numeros(num) VALUES (1), (2), (3);

Nuestras dos tablas, letras y numeros, solo tienen una columna: un campo de texto simple.

Ahora vamos a combinarlas con CROSS JOIN:

SELECT *
FROM letras
CROSS JOIN numeros;

 letra | num
--------+--------
 A      | 1
 A      | 2
 A      | 3
 B      | 1
 B      | 2
 B      | 3
 C      | 1
 C      | 2
 C      | 3
(9 filas)

Este es el  join mas simple que podemos hacer —pero aún en este simple ejemplo podemos ver como trabajan los joins: las dos filas separadas (una de letras y otra de numeros) han sido combinadas para formar una fila.

Mientras este tipo de join es discutido como un mero ejemplo académico, tiene al menos un buen caso de uso: rangos de fechas.

CROSS JOIN con rangos de fecha

Un buen caso de uso del CROSS JOIN es tomar cada fila de una tabla y aplicarla a todos los días dentro de un rango de fecha.

Digamos por ejemplo que estabas creando una aplicación que hiciera seguimiento a tareas diarias —cosas como cepillarte los dientes, comer tu desayuno, o ducharte.

Si quisieras generar un registro de cada tarea diaria y por cada día de la semana pasada, podrías usar un CROSS JOIN contra un rango de fechas.

Para hacer este rango de fechas, podemos usar la  función generate_series:

SELECT generate_series(
  (CURRENT_DATE - INTERVAL '5 day'),
  CURRENT_DATE,
  INTERVAL '1 day'
)::DATE AS dia;

La función generate_series toma tres parámetros.

El primer parámetro es el valor inicial. En este ejemplo estamos usando CURRENT_DATE - INTERVAL '5 day'. Esto devuelve la fecha actual menos cinco días —o lo que es lo mismo a "hace cinco días."

El segundo parámetro es la fecha actual (CURRENT_DATE).

El tercer parámetro es el "intervalo de paso"—o cuánto queremos incrementar el valor cada vez. Dado que estas son tareas diarias, usaremos el intervalo de un día (INTERVAL '1 day').

Poniéndolo todo junto, esto genera una serie de fechas que comienzan hace cinco días, terminan hoy y van un día a la vez.

Finalmente, eliminamos la porción de tiempo al convertir la salida de estos valores a una fecha usando ::DATE, y le asignamos un alias a esta columna usando AS dia para hacer la salida un poco más agradable.

El resultado de esta consulta son los últimos cinco días más hoy:

    dia
------------
 2020-08-19
 2020-08-20
 2020-08-21
 2020-08-22
 2020-08-23
 2020-08-24
(6 filas)

Volviendo a nuestro ejemplo de tareas por día, creemos una tabla simple que incluya las tareas que queremos completar e insertemos algunas tareas:

CREATE TABLE tareas(
  nombre TEXT
);

INSERT INTO tareas(nombre) VALUES
('Lavar dientes'),
('Comer desayuno'),
('Ducharse'),
('Vestirse');

Nuestra tablatareas solo tiene una columna, nombre, e insertamos cuatro tareas en esta tabla.

Ahora hagamosCROSS JOIN a nuestras tareas con la consulta para generar las fechas :

SELECT
  tareas.nombre,
  dates.day
FROM tareas
CROSS JOIN
(
  SELECT generate_series(
    (CURRENT_DATE - INTERVAL '5 day'),
    CURRENT_DATE,
    INTERVAL '1 day'
  )::DATE	AS dia
) AS fechas

(Dado que nuestra consulta de generación de fechas no es una tabla real, simplemente la escribimos como una subconsulta)

A partir de esta consulta, devolvemos el nombre de la tarea y el día, y el conjunto de resultados se ve así:

     nombre      |    dia
---------------+------------
 Lavar dientes   | 2020-08-19
 Lavar dientes   | 2020-08-20
 Lavar dientes   | 2020-08-21
 Lavar dientes   | 2020-08-22
 Lavar dientes   | 2020-08-23
 Lavar dientes   | 2020-08-24
 Comer desayuno  | 2020-08-19
 Comer desayuno  | 2020-08-20
 Comer desayuno  | 2020-08-21
 Comer desayuno  | 2020-08-22
 ...
 (24 filas)

Como esperábamos, obtenemos una fila para cada tarea por cada día en nuestro rango de fechas.

El CROSS JOIN es el más simple join que podemos hacer, pero para ver los siguientes tipos, necesitaremos una configuración de tabla más realista.

Creando directorios y películas

Para ilustrar los siguientes tipos de combinaciones o joins, usaremos el ejemplo de películas y directorios de películas.

En esta situación, una película tiene un director, pero no se requiere que una película tenga un director —imagínate que se anuncia una nueva película, pero la elección del director aún no se ha confirmado.

Nuestra tabladirectorios almacenará el nombre de cada director, y la tabla películas almacenará el nombre de la película así como una referencia al director de la película (si tuviera uno).

Vamos a crear esas dos tablas e insertar algunos datos en ellas:

CREATE TABLE directorios(
  id SERIAL PRIMARY KEY,
  name TEXT NOT NULL
);

INSERT INTO directorios(name) VALUES
('John Smith'),
('Jane Doe'),
('Xavier Wills')
('Bev Scott'),
('Bree Jensen');

CREATE TABLE peliculas(
  id SERIAL PRIMARY KEY,
  name TEXT NOT NULL,
  director_id INTEGER REFERENCES directorios 
);

INSERT INTO peliculas(name, director_id) VALUES
('Pelicula 1', 1),
('Pelicula 2', 1),
('Pelicula 3', 2),
('Pelicula', NULL),
('Pelicula', NULL);

Tenemos cinco directorios, cinco películas, y tres de esas películas tienen directorios asignados. Director ID 1 tiene dos películas, y director ID 2 tiene una.

FULL OUTER JOIN

Ahora que tenemos algunos datos con los que trabajar, veamos el FULL OUTER JOIN.

UnFULL OUTER JOIN tiene algunas similitudes con un CROSS JOIN, pero tiene un par de diferencias clave.

La primera diferencia es que un FULL OUTER JOIN requiere una condición de combinación.

Una condición de combinación especifica cómo se relacionan entre sí las filas entre las dos tablas y según qué criterios deben unirse.

En nuestro ejemplo, nuetras tabla películas tiene una referencia al director a través de la columna director_id, y esta columna coincide con la columna id de la tabla directors. Estas son las dos columnas que usaremos como nuestra condición de combinación.

Así es como escribimos esta combinación entre nuestras dos tablas:

SELECT *
FROM peliculas
FULL OUTER JOIN directorios
  ON director.id = peliculas.director_id;

Observe la condición de combinación que especificamos que hace coincidir la película con su director: ON peliculas.director_id = directorios.id.

Nuestro conjunto de resultados parece una especie de producto cartesiano extraño:

  id  |  nombre   | director_id |  id  |     nombre
------+---------+-------------+------+--------------
    1 | Pelicula 1 |           1 |    1 | John Smith
    2 | Pelicula 2 |           1 |    1 | John Smith
    3 | Pelicula 3 |           2 |    2 | Jane Doe
    4 | Pelicula 4 |        NULL | NULL | NULL
    5 | Pelicula 5 |        NULL | NULL | NULL
 NULL | NULL       |        NULL |    5 | Bree Jensen
 NULL | NULL       |        NULL |    4 | Bev Scott
 NULL | NULL       |        NULL |    3 | Xavier Wills
(8 filas)

Las primeras filas que vemos son aquellas en las que la película tenía un director, y nuestra condición de combinación se evaluó como verdadera.

Sin embargo, después de esas filas, vemos cada una de las filas restantes de cada tabla—pero con valoresNULL  donde la otra tabla no tiene una coincidencia.

Note: Si no estás familiarizado con valores NULL , ve mi explicación aqui en este tutorial de operadores de SQL.

Aquí también vemos otra diferencia entre el CROSS JOIN y elFULL OUTER JOIN. Un FULL OUTER JOIN devuelve una fila distinta de cada tabla—a diferencia del CROSS JOIN que tiene múltiples.

INNER JOIN

El siguiente tipo de join, INNER JOIN, es uno de los tipos de join más utilizados.

Un inner join solo devuelve filas donde la condición de join es verdadera.

En nuestro ejemplo, un inner join entre nuestras tablas peliculas y directorios solo devolvería registros en los que a la película se le haya asignado un director.

La sintaxis es básicamente la misma que antes:

SELECT *
FROM peliculas
INNER JOIN directorios
  ON directorios.id = peliculas.director_id;

Nuestro resultado muestra las tres películas que tienen un director:

 id |  nombre   | director_id | id |    nombre
----+---------+-------------+----+------------
  1 | Pelicula 1 |           1 |  1 | John Smith
  2 | Pelicula 2 |           1 |  1 | John Smith
  3 | Pelicula 3 |           2 |  2 | Jane Doe
(3 filas)

Dado que un inner join solo incluye filas que coinciden con la condición del join, el orden de las dos tablas en el join no importa.

Si invertimos el orden de las tablas en la consulta, obtenemos el mismo resultado:

SELECT *
FROM directorios
INNER JOIN peliculas
  ON peliculas.director_id = directorios.id;

 id |    nombre    | id |  nombre   | director_id
----+------------+----+---------+-------------
  1 | John Smith |  1 | Pelicula 1 |           1
  1 | John Smith |  2 | Pelicula 2 |           1
  2 | Jane Doe   |  3 | Pelicula 3 |           2
(3 filas)

Dado que enumeramos la tabla  directorios primero en esta consulta y selecciona todas las columnas (SELECT *), vemos los datos de la columna directorios primero y luego las columnas de peliculas—pero el resultado es el mismo.

Esta es una propiedad útil de los inner joins, pero no es cierta para todos los tipos de joins—como nuestro próximo tipo de join.

LEFT JOIN / RIGHT JOIN

Los siguientes tipos de joins usan un modificador (LEFT or RIGHT) que afecta qué datos de la tabla se incluyen en el conjunto de resultados.

Nota: el LEFT JOIN yRIGHT JOIN también puede ser referido como LEFT OUTER JOIN y RIGHT OUTER JOIN.

Estos joins se utilizan en consultas en las que queremos devolver todos los datos de una tabla en particular y, si existe, los datos de la tabla asociada también.

Si los datos asociados no existen, aún recuperamos todos los datos de la tabla "primaria".

Es una consulta de información sobre algo en particular e información adicional si esta información adicional existe.

Esto será simple de entender con un ejemplo. Vamos a encontrar todas las películas y sus directorios, pero sin importar si tienen director o no—esto es adicional:

SELECT *
FROM peliculas
LEFT JOIN directorios
  ON directorios.id = peliculas.director_id;

La consulta sigue nuestro mismo patrón que antes—acabamos de especificar el join como un LEFT JOIN.

En este ejemplo, la tabla peliculas es la tabla de la "derecha".

Si escribimos la consulta en una línea, hace que esto sea un poco más fácil de ver:

... FROM peliculas LEFT JOIN directorios ...

Un left join devuelve todos los datos de la tabla de la "izquierda".

Un left join devuelve cualquier fila de la tabla "derecha"  que coincida con la condición del join.

Las filas de la tabla de la "derecha"  que no coinciden con la condición del join se devuelven comoNULL.

 id |  nombre   | director_id |  id  |    nombre
----+---------+-------------+------+------------
  1 | Pelicula 1 |           1 |    1 | John Smith
  2 | Pelicula 2 |           1 |    1 | John Smith
  3 | Pelicula 3 |           2 |    2 | Jane Doe
  4 | Pelicula 4 |        NULL | NULL | NULL
  5 | Pelicula 5 |        NULL | NULL | NULL
(5 filas)

Mirando ese conjunto de resultados, podemos ver por qué este tipo de join es útil para el tipo de consultas "todo esto y, si existe, algo de eso" .

RIGHT JOIN

El RIGHT JOIN trabaja exactamente como LEFT JOIN—excepto que las reglas sobre las dos tablas están invertidas.

En un right join, se devuelven todas las filas de la tabla "derecha" . La tabla  "izquierda" se devuelve condicionalmente en función de la condición del join.

Usemos la misma consulta que arriba, pero sustituyamos LEFT JOIN por RIGHT JOIN:

SELECT *
FROM peliculas
RIGHT JOIN directorios
  ON directorios.id = peliculas.director_id;

  id  |  nombre   | director_id | id |     nombre
------+---------+-------------+----+--------------
    1 | Pelicula 1 |           1 |  1 | John Smith
    2 | Pelicula 2 |           1 |  1 | John Smith
    3 | Pelicula 3 |           2 |  2 | Jane Doe
 NULL | NULL    |        NULL |  5 | Bree Jensen
 NULL | NULL    |        NULL |  4 | Bev Scott
 NULL | NULL    |        NULL |  3 | Xavier Wills
(6 filas)

Nuestro conjunto de resultados ahora devuelve la fila de cada director en la tabla directorios y, si existe, los datos de las peliculas.

Todo lo que hemos hecho es cambiar qué tabla estamos considerando como la "primaria" —la tabla de la que queremos ver todos los datos, independientemente de si existen sus datos asociados.

LEFT JOIN / RIGHT JOIN en aplicaciones de producción

En una aplicación de producción, solo uso LEFT JOIN y nunca uso RIGHT JOIN.

Hago esto porque, en mi opinión, un LEFT JOIN hace que la consulta sea más fácil de leer y comprender.

Cuando escribo consultas, me gusta pensar en comenzar con un conjunto de resultados "base", digamos que todas las películas, y entonces traer o sustraer) grupos de cosas de esa base.

Debido a que me gusta comenzar con una base, el LEFT JOIN se ajusta a esta línea de pensamiento. Quiero todas las filas de mi tabla base (la tabla "izquierda") y condicionalmente quiero las filas de la tabla "derecha".

En la práctica, no creo haber visto nunca un RIGHT JOINen una aplicación de producción. No hay nada de malo con un RIGHT JOIN—solo creo que hace que la consulta sea más difícil de entender.

Reescribiendo RIGHT JOIN

Si quisiéramos cambiar nuestro escenario anterior y, en su lugar, devolver a todos los directorios y condicionalmente sus películas, podemos reescribir fácilmente RIGHT JOIN en LEFT JOIN.

Todo lo que tenemos que hacer es cambiar el orden de las tablas en la consulta y cambiar de RIGHT a LEFT:

SELECT *
FROM directorios
LEFT JOIN peliculas
  ON peliculas.director_id = directorios.id;

Nota: Me gusta poner ON en la tabla que se está uniendo (la tabla "derecha" —en el ejemplo anterior peliculas) primero en la condición del join (ON peliculas.director_id = ...)—pero esa es solo mi preferencia personal.

Filtrado usando LEFT JOIN

Hay dos casos de uso para usar un LEFT JOIN (oRIGHT JOIN).

El primer caso de uso que ya lo hemos cubierto: devolver todas las filas de una tabla y condicionalmente de otra.

El segundo caso de uso es devolver filas de la primera tabla donde los datos de la segunda tabla no están presentes.

El escenario sería así: encontrar directorios que no pertenezcan a una película.

Para hacer esto, comenzaremos con un LEFT JOIN y nuestra tabla de directorios será la tabla primaria o la tabla "izquierda":

SELECT *
FROM directorios
LEFT JOIN peliculas
  ON peliculas.director_id = directorios.id;

Para un director que no pertenece a una película, las columnas de la tabla peliculas son NULL:

 id |     nombre     |  id  |  nombre   | director_id
----+--------------+------+---------+-------------
  1 | John Smith   |    1 | Pelicula 1 |           1
  1 | John Smith   |    2 | Pelicula 2 |           1
  2 | Jane Doe     |    3 | Pelicula 3 |           2
  5 | Bree Jensen  | NULL | NULL    |        NULL
  4 | Bev Scott    | NULL | NULL    |        NULL
  3 | Xavier Wills | NULL | NULL    |        NULL
(6 filas)

En nuestro ejemplo, los ID de director 3, 4, y 5 no pertenecen a una película.

Para filtrar nuestro conjunto de resultados solo a estas filas, podemos agregar una cláusula WHERE  para devolver solo las filas donde los datos de la película son NULL:

SELECT *
FROM directorios
LEFT JOIN peliculas
  ON peliculas.director_id = directorios.id
WHERE peliculas.id IS NULL;

 id |     nombre     |  id  | nombre | director_id
----+--------------+------+------+-------------
  5 | Bree Jensen  | NULL   | NULL |        NULL
  4 | Bev Scott    | NULL   | NULL |        NULL
  3 | Xavier Wills | NULL   | NULL |        NULL
(3 filas)

¡Y allí están nuestros tres directorios sin película!

Es común usar la columnaid de la tabla para filtrar (WHERE peliculas.id IS NULL), pero todas las columnas de la tabla  peliculas son NULL—por lo que cualquiera de ellas funcionaría.

(Dado que sabemos que todas las columnas de la tabla peliculas serán NULL, en la consulta anterior podríamos escribir SELECT directorios.* en lugar de SELECT * para devolver toda la información del director.)

UsandoLEFT JOIN para encontrar coincidencias

En nuestra consulta anterior encontramos directorios que no pertenecían a películas.

Usando nuestra misma estructura, podríamos encontrar directorios que si pertenecieran a películas cambiando nuestra condición WHERE  para buscar filas donde los datos de la película no sean NULL:

SELECT *
FROM directorios
LEFT JOIN peliculas
  ON peliculas.director_id = directorios.id
WHERE peliculas.id IS NOT NULL;

 id |    nombre    | id |  nombre   | director_id
----+------------+----+---------+-------------
  1 | John Smith |  1 | Pelicula 1 |           1
  1 | John Smith |  2 | Pelicula 2 |           1
  2 | Jane Doe   |  3 | Pelicula 3 |           2
(3 filas)

Esto puede parecer útil, pero en realidad acabamos de volver a implementar INNER JOIN!

Múltiple joins o combinaciones

Hemos visto cómo unir dos tablas, pero ¿qué pasa con las combinaciones múltiples seguidas?

En realidad es bastante simple, pero para ilustrar esto necesitamos una tercera tabla: tickets.

Esta tabla representará las entradas vendidas para una película:

CREATE TABLE tickets(
  id SERIAL PRIMARY KEY,
  movie_id INTEGER REFERENCES peliculas NOT NULL
);

INSERT INTO tickets(pelicula_id) VALUES (1), (1), (3);

La tabla tickets solo tiene un id y una referencia a la película: pelicula_id.

También hemos insertado dos boletos vendidos para la película ID 1, y un boleto vendido para la película ID 3.

¡Ahora, unamos losdirectorios a las peliculas—y luego peliculas a tickets!

SELECT *
FROM directorios
INNER JOIN peliculas
  ON peliculas.director_id = directors.id
INNER JOIN tickets
  ON tickets.pelicula_id = peliculas.id;

Dado que se trata de inner joins, el orden en que escribimos las combinaciones no importa. Podríamos haber comenzado con los tickets, luego combinar a las peliculas, y luego combinar a los directorios.

De nuevo, todo se reduce a lo que se está tratando de consultar y lo que hace que la consulta sea más comprensible.

En nuestro conjunto de resultados, notaremos que hemos reducido aún más las filas que se devuelven:

 id |    nombre    | id |  nombre   | director_id | id | pelicula_id
----+------------+----+---------+-------------+----+----------
  1 | John Smith |  1 | Pelicula 1 |           1 |  1 |        1
  1 | John Smith |  1 | Pelicula 1 |           1 |  2 |        1
  2 | Jane Doe   |  3 | Pelicula 3 |           2 |  3 |        3
(3 filas)

Esto tiene sentido porque hemos agregado otro INNER JOIN. En efecto, esto agrega otra condición "AND"a nuestra consulta.

Nuestra consulta esencialmente dice: "devuelve todos los directorios que pertenezcan a películas pero que también tienen tickets vendidos."

Si, en cambio, quisiéramos encontrar directorios que pertenezcan a películas que no hayan vendido tickest todavía, podríamos sustituir nuestro último INNER JOIN por un LEFT JOIN:

SELECT *
FROM directorios
JOIN peliculas
  ON peliculas.director_id = directorios.id
LEFT JOIN tickets
  ON tickets.pelicula_id = peliculas.id;

Podemos ver que la Pelicula 2 hora está de vuelta en el conjunto de resultados:

 id |    nombre    | id |  nombre   | director_id |  id  | pelicula_id
----+------------+----+---------+-------------+------+----------
  1 | John Smith |  1 | Pelicula 1 |           1 |    1 |        1
  1 | John Smith |  1 | Pelicula 1 |           1 |    2 |        1
  2 | Jane Doe   |  3 | Pelicula 3 |           2 |    3 |        3
  1 | John Smith |  2 | Pelicula 2 |           1 | NULL |     NULL
(4 filas)

Esta película no tuvo ninguna venta de boletos, por lo que anteriormente se excluyó del conjunto de resultados debido a INNER JOIN.

Dejaré esto como Ejercicio para el lector ™, pero ¿cómo encontraría directorios que pertenezcan a películas que no tienen venta de boletos?

Orden de ejecución de la combinación

Al final, realmente no nos importa en qué orden se ejecutan las combinaciones.

Una de las diferencias clave entre SQL y otros lenguajes de programación modernos es que SQL es un lenguaje declarativo.

Esto significa que especificamos el resultado que queremos, pero no especificamos los detalles de ejecución; esos detalles se dejan al planificador de consultas de la base de datos. Especificamos las combinaciones que queremos y las condiciones en ellas y el planificador de consultas se encarga del resto.

Pero, en realidad, la base de datos no une tres tablas al mismo tiempo. En su lugar, probablemente unirá las dos primeras tablas en un resultado intermedio y luego unirá ese conjunto de resultados intermedios a la tercera tabla.

(Nota: Esta es una explicación algo simplificada.)

Entonces, como estamos trabajando con múltiples joins en las consultas, podemos pensar en ellas como una serie de joins entre dos tablas, aunque una de esas tablas puede llegar a ser bastante grande.

Joins con condiciones extra

El último tema que cubriremos es un join con condiciones adicionales.

Similar a una cláusula WHERE, podemos agregar tantas condiciones como queramos a nuestras condiciones de join.

Por ejemplo, si quisiéramos encontrar películas con directorios que no se llamen "John Smith", podríamos agregar esa condición extra a nuestra join con un AND:

SELECT *
FROM peliculas
INNER JOIN directorios
  ON directors.id = peliculas.director_id
  AND directorios.name <> 'John Smith'

Podemos usar cualquier operador que pondríamos en una cláusula WHEREen esta condición de join.

También obtenemos el mismo resultado de esta consulta si colocamos la condición en una cláusula WHERE en su lugar:

SELECT *
FROM peliculas
INNER JOIN directorios
  ON directorios.id = peliculas.director_id
WHERE directorios.name <> 'John Smith';

Hay algunas diferencias sutiles que ocurren bajo el capó aquí, pero para el propósito de este artículo, el conjunto de resultados es el mismo.

(Si no está familiarizado con todas las formas en que puede filtrar una consulta SQL, consulte el artículo mencionado anteriormente aquí.)

La realidad acerca de escribir consultas con joins

En realidad, solo uso combinaciones de tres maneras diferentes:

INNER JOIN

El primer caso de uso son los registros donde existe la relación entre dos tablas. Esto lo cumple el INNER JOIN.

Estas son situaciones como encontrar "películas que tienen directorios" o "usuarios con publicaciones".

LEFT JOIN

El segundo caso de uso son los registros de una tabla —y si existe la relación—los registros de una segunda tabla. Esto lo cumple el LEFT JOIN.

Estas son situaciones como encontrar "películas con directorios si es que tienen uno" o "usuarios con publicaciones si tienen alguna."

LEFT JOIN exclusión

El tercer caso de uso más común es nuestro segundo caso de uso para un LEFT JOIN: encontrar registros en una tabla que no tienen una relación en la segunda tabla.

Estas son situaciones como "películas sin directorios" o "usuarios sin publicaciones."

Dos tipos de combinaciones o joins muy útiles

Creo que nunca he usado un FULL OUTER JOIN o un RIGHT JOIN en una aplicación de producción. El caso de uso simplemente no aparece con la frecuencia suficiente o la consulta se puede escribir de una manera más clara (en el caso de RIGHT JOIN).

Ocasionalmente, he usado un CROSS JOIN para cosas como distribuir registros en un rango de fechas (como lo miramos al principio), pero ese escenario tampoco aparece con demasiada frecuencia.

Entonces, ¡buenas noticias! En realidad, solo hay dos tipos de combinaciones que debe comprender para el 99,9 % de los casos de uso que encontraras: INNER JOIN y LEFT JOIN!

Si te gustó este artículo, me puedes seguir en Twitter donde hablo de base de datos y temas relacionados con el desarrollo.

¡Gracias por leer!

John

P.S. un consejo adicional por haber leido hasta el final: la mayoría de los sistemas de base de datos te permitiran escribir simplemente JOIN en lugar deINNER JOIN—lo que te ahorrará un poco de tipeo adicional. :)

SQL son las siglas en inglés para "Structured Query Language" (lenguaje de consulta estructurado). Se utiliza con todo tipo de bases de datos relacionales.

Ejemplo de sintaxis básica de SQL

Esta guía proporciona una descripción básica y de alto nivel de la sintaxis de las declaraciones SQL.

SQL es un estándar internacional (ISO) pero encontrarás muchas diferencias entre las implementaciones. Esta guía utiliza MySQL como ejemplo. Si utilizas uno de los muchos otros Gestores de Bases de Datos Relacionales (DBMS por sus siglas en inglés) tendrás que consultar el manual de ese DBMS si es necesario.

Lo que cubriremos

• Uso (establece qué base de datos utilizarán las instrucciones)
• Cláusulas Select y From
• Cláusula Where (and/or, IN, Between, LIKE)
• Order by (ASC, DESC)
• Group by y Having

Cómo se utiliza

Se utiliza para seleccionar la base de datos que contiene las tablas para tus declaraciones SQL:

use fcc_sql_guides_database; --selecciona la base de datos de muestras guía

Cláusulas Select y From

La cláusula Select se utiliza normalmente para determinar qué columnas de los datos se quieren mostrar en los resultados. También hay opciones que puedes usar para mostrar datos que no son una columna de la tabla.

Este ejemplo muestra dos columnas seleccionadas de la tabla "student", y dos columnas calculadas. La primera de las columnas calculadas es un número sin sentido, y la otra es la fecha del sistema.

SELECT studentID, FullName, 3+2 as five, now() as currentDate
FROM student;

Cláusula Where (and / or, IN, Between y LIKE)

La cláusula Where se utiliza para limitar el número de filas devueltas.

En este caso se utilizarán las cinco condiciones en un ejemplo un tanto ridículo de la cláusula Where.

Compara este resultado con las declaraciones SQL anteriores para seguir esta lógica.

Se mostrarán las filas que:

• Tengan el ID del estudiante (studentID) entre 1 y 5 (inclusivo)
• o studentID = 8
• o tengan "Maximo" en el nombre

El siguiente ejemplo es similar, pero especifica además que si alguno de los estudiantes tiene determinadas puntuaciones de SAT (1000, 1400), no se mostrarán:

SELECT studentID, FullName, sat_score, recordUpdated
FROM student
WHERE (
	studentID between 1 and 5
    	or studentID = 8
    	or FullName like '%Maximo%'
    	)
    	and sat_score NOT in (1000,1400);

Order By (ASC, DESC)

Order By (ordenar por) nos da la opción de ordenar los datos resultantes por uno o más elementos de la sección SELECT. Aquí está la misma lista de arriba, pero ordenada por el nombre completo (FullName) de los estudiantes. El orden por defecto es ascendente (ASC), pero para ordenar en el orden opuesto (descendente) se utiliza DESC, como en el ejemplo siguiente:

SELECT studentID, FullName, sat_score
FROM student
WHERE (studentID between 1 and 5 -- inclusive
	or studentID = 8
    or FullName like '%Maximo%'
    and sat_score NOT in (1000, 1400)
  order by FullName DESC;

Group By y Having

Group By (agrupar) nos da una forma de combinar filas y agregar datos. La cláusula Having es como la cláusla Where anterior, excepto que actúa sobre los datos agrupados.

Estos datos provienen de los datos de las contribuciones a la campaña que hemos estado utilizando en algunas de estas guías.

Esta declaración de SQL responde a la pregunta: "¿qué candidatos recibieron el mayor número de contribuciones (no la cantidad de dólares, sino el recuento (*)) en 2016, pero sólo los que tuvieron más de 80 contribuciones?"

Al ordenar estos datos en orden descendente (DESC), los candidatos con el mayor número de contribuciones se sitúan al principio de la lista.

SELECT Candidate, Election_year, sum(Total_$), count(*)
FROM combined_party_data
WHERE Election_year = 2016
GROUP BY Candidate, Election_year
	having count(*) > 80
    order by count(*) DESC;

Como con todas estas cosas de SQL, hay MUCHO MÁS de lo que encuentras en esta guía introductoria. Espero que esto al menos te dé lo suficiente para empezar. Por favor, consulta el manual de tu gestor de base de datos y diviértete probando diferentes opciones por ti mismo.

Preguntas comunes sobre SQL en las entrevistas

¿Qué es un inner join en SQL?

Es el tipo de unión por defecto si no se especifica ninguna unión. Devuelve todas las filas en las que hay al menos una coincidencia en ambas tablas.

SELECT * FROM A x JOIN B y ON y.aId = x.Id

¿Qué es un left join en SQL?

Un left join devuelve todas las filas de la tabla a la izquierda (LEFT) y las filas coincidentes de la tabla a la derecha (RIGHT). Las filas de la tabla a la izquierda se devolverán aunque no haya una coincidencia en la tabla a la dercha. Las filas de la tabla a la izquierda sin coincidencias en la tabla derecha tendrán valores nulos (null) para la tabla a la derecha.

SELECT * FROM A x LEFT JOIN B y ON y.aId = x.Id

¿Qué es un right join en SQL?

Un right join devuelve todas las filas de la tabla a la derecha, y las filas coincidentes de la tabla a la izquierda. Contrario al left join, este devuelve todas las filas de la tabla a la derecha incluso cuando no haya ninguna coincidencia en la tabla izquierdo. Las filas de la tabla derecho que no tengan coincidencias en la tabla izquierdo tendrán valores null para las columnas de la tabla izquierdo.

SELECT * FROM A x RIGHT JOIN B y ON y.aId = x.Id

¿Qué es un full join en SQL?

Un full join devuelve todas las filas en donde hay una coincidencia en cualquiera de las tablas. Es decir, si hay filas en la tabla izquierdo que no tienen coincidencias en la tabla derecho, se incluirán. Así como si hay filas en la tabla derecho que no tienen coincidencias en la tabla izquierdo, también se incluirán.

SELECT Customers.CustomerName, Orders.OrderID
FROM Customers
FULL OUTER JOIN Orders
ON Customers.CustomerID = Orders.CustomerID
ORDER BY Customers.CustomerName

¿Cuál es el resultado del siguiente comando?

DROP VIEW view_name

Aquí se producirá un error porque no podemos realizar una operación DML en una vista.

¿Se puede realizar un rollback después de utilizar el comando ALTER?

No, porque ALTER es un comando DDL y el servidor Oracle realiza un COMMIT automático cuando se ejecutan las declaraciones DDL.

¿Cuál es la única restricción que aplica reglas a nivel de columna?

NOT NULL es la única restricción que funciona a nivel de columna.

¿Cuáles son las pseudo-columnas en SQL? Da algunos ejemplos.

Una pseudo-columna es una función que devuelve un valor generado por el sistema. La razón por la que se conoce así es porque una pseudo-columna es un valor asignado por Oracle que se utiliza en el mismo contexto que una columna de la base de datos Oracle, pero que no se almacena en el disco.

ROWNUM, ROWID, USER, CURRVAL, NEXTVAL etc

Crea un usuario my723acct con contraseña kmd26pt. Utiliza los tablespaces de datos de usuario y datos temporales proporcionados por PO8 y proporciona a este usuario 10M de espacio de almacenamiento en datos de usuario (user_data) y 5M de espacio de almacenamiento en datos temporales (temporary_data).

CREATE USER my723acct IDENTIFIED BY kmd26pt
DEFAULT TABLESPACE user_data
TEMPORARY TABLESPACE temporary_data
QUOTA 10M on user_data QUOTA 5M on temporary_data

Cree el ROLE role_tables_and_views

CREATE ROLE role_tables_and_views

Concede al rol de la pregunta anterior los privilegios para conectarse a la base de datos y los privilegios para crear tablas y vistas.

El privilegio para conectarse a la base de datos es CREATE SESSION. El privilegio para crear una tabla es CREATE TABLE. El privilegio para crear una vista es CREATE VIEW.

GRANT Create session, create table, create view TO role_tables_and_views

Concede el ROLE de la pregunta anterior a los usuarios anny y rita

GRANT role_tables_and_views TO anny, rita

Escribe un comando para cambiar la contraseña del usuario rita de abcd a dfgh

ALTER USER rita IDENTIFIED BY dfgh

Los usuarios rita y anny no tienen privilegios SELECT en la tabla de inventario (INVENTORY) que fue creado por SCOTT. Escribe un comando para permitir que SCOTT le conceda a los usuarios privilegios SELECT en estas tablas.

GRANT select ON inventory TO rita, anny

El usuario rita ha sido transferida y ya no necesita el privilegio que se le concedió a través del ROLE role_tables_and_views. Escribe un comando para quitarle los privilegios que se le habían otorgado anteriormente, excepto que aún pueda conectarse a la base de datos.

REVOKE select ON scott.inventory FROM rita
REVOKE create table, create view FROM rita

El usuario rita, que había sido transferida, ahora se traslada a otra empresa. Dado que los objetos que creó ya no son útiles, escriba un comando para eliminar este usuario y todos sus objetos.

Aquí la opción CASCADE es necesaria para eliminar todos los objetos del usuario en la base de datos.

DROP USER rita CASCADE

Escribe una consulta SQL para encontrar el enésimo salario más alto de la tabla

SELECT TOP 1 Salary
FROM (
	SELECT DISTINCT TOP N Salary
    FROM Employee
    ORDER BY Salary DESC
    )
ORDER BY Salary ASC

Declaracion SQL Create View

¿Qué es una View (Vista)?

Una Vista es un objeto de la base de datos que presenta los datos existentes en uno o más tablas. Las Vistas se utilizan de manera similar a las tablas, pero no contienen ningún dato. Sólo "apuntan" a los datos que existen en otra parte (tablas o vistas, por ejemplo).

¿Por qué nos gustan?

• Vistas son una forma de limitar los datos presentados. Por ejemplo, los datos del departamento de recursos humanos filtrados para presentar sólo información no sensible. Información sensible en este caso podrían ser números de seguridad social, el sexo del empleado, tasa de pago, dirección de domicilio, etc.
• Los datos complejos de más de una tabla pueden combinarse en una única "Vista". Esto puede facilitar la vida a sus analistas de negocio y programadores.

Consejos de seguridad importantes

• Las Vistas son gestionadas por el sistema. Cuando los datos en las tablas relacionados se modifican, añaden o actualizan, la Vista es actualizada por el sistema. Queremos utilizarlas sólo cuando sea necesario gestionar el uso de los recursos del sistema.
• En MySQL, cambios en el diseño de una tabla (es decir, columnas nuevas o eliminadas) realizados DESPUÉS de la creación de una Vista no se actualizan en la propia Vista. La Vista tendría que ser actualizada o recreada.
• Las Vistas son uno de los cuatro tipos de objetos estándar de las bases de datos. Los otros son las tablas, procedimientos almacenados y funciones.
• Las Vistas usualmente pueden ser tratadas como una tabla, pero las actualizaciones están limitadas o no están disponibles cuando la Vista contiene más de una tabla.
• Hay muchos otros detalles sobre las Vistas que están fuera del alcance de esta guía introductoria. Dedique tiempo al manual de su gestor de base de datos y diviértase con este poderoso objeto SQL.

Sintaxis de la declaración Create View (MySQL)

CREATE
	[OR REPLACE]
    [ALGORITHM = {UNDEFINED | MERGE | TEMPTABLE}]
    [DEFINER = {user | CURRENT_USER}]
    [SQL SECURITY {DESINGER | INVOKER}]
    VIEW view_name[(column_list)]
    AS select_statement
    [WITH [CASCADED | LOCAL] CHECK OPTION]

Esta guia cubrirá esta parte de la declaración:

CREATE
	VIEW view_name[(column_list)]
    AS select_statement

Ejemplo de creacion de una Vista (View) a partir de las tablas de estudiantes (student)

Notas:

• El nombre de la Vista tiene una "v" al final. Se recomienda que el nombre de la Vista indique que es una vista de alguna manera para facilitar la vida a los programadores y administradores de la base de datos. Tu tienda de informática debe tener sus propias reglas para nombrar los objetos.
• Las columnas de la Vista están limitadas por la cláusula SELECT y las filas de datos por la cláusula WHERE.
• El carácter "`" alrededor de los nombres de las Vistas es necesario debido al "-" en los nombres. MySQL informa de un error sin ellos.

create view `programming-students-v` as
SELECT FullName, programOfStudy
FROM student
WHERE programOfStudy = 'Programming';


SELECT * FROM `programming-students-v`; 

Ejemplo de uso de una Vista para combinar datos de más de una tabla

Se ha agregado una tabla demográfico de estudiantes a la base de datos para demostrar este uso. Esta Vista combinará estas tablas.

Notas:

• Para "unir" tablas, las tablas deben tener campos en común (normalmente claves primarias) que identifiquen de forma única cada fila. En este caso es el ID del estudiante.
• Fíjese en el "alias" dado a cada tabla ("s" para estudiante y "sc" para contacto con el estudiante). Se trata de una herramienta para acortar los nombres de las tablas y facilitar la identificación de la tabla que se está utilizando. Es más fácil que escribir repetidamente nombres de tablas largas. En este ejemplo, era necesario porque studentID es el mismo nombre de columna en ambas tablas, y el sistema presentaría un "error de nombre de columna ambiguo" sin especificar qué tabla utilizar.

Guía del operador Between

El operador BETWEEN es útil gracias al Optimizador de Consultas SQL (SQL Query Optimizer). Aunque BETWEEN es funcionalmente lo mismo que: x <= element <= y, el Oprimizador de Consultas reconocerá este comando más rápidamente, y ha optimizado el código para ejecutarlo.

Este operador se usa en una cláusula WHERE o en una cláusula GROUP BY HAVING.

Se seleccionan las filas que tienen un valor mayor que el valor mínimo y menos que el valor máximo.

Es importante tener en cuenta que los valores introducidos en el comando se excluyen del resultado. Obtenemos sólo lo que está entre ellos.

Esta es la sintaxis para utilizar la función en una cláusula WHERE:

SELECT field1, testfield
FROM table1
WHERE testField BETWEEN min and max

Y aquí un ejemplo utilizando la tabla de estudiantes y la cláusula WHERE:

-- sin clausula WHERE
SELECT studentID, FullName, studentID
FROM student;

-- clausula WHERE con BETWEEN
SELECT studentID, FullName, studentID
FROM student
WHERE studentID between 2 and 7;

Aquí hay un ejemplo usando la tabla de fondos de campaña y la cláusula HAVING. Esto devolverá las filas en las que la suma de las donaciones de un candidato esté entre 3 y 18 millones de dólares, basándose en la cláusula HAVING en la parte GROUP BY de la declaración. Más información sobre la agregación en esa guía.

SELECT Candidate, Office_Sought, Election_Year, format(sum(TOTAL_$),2)
FROM combined_party_data
WHERE Election_Year = 2016
GROUP BY Candidate, Office_Sought, Election_Year
HAVING sum(Total_$) BETWEEN 3000000 and 18000000
ORDER BY sum(Total_$) DESC;

Una tabla es un grupo de datos almacenados en una base de datos.

Para crear una tabla en una base de datos se utiliza la declaración CREATE TABLE. Se le da un nombre a la tabla y una lista de columnas con sus tipos de datos.

CREATE TABLE TABLENAME(Attribute1 Datatype, Attribute2 Datatype, ...);

Aquí hay un ejemplo de creación de una tabla llamado Persona:

CREATE TABLE Persona(
	Id int not null,
    Name varchar not null,
    DateOfBirth date not null,
    Gender bit not null,
    PRIMARY KEY(Id)
);

En el ejemplo anterior, cada Persona tiene un Nombre (Name), fecha de nacimiento (DateOfBirth), y género (Gender). La columna Id es la clave que identifica a una persona en la tabla. Se utiliza la palabra clave PRIMARY KEY para configurar una o más columnas como claves primarias.

Una columna puede ser not null o null indicando si es obligatoria o no.

Las consultas de inserción son una forma de insertar datos en una tabla. Digamos que hemos creado una tabla utilizando:

CREATE TABLE tabla_ejemplo(nombre varchar(255), edad int)

tabla_ejemplo

Nombre | Edad
  ---  |  ---

Ahora para agregar algunos datos a esta tabla, utilizaremos INSERT de la siguiente manera:

INSERT INTO tabla_ejemplo(column1, column2) VALUES ("Andrew",23)

tabla_ejemplo

Nombre | Edad
  ---  | ---
Andrew | 23

Incluso lo siguiente funciona, pero siempre es una buena práctica especificar qué datos van en cada columna.

INSERT INTO tabla_nombre VALUES("John",28)

tabla_ejemplo

Nombre | Edad
  ---  | ---
Andrew | 23
John   | 28

AND se utiliza en una cláusula WHERE o en una cláusula GROUP BY HAVING para limitar las filas devueltas por la declaración ejecutada. Se utiliza AND cuando se requiera que se cumpla más de una condición.

Utilizremos la tabla de estudiantes para presentar ejemplos.

Aquí está la tabla de estudiantes sin una cláusula WHERE:

SELECT * FROM student;

Ahora se añade la cláusula WHERE para mostrar sólo los alumnos de programación:

SELECT * 
FROM student
WHERE programsOfStudy = 'Programming';

Ahora la clausula WHERE se actualiza con AND para mostrar los resultados de los estudiantes de programación que también tienen una puntuación SAT superior a 800:

SELECT *
FROM student
WHERE programOfStudy = 'Programming'
AND sat_score > 800;

Este es un ejemplo más complejo de la tabla de contribuciones de campaña. Este ejemplo tiene una cláusula GROUP BY con una cláusula HAVING que utiliza un AND para restringir los registros devueltos a los candidatos de 2016 con contribuciones entre 3 y 18 millones de dólares en total.

SELECT Candidate, Office_Sought, Election_Year, FORMAT(sum(Total_$),2)
FROM combined_party_data
WHERE Office_sought = 'PRESIDENT / VICE PRESIDENT'
GROUP BY Candidate, Office_Sought, Election_Year
HAVING Election_Year = 2016 AND sum(Total_$) BETWEEN 3000000 and 18000000
ORDER BY sum(Total_$) DESC;

Cómo utilizar ORDER BY en SQL

Order By (ASC, DESC)

ORDER BY nos da una forma de ordenar el conjunto de resultados por uno o más elementos de la sección SELECT. A continuación se muestra un SQL que ordena a los estudiantes por nombre (FullName) en orden descendente. El orden por defecto es ascendente (ASC) por lo que para ordenar en el orden contrario se utiliza DESC.

SELECT studentId, FullName, sat_score
FROM student
ORDER BY FullName DESC;

+-----------+------------------------+-----------+
| studentID | FullName               | sat_score |
+-----------+------------------------+-----------+
|         2 | Teri Gutierrez         |       800 |
|         3 | Spencer Pautier        |      1000 |
|         6 | Sophie Freeman         |      1200 |
|         9 | Raymond F. Boyce       |      2400 |
|         1 | Monique Davis          |       400 |
|         4 | Louis Ramsey           |      1200 |
|         7 | Edgar Frank "Ted" Codd |      2400 |
|         8 | Donald D. Chamberlin   |      2400 |
|         5 | Alvin Greene           |      1200 |
+-----------+------------------------+-----------+
9 rows in set (0.00 sec)

Aquí está la lista de estudiantes actual, no ordenada, para compararla con la anterior:

SELECT studentID, FullName, sat_score, rcd_updated
FROM student;

+-----------+------------------------+-----------+---------------------+
| studentID | FullName               | sat_score | rcd_updated         |
+-----------+------------------------+-----------+---------------------+
|         1 | Monique Davis          |       400 | 2017-08-16 15:34:50 |
|         2 | Teri Gutierrez         |       800 | 2017-08-16 15:34:50 |
|         3 | Spencer Pautier        |      1000 | 2017-08-16 15:34:50 |
|         4 | Louis Ramsey           |      1200 | 2017-08-16 15:34:50 |
|         5 | Alvin Greene           |      1200 | 2017-08-16 15:34:50 |
|         6 | Sophie Freeman         |      1200 | 2017-08-16 15:34:50 |
|         7 | Edgar Frank "Ted" Codd |      2400 | 2017-08-16 15:35:33 |
|         8 | Donald D. Chamberlin   |      2400 | 2017-08-16 15:35:33 |
|         9 | Raymond F. Boyce       |      2400 | 2017-08-16 15:35:33 |
+-----------+------------------------+-----------+---------------------+
9 rows in set (0.00 sec)

Como con todas estas cosas de SQL, hay mucho más de lo que hay en esta guía introductoria.

Espero que esto al menos te dé lo suficiente para empezar.

Por favor, consulta el manual de tu gestor de base de datos y diviértete probando diferentes opciones por ti mismo.

Podrías pensar que una herramienta tan "vieja" tienes sus mejores días detrás de ella, pero estarías lejos de estar en lo cierto. En 2019, a través de la encuesta de Scale Grid DeveloperWeek, SQL fue utilizado por el 60.5% de los encuestados, mientras que NoSQL fue utilizado por solo el 39.5% de los encuestados.

Para ser claros, la categoría SQL se dividió en varias subcategorías que incluían MySQL, PostgreSQL, SQL Server, etc., mientras que la categoría NoSQL se dividió en subcategorías que contenían MongoDB, Cassandra, etc.

Incluso en 2017, según la Stack Overflow Developer's Survey, el segundo lenguaje más utilizado fue SQL (justo detrás de JavaScript) con el 50% de los 64,000 encuestados diciendo que todavía utilizan SQL en alguna forma.

Su popularidad se debe, al menos en parte, a la simplicidad del lenguaje, al hecho de que fue construido con datos relacionales en mente, y porque ha demostrado ser fiable para buscar, unir y filtrar datos.

Basta con decir que SQL no sólo está vivito y coleando, sino que prospera entre la comunidad de desarrollo de hoy en día.

¡Ahora vamos a ver por qué!

Las partes divertidas

SQL Server es el sabor preferido de SQL que utilizo en mis actividades cotidianas en el trabajo, por lo que los ejemplos siguientes se ajustarán a esas normas.

Una de las cosas que más me gusta hacer es actualizar varios registros dentro de una tabla. Ahora podría hacer este registro de uno en uno, pero SQL nos da la capacidad de actualizar múltiples (miles y miles si es necesario) registros a la vez a través de la declaración UPDATE.

La declaración UPDATE puede utilizarse para actualizar una sola columna, un conjunto más amplio de registros (mediante el uso de condiciones), y/o toda la tabla en una base de datos. La(s) condición(es) puede(n) ser un booleano, una verificación de cadena de texto o una secuencia matemática que se resuelve en un booleano (mayor que, menos que, etc.).

Aunque puede variar ligeramente de un sabor a otro, la sintaxis general es la siguiente:

UPDATE nombre-de-la-tabla
SET nombre-de-la-columna = valor[, nombre-de-la-columna=valor]
[WHERE condición]

Los corchetes ( [] ) de arriba denotan adiciones opcionales a la consulta.

***Es muy importante tener en cuenta que sin la condición de WHERE, TODOS los registros de la tabla se actualizarán tan pronto como se ejecute la consulta.***

Consultas de ejemplo

Como nuestro conjunto de datos, usaré esta tabla llamada Work_Tickets:

Consulta simple sin condiciones

Aquí hay una consulta de actualización muy simple que cambiará todos los campos de UnitCost al número 131.6152:

UPDATE Work_Tickets
SET UnitCost = 131.6152

Nota que no hay cláusula de WHERE, así que cada línea de la tabla se actualizará y nuestro conjunto de datos se verá así:

Consultas simples con condición(es)

Aquí hay una simple consulta con una declaración de condición:

UPDATE Work_Tickets
SET Billed = true
WHERE UnitCost <> 0.00

Esta consulta actualizará el campo de Billed para que sea true en cada línea que coincida con la condición de UnitCost no igual a 0. Después de ejecutar nuestra consulta, el conjunto de datos se verá así:

Abajo hay una consulta en la que cambiamos el ParentLineKey por la cadena 000134 en la que el SalesOrderNum y el WorkTicketNum coinciden con las cadenas dadas.

UPDATE Work_Tickets
SET ParentLineKey = 000134
WHERE SalesOrderNum = 00061358 and WorkTicketNumber = 000933

Así que, el 085569 en el campo ParentLineKey será reemplazado por 000134 y nuestro conjunto de datos ahora se ve así:

Actualizando múltiples campos

Digamos que tienes un conjunto de datos mucho más grande que el que estamos usando actualmente y tienes varios campos para actualizar.

Sería tedioso y aburrido actualizarlos con diferentes declaraciones de actualización. Por suerte para nosotros también es posible actualizar varios campos a la vez con una declaración de actualización (update), siempre y cuando separemos los nombres de las columnas con una coma:

UPDATE Work_Tickets
SET UnitCost = 129.8511, Qty_Ordered = 72, Qty_Shipped = 72
WHERE SalesOrderNum = 00061358

Y aquí está el resultado con los campos actualizados después de ejecutar la consulta:

Usando Update en una subconsulta

Los ejemplos anteriores son perfectos si se trabaja con una sola fuente de datos. Sin embargo, la mayoría de tus datos no se almacenarán en una sola tabla. Ahí es donde el uso de UPDATE con múltiples fuentes de datos es útil.

La sintaxis para actualizar una columna/tabla cambia un poco si queremos traer datos de otra tabla:

UPDATE nombre-de-la-tabla
SET nombre-de-la-columna = (SELECT nombre de columna(s)
FROM nombre-de-la-tabla2
WHERE condición(es))
[WHERE condición]

Y aquí están las dos tablas que usaremos para esta consulta - la tabla Work_Tickets:

y la tabla Customer_Info:

La declaración UPDATE con la subconsulta se ve así:

UPDATE Customer_Info
SET Code = (SELECT Customer_Code
FROM Work_Tickets
WHERE Work_Tickets.Customer_Contact = Customer_Info.Email)
FROM Work_Tickets
WHERE Code IS NULL

Este ejemplo actualizará el campo Code de la tabla Customer_Info donde la dirección de correo electrónico coincide con la de ambas tablas. Y así es como se ve ahora nuestra tabla Customer_Info:

Concluyendo

Espero que este artículo te haya sido útil para entender cómo funciona la declaración UPDATE en SQL.

¡Ahora estás listo para escribir tus propias sentencias SQL UPDATE como un campeón! ¡Después de hacerlo, me encantará que lo compartieras conmigo en redes sociales!

No olvides visitar mi blog donde frecuentemente publico artículos sobre desarrollo web.

Ya que estás allí, ¿por qué no te inscribes en mi boletín de noticias? Puedes hacerlo en la parte superior derecha de la página principal del blog. Me gusta enviar artículos interesantes (míos y de otros), recursos y herramientas para desarrolladores de vez en cuando.

Si tienes preguntas sobre este artículo o en general, mis MDs están abiertos - ven a saludar en Twitter o en cualquiera de mis otras cuentas de redes sociales que puedes encontrar debajo del botón de suscripción del boletín de noticias en la página principal de mi blog o en mi perfil aquí en fCC :)

¡Qué tengas un día increíble y feliz día programando, amigo!

Traducido del artículo de Jonathan Sexton - SQL Update Statement — Example Queries for Updating Table Values

Si quisieras algo de historia del lenguaje, así como algunos echos interesantes, puedes leer la parte de la introducción del artículo SQL Update Statement article.

En este artículo, recorreremos las partes más importantes de la creación de una tabla en SQL. Mi "sabor" preferido de SQL es SQL Server, pero la información acerca de la creación de tablas es algo ubicua entre todas las variaciones de SQL.

Si nunca antes usaste SQL o no sabes lo que es una tabla, ¡no temas! En resumen, una tabla es un objeto de una base de datos que almacena o contiene los datos dentro de esa porción de la base de datos. Almacena los datos dentro de columnas nombradas y renglones numerados, la cual te será familiar si has utilizado programas de hojas de cálculo. Cada renglón representa un registro de la base de datos completa.

Si los datos fueran cajas, una tabla sería una sección de los estantes de la bodega donde almacenamos las cajas.

Estoy simplificando la explicación bastante, y hay mucha más información sobre las tablas SQL, pero eso está fuera del alcance de este artículo. Si estas ansioso por más información sobre tablas, te recomiendo profundizar en la documentación de Microsoft Database Design.

Antes de aprender cómo crear una tabla, es importante aprender cuales son los tipos de datos que pueden almacenar las columnas.

Tipos de Datos

Las tablas SQL pueden almacenar texto, números, combinaciones de texto y números, así como imágenes y enlaces.

Cuando se crea una tabla, nosotros designamos el tipo de dato que almacenarán los renglones y columnas. A continuación, la clasificación de datos:

• Numéricos Aproximados
• Cadenas
• Fecha y Hora
• Cadenas de Texto Unicode
• Numéricos Exactos
• Otros

A continuación, enumeraré algunos de los tipos de datos más comunes abajo.

Aquí tienes los tipos de datos más comúnmente usados de acuerdo a mi experiencia, sin ningún orden particular:

• char(tamaño) - cadena de tamaño fijo que puede contener letras, números, caracteres especiales
• varchar(tamaño) - cadena de tamaño variable que puede contener letras, números, y caracteres especiales
• boolean - Cero (o valores que son igual a 0) es falso, no-cero es verdadero
• int(tamaño opcional) - un número de hasta 10 caracteres en longitud, acepta números negativos y positivos
• bigint(tamaño opcional) - un numero de hasta 19 caracteres en longitud, acepta números negativos y positivos.
• float(tamaño, d) - un número donde el tamaño total del número es representado por el tamaño y la cantidad de caracteres después del punto decimal representado por una d
• date - fecha en el formato YYYY-MM-DD
• datetime - fecha y hora en el formato YYYY-MM-DD hh:mm:ss
• time - tiempo en el formato hh:mm:ss

Bien, ahora que sabemos que tipos de datos pueden contener los renglones y las columnas, ¡vamos a la parte divertida!

Creando una Tabla

Antes de que iniciemos, es importante anotar que estaré proporcionando todos mis ejemplos independientes de cualquier programa.

Sin embargo, si quieres iniciar a escribir consultas y no estás seguro de cómo empezar, echa un vistazo al SQL Server Management Studio. Es gratis, un programa robusto ampliamente usado y soportado por la comunidad.

Alternativamente, hay muchas opciones incluyendo DB Fiddle que te permite construir esquemas y escribir consultas directamente en tu navegador.

Empezaremos con una declaración simple para crear una tabla básica:

CREATE TABLE table_name ( column1_name datatype, column2_name datatype, column3_name datatype, column4_name datatype, column5_name datatype,)

Hay otros parámetros que podemos adicionar después de datatype para aumentar las columnas:

• NOT NULL - pasando este parámetro asegurará que la columna no almacene un valor NULL
• UNIQUE - pasando este parámetro va a prevenir que la columna almacene el mismo valor más de una vez
• UNIQUE KEY - pasando este parámetro designará la columna como identificador único. Esencialmente, es una combinación de los dos parámetros anteriores.

Ahora, vamos a crear una tabla (nombrada doggo_info, la cual debe adherirse a los identificadores estándar para bases de datos) para almacenar información sobre los residentes de Woof Woff Retreat, un estancia para perros de ficción que se me acaba de ocurrir :)

CREATE TABLE doggo_info ( ID int UNIQUE KEY, Name varchar(50) NOT NULL, Color varchar(50), Breed varchar(50), Age int, Weight int, Height int, Fav_Food varchar(100), Fav_Toy varchar(100), Dislikes varchar(500), Allergies varchar(500) NOT NULL )	

Y aquí esta nuestra nueva tabla que acabamos de crear:

‌Notarás que nuestra tabla está completamente vacía y esto es porque no le hemos añadido ningún dato aún. Adicionar datos esta más allá del enfoque de este artículo, pero quería que estuvieras al tanto de esa parte.

Crear una Tabla desde una Tabla Existente

También es posible crear una tabla basándonos en otra tabla preexistente.

Es muy fácil y no requiere mucha sintaxis adicional. Necesitamos seleccionar la tabla y las columnas desde donde copiar:

CREATE TABLE new_table_name AS SELECT column1, column2, column3, column4 (usar * para seleccionar todas las columnas para ser adicionadas a la tabla nueva) FROM current_table_name WHERE conditions_exist

Entonces, convenientemente, he adicionado algunos datos a nuestra tabla doggo_info y ahora se ve como el ejemplo de abajo:

Ahora podemos crear otra tabla basada en los datos que tenemos en nuestra tabla doggo_info ejecutando la consulta siguiente:

CREATE TABLE puppies_only AS SELECT * FROM doggo_info WHERE Age < 4

Queremos crear una tabla nueva con todas las columnas de la tabla doggo_info pero solo donde las edades son menos de 4. Después de ejecutar esta consulta, nuestra nueva tabla se verá como sigue:

Espero que puedas ver que tan poderosa puede ser esta declaración.  Con unas cuantas líneas en nuestra consulta, esencialmente hemos copiado los datos de una tabla a otra, pero solo los renglones que queríamos.

Esto no solo es una herramienta práctica para tener en tu cinturón de herramientas de desarrollador - esto te ahorrará cantidad de tiempo incalculable cuando necesites mover datos entre tablas.

Resumiendo

Ahora que sabes como crear (o copiar) una tabla en SQL, sin importar la situación que se te presente, ¡puedes ahora iniciar a llenar de datos las columnas y renglones para almacenar!

La declaración CREATE TABLE es extremadamente útil y poderosa. Tu estas listo para darle buen uso.

Si este artículo te sirve, revisa el blog (de Jonathan Sexton) donde frecuentemente publica artículos sobre desarrollo web, la vida y aprendizaje.

Cuando estés ahí, porque no registrarse al boletín. Puedes hacer eso en la parte superior derecha de la página principal del blog. Le gusta enviar artículos interesantes (De Jonathan y de otros), recursos, y herramientas para desarrolladores de vez en cuando.

Si tienes preguntas sobre este artículo, o solo en genera, déjamelo saber - ven a saludar en Twitter o cualquiera de las otras redes sociales que puedes encontrar abajo el el perfil de FCC :)

¡Ten un excelente día! ¡Feliz aprendizaje y feliz programación, amigo!

Traducido del artículo de Jonathan Sexton - SQL Create Table Statement - With Example Syntax