La sostenibilidad en los negocios es difícil sin una gestión de datos adecuada. Construir un sistema bien definido es esencial para gestionar las operaciones internas y externas. Una visión detallada de los datos comerciales ayuda a comprender el flujo de trabajo general y a medir el rendimiento. Además, el uso de bases de datos ahorra tiempo y permite acceder a la información sin esfuerzo.
¿Qué es una base de datos?
Una base de datos es un sistema organizado que se utiliza para almacenar información de forma segura. Ofrece categorización y permite la creación de tablas para ordenar tipos similares de elementos bajo un mismo grupo. Las tablas proporcionan opciones para listar información en múltiples filas y columnas. Como resultado, la calidad y la coherencia de los datos mejoran. Además del almacenamiento y las capacidades de fácil acceso, las bases de datos desempeñan un papel importante en la protección de la privacidad y la seguridad de los sistemas. Ya sea de forma ad hoc o como parte de un proceso codificado en una aplicación, la recuperación de datos es uno de los aspectos más críticos de la gestión de bases de datos.
Una consulta en un DMS relacional es cualquier comando utilizado para recuperar datos de una tabla. SELECT se utilizan casi siempre en las consultas de Lenguaje de Consulta Estructurado (SQL). Existen varios métodos para recuperar información de una base de datos. Generalmente, los desarrolladores prefieren la opción de la línea de comandos porque es rápida y eficaz. Permite enviar consultas sin problemas.
En esta guía, le presentaremos MySQL y analizaremos cómo trabajar con consultas en MySQL. ¡Empecemos!
Requisitos previos
Para seguir este tutorial, necesitará lo siguiente:
-
La última versión de Ubuntu está instalada en su sistema.
-
Los usuarios del sistema deben tener privilegios de sudo.
-
Si tiene dificultades para acceder a su cuenta sudo, considere cambiar la contraseña de root de MySQL.
-
-
MySQL está configurado en su servidor.
Paso 1 — Crear y configurar una base de datos
Antes de comenzar y escribir nuestra primera consulta SQL, necesitamos crear una base de datos y agregarle tablas. Después de eso, poblaremos las tablas utilizando datos de muestra. Trabajar con bases de datos le ayudará a comprender la configuración básica y le dará confianza para trabajar con consultas.
La experiencia práctica es la forma más eficaz de desarrollar conceptos y comprender la importancia de las bases de datos. En esta guía, le guiaremos a través del uso de las bases de datos y su importancia para resolver problemas del mundo real. Veamos un escenario para comprender cómo las bases de datos pueden ayudar a organizar los registros de manera estructurada.
Escenario: Crearemos una base de datos donde un grupo de estudiantes universitarios se va de vacaciones para celebrar sus cumpleaños. Antes de irse de vacaciones, planean participar en una competencia amistosa de natación. Además, cada amigo del grupo planea una lista de tareas pendientes para que su viaje sea emocionante y agradable.
Primero, abra MySQL como usuario root:
|
1 |
$ sudo mysql |
Luego, cree una base de datos ejecutando el siguiente comando:
|
1 2 3 |
mysql> CREATE DATABASE `vacation`; Query OK, 1 row affected (0.52 sec) |
Next, let’s use our database using the following command:
|
1 |
mysql> USE vacation; |
After that, we will create tables on our database. Name the first table as celebration. Our table will have columns for the names of our friends (name), the tournaments they have won (wins) and also a column for their mejor tiempo (time):
|
1 2 3 4 5 6 7 |
mysql> CREATE TABLE celebration ( -> name varchar(50), -> wins real, -> time real -> ); Query OK, 0 rows affected (2.03 sec) |
Luego poblaremos nuestra tabla con datos:
|
1 2 3 4 5 6 7 8 9 |
mysql> INSERT INTO celebration (name, wins, time) VALUES('Austin', '4', '15.5'), ('Ivan','7','9'), ('Aisha','10','5'), ('Zane','13','7.5'); Query OK, 4 rows affected (0.29 sec) Records: 4 Duplicates: 0 Warnings: 0 |
Luego, cree otra tabla dentro de nuestra base de datos para almacenar información sobre sus actividades de cumpleaños favoritas. Crearemos una tabla llamada vacation y tendrá las siguientes columnas:
|
Lista |
Detalle |
|
name: |
Almacena el nombre de cada amigo. |
|
birthdate: |
Realiza un seguimiento de la fecha de nacimiento de cada individuo. |
|
activity: |
Mantiene un registro de su actividad favorita. |
|
Destino: |
Almacena la información del destino favorito de cada individuo. |
|
meal: |
Realiza un seguimiento de la comida favorita de un individuo. |
|
1 2 3 4 5 6 7 8 |
mysql> CREATE TABLE vacation ( name varchar(50), birthdate date, activity varchar(50), destination varchar(50), meal varchar(50) ); Query OK, 0 rows affected (0.09 sec) |
Pueble la tabla con datos:
|
1 2 3 4 5 6 7 8 9 10 |
mysql> CREATE TABLE vacation ( name varchar(50), birthdate date, activity varchar(50), destination varchar(50), meal varchar(50) ); Query OK, 0 rows affected (0.09 sec) Records: 4 Duplicates: 0 Warnings: 0 |
Ya ha terminado de configurar su base de datos.
Paso 2 — Primeros pasos con las sentencias SELECT
Las consultas en SQL normalmente comienzan con SELECT. Se utiliza en las consultas para especificar qué columnas de una tabla deben devolverse con los resultados. Una consulta también debe incluir siempre FROM, que se utiliza para especificar la tabla que consultará la sentencia.
Las consultas siguen la siguiente sintaxis:
|
1 |
mysql> SELECT column_to_select FROM table_to_select WHERE certain_conditions_apply; |
Utilizaremos la sintaxis de consulta para devolver la columna meal de la tabla vacation tabla:
|
1 |
mysql> SELECT meal FROM vacation; |
Nuestra salida será la siguiente:
|
1 2 3 4 5 6 7 8 9 10 |
+-------+ | meal | +-------+ | Steak | | Sushi | | Fries | | Tofu | +-------+ 4 rows in set (0.00 sec) |
También puede seleccionar varias columnas utilizando una coma para separarlas:
|
1 |
mysql> SELECT name, destination FROM vacation; |
Salida:
|
1 2 3 4 5 6 7 8 9 10 |
+--------+-------------+ | name | destination | +--------+-------------+ | Austin | Maldives | | Ivan | Mauritius | | Aisha | Colorado | | Zane | Bora Bora | +--------+-------------+ 4 rows in set (0.00 sec) |
También puede utilizar un asterisco (*) si desea representar todas las columnas de la tabla:
|
1 |
mysql> SELECT * FROM celebration; |
Salida:
|
1 2 3 4 5 6 7 8 9 10 |
+--------+------+------+ | name | wins | time | +--------+------+------+ | Austin | 4 | 15.5 | | Ivan | 7 | 9 | | Aisha | 10 | 5 | | Zane | 13 | 7.5 | +--------+------+------+ 4 rows in set (0.00 sec) |
Si desea filtrar los registros que cumplen con una condición específica, utilice WHERE. Las filas que no cumplen con la condición especificada se eliminan de los resultados. La cláusula WHERE utiliza la siguiente sintaxis:
|
1 |
mysql> . . . WHERE column_name comparison_operator value |
Es un operador de comparación que define cómo se debe comparar la columna especificada con el valor. Los operadores de comparación comunes de SQL incluyen:
|
Operador |
Uso |
|
= |
Igualdad |
|
!= |
Desigualdad |
|
< |
Menor que |
|
> |
Mayor que |
|
<= |
Menor o igual que |
|
>= |
Mayor o igual que |
|
BETWEEN |
Comprueba si el valor se encuentra dentro del rango dado. |
|
IN |
Comprueba si el valor de una fila está contenido en un conjunto de valores especificados. |
|
EXISTS |
Comprueba si existe una fila |
|
LIKE |
Comprueba si un valor coincide con la cadena especificada |
|
IS NULL |
Comprueba si hay valores nulos |
|
IS NOT NULL |
Comprueba todos los valores distintos de NULL |
Si quisiera encontrar el destino favorito de Aisha, podría utilizar la siguiente consulta:
|
1 |
mysql> SELECT destination FROM vacation WHERE name ='Aisha'; |
La consulta devolverá lo siguiente:
|
1 2 3 4 5 6 7 |
+-------------+ | destination | +-------------+ | Colorado | +-------------+ 1 fila en conjunto (0.03 seg) |
SQL admite el uso de caracteres comodín, los cuales son especialmente útiles en las cláusulas WHERE. Los signos de porcentaje ( %) denotan cero o más caracteres desconocidos, mientras que los guiones bajos ( _) denotan un solo carácter desconocido. Estos son útiles si desea encontrar una entrada específica en una tabla pero no está seguro de ella.
Por ejemplo, si hubiera olvidado el destino favorito de un amigo y solo supiera la letra con la que comienza, por ejemplo, “m”. Puede encontrar el nombre del destino mediante la siguiente consulta:
|
1 |
mysql> SELECT destination FROM vacation WHERE destination LIKE 'm%'; |
La consulta devolverá:
|
1 2 3 4 5 6 7 8 |
+-------------+ | destination | +-------------+ | Maldivas | | Mauricio | +-------------+ 2 filas en conjunto (0.04 seg) |
Al trabajar con bases de datos, es posible que se encuentre con columnas o tablas con nombres relativamente largos o difíciles de leer. En estos casos, puede hacer que los nombres sean más legibles utilizando la palabra clave AS para crear un alias. Los alias creados con AS solo son válidos durante la duración de la consulta para la que fueron creados:
|
1 2 3 4 5 6 7 8 9 10 11 |
mysql> SELECT name AS E, destination as D, activity as A FROM vacation; +--------+-----------+-------------------+ | E | D | A | +--------+-----------+-------------------+ | Austin | Maldivas | esquí | | Ivan | Mauricio | parapente | | Aisha | Colorado | escalada de montaña | | Zane | Bora Bora | pesca | +--------+-----------+-------------------+ 4 filas en conjunto (0.00 seg) |
Paso 3 — Introducción a las funciones de agregación
Al trabajar con datos, no siempre querrá ver los datos en sí. Es posible que prefiera tener información sobre los datos. Al emitir una consulta SELECT, puede interpretar o realizar cálculos en sus datos utilizando la sintaxis SQL. Estas se conocen como funciones de agregación.
La función COUNT cuenta y devuelve el número de filas que cumplen con un conjunto específico de criterios. Por ejemplo, si desea saber cuántos amigos prefieren ir a las Maldivas, puede utilizar la siguiente consulta:
|
1 |
mysql> SELECT COUNT(destination) FROM vacation WHERE destination = 'Maldivas'; |
Se devolverán los siguientes resultados:
|
1 2 3 4 5 6 7 |
+--------------------+ | COUNT(destination) | +--------------------+ | 1 | +--------------------+ 1 fila en conjunto (0.06 seg) |
MIN se utiliza para encontrar el valor más pequeño dentro de una columna especificada:
|
1 |
mysql> SELECT MIN(wins) FROM celebration; |
La consulta mostrará:
|
1 2 3 4 5 6 7 |
+-----------+ | MIN(wins) | +-----------+ | 4 | +-----------+ 1 fila en conjunto (0.02 seg) |
MAX se utiliza para encontrar el valor numérico más grande en una columna dada:
|
1 |
mysql> SELECT MAX(wins) FROM celebration; |
El resultado esperado es:
|
1 2 3 4 5 6 7 |
+-----------+ | MAX(wins) | +-----------+ | 13 | +-----------+ 1 fila en conjunto (0.03 seg) |
Tanto la función MIN como MAX se pueden utilizar en datos numéricos y alfabéticos. Cuando se aplica a una columna de valores de cadena, la función MIN devuelve el primer valor alfabéticamente.
La función MIN devuelve el primer valor alfabéticamente:
|
1 |
mysql> SELECT MIN(name) FROM celebration; |
Este será el resultado:
|
1 2 3 4 5 6 7 |
+-----------+ | MIN(name) | +-----------+ | Aisha | +-----------+ 1 fila en conjunto (0.00 seg) |
La función MAX devuelve el último valor alfabéticamente:
|
1 |
mysql> SELECT MAX(name) FROM celebration; |
Este será el resultado:
|
1 2 3 4 5 6 7 |
+-----------+ | MAX(name) | +-----------+ | Zane | +-----------+ 1 fila en conjunto (0.00 seg) |
Paso 4 — Manipular los resultados de las consultas
Otra cláusula popular que se utiliza es la GROUP BY . Se utiliza al realizar una función de agregación en una columna pero en relación con los valores coincidentes en otra:
|
1 |
mysql> SELECT COUNT(name), activity FROM vacation GROUP BY activity; |
El resultado será:
|
1 2 3 4 5 6 7 8 9 10 |
+-------------+-------------------+ | COUNT(name) | activity | +-------------+-------------------+ | 1 | esquí | | 1 | parapente | | 1 | escalada de montaña | | 1 | pesca | +-------------+-------------------+ 4 filas en conjunto (0.04 seg) |
Para ordenar los resultados de la consulta, use la cláusula ORDER BY . Los valores numéricos se ordenan de forma ascendente de forma predeterminada, mientras que los valores de texto se ordenan alfabéticamente. La siguiente consulta enumera las columnas name y birthdate , pero ordena los resultados por birthdate:
|
1 |
mysql> SELECT name, birthdate FROM vacation ORDER BY birthdate; |
El resultado será el siguiente:
|
1 2 3 4 5 6 7 8 9 10 |
+--------+------------+ | name | birthdate | +--------+------------+ | Zane | 1996-01-01 | | Aisha | 1999-07-24 | | Austin | 2002-01-07 | | Ivan | 2010-12-18 | +--------+------------+ 4 filas en conjunto (0.04 seg) |
El resultado está en orden ascendente; para ordenar en orden descendente, cierre la consulta con la palabra DESC:
|
1 |
mysql> SELECT name, birthdate FROM vacation ORDER BY birthdate DESC; |
Eche un vistazo al resultado:
|
1 2 3 4 5 6 7 8 9 10 |
+--------+------------+ | name | birthdate | +--------+------------+ | Ivan | 2010-12-18 | | Austin | 2002-01-07 | | Aisha | 1999-07-24 | | Zane | 1996-01-01 | +--------+------------+ 4 filas en conjunto (0.00 seg) |
La cláusula HAVING se añadió a SQL para proporcionar una funcionalidad similar a la de la cláusula WHERE y al mismo tiempo ser compatible con funciones de agregación. La diferencia entre estas dos cláusulas es que WHERE sirve para hacer referencia a registros individuales y HAVING hace referencia a registros de grupo. Para ello, la cláusula GROUP BY debe estar presente siempre que se utilice una cláusula HAVING:
|
1 |
mysql> SELECT COUNT(name), activity FROM vacation GROUP BY activity HAVING COUNT(name) >= 1; |
La consulta devolverá:
|
1 2 3 4 5 6 7 8 |
+-------------+-------------------+ | COUNT(name) | activity | +-------------+-------------------+ | 1 | esquí | | 1 | parapente | | 1 | escalada de montaña | | 1 | pesca | +-------------+-------------------+ |
El COUNT es 1 en todos porque no hay dos amigos a los que les guste la misma actividad.
Paso 5 — Consultar múltiples tablas
La cláusula JOIN se puede utilizar en el resultado de una consulta para combinar filas de dos o más tablas. Esto se logra localizando una columna relacionada entre las tablas y ordenando el resultado de manera adecuada.
SELECT que incluyen una cláusula JOIN siguen la siguiente sintaxis:
|
1 2 3 |
mysql> SELECT table1.column1, table2.column2 mysql> FROM table1 mysql> JOIN table2 ON table1.related_column=table2.related_column; |
Si quisiera comprarle a cada uno de sus amigos un trofeo por sus victorias mientras practican natación en sus cumpleaños, podría crear una consulta que una ambas tablas para ayudarle a encontrar toda la información que desea con una sola consulta:
|
1 2 3 |
mysql> SELECT celebration.name, celebration.wins, vacation.birthdate FROM celebration JOIN vacation ON celebration.name=vacation.name; |
La salida será:
|
1 2 3 4 5 6 7 8 9 10 |
+--------+------+------------+ | name | wins | birthdate | +--------+------+------------+ | Austin | 4 | 2002-01-07 | | Ivan | 7 | 2010-12-18 | | Aisha | 10 | 1999-07-24 | | Zane | 13 | 1996-01-01 | +--------+------+------------+ 4 filas en conjunto (0.00 seg) |
Esta es una cláusula de JOIN interno. Esto se debe a que selecciona todos los registros que tienen valores coincidentes en ambas tablas y los imprime en un conjunto de resultados. Los registros que no coinciden con la consulta no se incluyen. Podemos incluir una nueva fila en nuestras tablas que no corresponda con ninguna entrada:
|
1 2 3 4 |
mysql> INSERT INTO celebration(name,wins,time) VALUES('Ella', '1', '120'); Query OK, 1 fila afectada (0.01 seg) |
|
1 2 3 4 |
mysql> INSERT INTO celebration(name,wins,time) VALUES('Ella', '1', '120'); Query OK, 1 fila afectada (0.01 seg) |
Luego, vuelva a ejecutar la instrucción SELECT con la cláusula JOIN:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 |
mysql> SELECT celebration.name, celebration.wins, vacation.birthdate -> FROM celebration -> JOIN vacation ON celebration.name=vacation.name; +--------+------+------------+ | name | wins | birthdate | +--------+------+------------+ | Austin | 4 | 2002-01-07 | | Ivan | 7 | 2010-12-18 | | Aisha | 10 | 1999-07-24 | | Zane | 13 | 1996-01-01 | +--------+------+------------+ 4 filas en conjunto (0.00 seg) |
Debido a que la tabla celebration no tiene ninguna entrada para Peter y la tabla vacation no tiene ninguna entrada para Ella, esos registros están ausentes.
Podemos devolver todos los registros de una de las tablas utilizando una cláusula JOIN externa. Esta puede ser un LEFT JOIN o un RIGHT JOIN. Un LEFT JOIN devuelve todos los registros de la tabla izquierda y solo los registros coincidentes de la tabla derecha. La tabla izquierda en el contexto de las uniones externas es la referenciada por la cláusula FROM, y la tabla derecha es cualquier tabla referenciada después de la instrucción JOIN.
Ejecute la consulta de nuevo pero use una cláusula LEFT JOIN:
|
1 2 3 |
mysql> SELECT celebration.name, celebration.wins, vacation.birthdate FROM celebration LEFT JOIN vacation ON celebration.name=vacation.name; |
El comando devolverá todos los registros de la tabla izquierda ( celebration) incluso si no tiene un registro correspondiente en la tabla derecha. Cuando no hay un registro coincidente en la tabla derecha, se devuelve como NULL:
|
1 2 3 4 5 6 7 8 9 10 11 |
+--------+------+------------+ | name | wins | birthdate | +--------+------+------------+ | Austin | 4 | 2002-01-07 | | Ivan | 7 | 2010-12-18 | | Aisha | 10 | 1999-07-24 | | Zane | 13 | 1996-01-01 | | Ella | 1 | NULL | +--------+------+------------+ 5 filas en conjunto (0.00 seg) |
Esta es ahora la cláusula RIGHT JOIN:
|
1 2 3 |
mysql> SELECT celebration.name, celebration.wins, vacation.birthdate FROM celebration RIGHT JOIN vacation ON celebration.name=vacation.name; |
Se devolverán todos los valores de la tabla derecha (vacation). Debido a que el birthdate de Peter está registrado en la tabla derecha y no en la tabla izquierda, las columnas name y wins devolverán valores NULL en esas filas:
|
1 2 3 4 5 6 7 8 9 10 11 |
+--------+------+------------+ | name | wins | birthdate | +--------+------+------------+ | Austin | 4 | 2002-01-07 | | Ivan | 7 | 2010-12-18 | | Aisha | 10 | 1999-07-24 | | Zane | 13 | 1996-01-01 | | NULL | NULL | 1991-05-03 | +--------+------+------------+ 5 filas en conjunto (0.01 seg) |
Puedes usar la cláusula UNION en lugar de JOIN para consultar registros de múltiples tablas. El operador UNION se diferencia de la cláusula JOIN en que combina los resultados de dos sentencias SELECT en una sola columna, en lugar de imprimir los resultados de múltiples tablas como columnas únicas utilizando una sola sentencia SELECT.
Puedes ejecutar esta consulta para ilustrarlo:
|
1 |
mysql> SELECT name FROM celebration UNION SELECT name FROM vacation; |
La consulta elimina las entradas duplicadas. Este es el comportamiento predeterminado del operador UNION:
|
1 2 3 4 5 6 7 8 9 10 11 12 |
+--------+ | name | +--------+ | Austin | | Ivan | | Aisha | | Zane | | Ella | | Peter | +--------+ 6 filas en conjunto (0.00 seg) |
Para devolver todas las entradas (además de los duplicados), utiliza el operador UNION ALL:
|
1 |
mysql> SELECT name FROM celebration UNION ALL SELECT name FROM vacation; |
Resultado:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 |
+--------+ | name | +--------+ | Austin | | Ivan | | Aisha | | Zane | | Ella | | Austin | | Ivan | | Aisha | | Zane | | Peter | +--------+ 10 filas en conjunto (0.00 seg) |
Las subconsultas son otro método para consultar varias tablas. Las subconsultas son consultas que se encuentran dentro de otra consulta (también conocidas como consultas internas o anidadas). Son útiles cuando se desea comparar los resultados de una consulta con los resultados de una función de agregación independiente.
Usaremos el ejemplo de intentar buscar qué amigo ha ganado más torneos de natación que Ella. En lugar de consultar cuántos partidos ha ganado Ella y luego ejecutar otra consulta para ver quién ha ganado más juegos que eso, puedes calcular ambos con una sola consulta:
|
1 2 3 4 |
mysql> SELECT name, wins FROM celebration -> WHERE wins > ( -> SELECT wins FROM celebration WHERE name = 'Ella' -> ); |
La consulta devolverá:
|
1 2 3 4 5 6 7 8 9 10 |
+--------+------+ | name | wins | +--------+------+ | Austin | 4 | | Ivan | 7 | | Aisha | 10 | | Zane | 13 | +--------+------+ 4 filas en conjunto (0.06 seg) |
Si quisieras llevar a tus amigos a unas vacaciones sorpresa, puedes usar una consulta para ver quién tiene más victorias y devolver su destino:
|
1 2 3 4 |
mysql> SELECT name, destination, activity, meal -> FROM vacation -> WHERE name = ( SELECT name FROM celebration -> WHERE wins = (SELECT MAX(wins) FROM celebration)); |
La consulta devolverá:
|
1 2 3 4 5 6 7 |
+------+-------------+----------+------+ | name | destination | activity | meal | +------+-------------+----------+------+ | Zane | Bora Bora | pesca | Tofu | +------+-------------+----------+------+ 1 fila en conjunto (0.00 seg) |
Esta sentencia contiene una subconsulta dentro de otra subconsulta.
Conclusión
La generación de consultas es una de las tareas más comunes en la gestión de bases de datos. Existen varias herramientas de administración de bases de datos como phpMyAdmin y pgAdmin que puedes utilizar para trabajar con consultas y visualizar sus resultados. Sin embargo, la sentencia SELECT desde la línea de comandos es la opción preferida debido a su facilidad de uso y excelente control.
Además, hay muchos tutoriales sobre bases de datos que puedes explorar desde nuestro blog:
- SQLite vs. MySQL vs. PostgreSQL: comparación de sistemas de gestión de bases de datos relacionales
- Soluciones rápidas para reparar tablas corruptas en MySQL: un tutorial
- Cómo instalar MySQL en Centos 7
- Usuario de MySQL — Crear y otorgar permisos
- Configuración de la replicación en MySQL en Ubuntu
¡Feliz computación!
Comentarios
Aún no hay comentarios. Sea el primero.