# Módulo 4. Consultas básicas SQL # Consultas básicas de selección #### La sentencia SELECT El comando SELECT permite: - Obtener datos de ciertas columnas de una tabla. - Obtener filas de una tabla de acuerdo con ciertos criterios. - Realizar cálculos sobre los datos. - Mezclar datos de tablas diferentes. - Agrupar datos. En este curso, vamos a quedarnos en lo más sencillo, que son las opciones 1, 2 y 3. En su forma más simple, la sintaxis para la expresión SELECT es: SELECT campos FROM tablas \[WHERE condiciones\] - **campos:** son las columnas (separadas por comas) o cálculos que se desea recuperar de la base de datos. Se puede utilizar \* si se desean recuperar todas las columnas. - **tablas:** indica las tablas de las que se desean recuperar los registros. Mínimo debe haber una tabla para poder recuperar registros. - **condiciones:** las condiciones que deben cumplir las filas que se desean recuperar. La sentencia más sencilla sería la de recuperar todos los campos de una tabla: ```SQL SELECT * FROM alumnos; ``` Si se desea recuperar solo DNI, nombre y apellidos de los alumnos, entonces se pondría: ```SQL SELECT DNI, nombre, apellidos FROM alumnos; ``` #### Condiciones La cláusula **WHERE** sirve para restringir los datos de salida. Permite poner una o varias condiciones que han de cumplir las filas que se desean recuperar, las que no cumplan esas condiciones no aparecerán en el resultado de la consulta. Por ejemplo, si solo se desea mostrar los datos de las asignaturas que tengan una duración mayor de 2 horas a la semana. Sería como sigue: ```SQL SELECT * FROM Asignatura WHERE Horas_semanales > 2; ``` Se van a explicar a continuación los operadores básicos que se pueden utilizar en la cláusula WHERE. ##### Operadores de comparación
**Operador** **Significado**
> Mayor que
< Menor que
>= Mayor o igual que
<= Menor o igual que
= Igual
<> Distinto
!= Distinto
##### Valores lógicos
**Operador** **Significado**
AND Devuelve verdadero si las expresiones de su izquierda y derecha son ambas verdaderas.
OR Devuelve verdadero si cualquiera de las dos expresiones a izquierda y derecha del OR, son verdaderas.
NOT Invierte la lógica de la expresión que está a su derecha. Si es verdadera, mediante NOT pasa a ser falsa.
Por ejemplo, si se desea mostrar los datos de las asignaturas que tengan una duración mayor de 2 horas a la semana pero menor de 6. Sería: ```SQL SELECT * FROM Asignatura WHERE Horas_semanales>2 AND Horas_semanales<6; ``` ##### LIKE Se usa sobre todo con textos, permite obtener registros cuyo valor en un campo cumpla una condición textual. LIKE utiliza una cadena que puede contener estos símbolos:
**Símbolo** **Significado**
% Una serie cualquiera de caracteres
\_ Un carácter cualquiera
Por ejemplo, mostrar los nombres de los alumnos que empiecen por S: ```SQL SELECT nombre FROM alumnos WHERE nombre LIKE 'S%'; ``` ##### IS NULL Devuelve verdadero si el valor que examina es nulo. Los campos tienen valor nulo cuando al insertar una fila, ese campo se deja vacío. La siguiente sentencia devuelve el nombre y apellidos de los alumnos que no tienen email. ```SQL SELECT nombre, apellidos FROM alumno WHERE email IS NULL ```

Hay otros operadores como **BETWEEN** o **IN**, que no se van a explicar en este curso.

#### ORDENACIÓN El orden inicial de los registros obtenidos por una SELECT es el orden en el que fueron introducidos. Para ordenar basándose en otros criterios, se utiliza la cláusula **ORDER BY**. En esa cláusula se coloca una lista de campos que indica la forma de ordenar. Se ordena primero por el primer campo de la lista, si hay coincidencias por el segundo, si ahí también las hay por el tercero, y así sucesivamente. Se puede colocar la palabra **ASC** O **DESC** (por defecto, si se indica nada, utiliza ASC). Por ejemplo, la siguiente sentencia muestra todos los datos de los alumnos que no tienen email, ordenados alfabéticamente por el nombre: ```SQL SELECT nombre, apellidos FROM alumno WHERE email IS NULL ORDER BY nombre ASC; ``` #### Contar filas Existe una función que sirve para contar filas, es la función **count**. Sirve para contar filas. Vamos a verlo con algún ejemplo. La siguiente consulta cuenta cuántos alumnos hay en la tabla alumno: ```SQL SELECT count(*) from alumno; ``` Si queremos contar cuántos alumnos hay cuyo apellido empiece por A: ```SQL SELECT count(*) from alumno where apellidos like 'A%'; ``` {{@5685}} # Consultas calculadas #### CONSULTAS CALCULADAS ##### Cálculos aritméticos En las consultas se pueden utilizar los operadores + (suma), - (resta), \* (multiplicación) y / (división) para hacer cálculos. Cuando se utilizan como expresión en una consulta SELECT, no modifican los datos originales sino que como resultado de la vista generada por la consulta, aparece una nueva columna. Ejemplo: ```SQL SELECT dni, nota, nota*2 FROM alumnos; ``` Esa consulta obtiene tres columnas: el dni, la nota y la nota multiplicada por 2 . La tercera tendrá como nombre la expresión utilizada, para poner un alias basta utilizar dicho alias tras la expresión **as**: ```SQL SELECT dni, nota, nota*2 as nota_doble FROM alumnos; ``` La prioridad de esos operadores es la normal: tienen más prioridad la multiplicación y división, después la suma y la resta. En caso de igualdad de prioridad, se realiza primero la operación que esté más a la izquierda. Se puede evitar cumplir esa prioridad usando paréntesis; el interior de los paréntesis es lo que se ejecuta primero. Cuando una expresión aritmética se calcula sobre valores NULL, el resultado es el mismo valor NULL. ##### Concatenación de textos Todas las bases de datos incluyen algún operador para encadenar textos. En SQLSERVER es el signo + en Oracle son los signos || y en MySQL se hace con la función **CONCAT** . Ejemplo: ```SQL SELECT dni, concat(apellidos,', ',nombre), email FROM alumnos; ``` El resultado de esa consulta es una tabla con tres columnas: la primera el DNI, la segunda columna es la concatenación de los apellidos con una coma y un espacio y luego el nombre, y la tercera columna el email. {{@5685}} # Consultas básicas sobre una base de datos en Coding Rooms Aquí van unos pocos ejemplos de consultas básicas sobre una base de datos, para practicar sobre la herramienta [Coding rooms](https://app.codingrooms.com/). Antes de nada, [aquí](https://drive.google.com/file/d/122-hVOyCTNviMjVoim3yGkkNDwCMT1lr/view?usp=sharing) puedes descarar la base de datos para ejecutarla en la herramienta que más abajo se explica paso a paso cómo hacerlo. La base de datos es sobre recetas, tiene el siguiente diagrama relacional: [![recetas relacional.png](https://libros.catedu.es/uploads/images/gallery/2022-09/scaled-1680-/FCTrecetas-relacional.png)](https://libros.catedu.es/uploads/images/gallery/2022-09/FCTrecetas-relacional.png) #### Coding Rooms Para utilizar Coding Rooms no se necesario registrarse si se accede directamente al workspace desde [este enlace](https://app.codingrooms.com/compiler/mysql). Pero si te registras se guardan los workspace que vayas utilizando, por lo que yo lo recomiendo. Para iniciar el compilador solo hay que pulsar sobre el botón "Start coding MySQL for free now". [![Coding Rooms start.png](https://libros.catedu.es/uploads/images/gallery/2022-09/scaled-1680-/coding-rooms-start.png)](https://libros.catedu.es/uploads/images/gallery/2022-09/coding-rooms-start.png) Esto abre el Workspace de MySQL siguiente. [![Workspace codingrooms mysql.png](https://libros.catedu.es/uploads/images/gallery/2022-09/scaled-1680-/workspace-codingrooms-mysql.png)](https://libros.catedu.es/uploads/images/gallery/2022-09/workspace-codingrooms-mysql.png) Lo primero que tenemos que hacer es ejecutar el script descargado para crear la base de datos de recetas. Para eso, en el área de navegación de archivos, clicar sobre la flecha hacia arriba para subir el archivo. [![coding rooms uploadfile.png](https://libros.catedu.es/uploads/images/gallery/2022-09/scaled-1680-/coding-rooms-uploadfile.png)](https://libros.catedu.es/uploads/images/gallery/2022-09/coding-rooms-uploadfile.png) El archivo se carga y haciendo clic sobre él se abre en el escritorio. Ahora solo hay que desplegar los archivos del botón de ejecución y seleccionar el archivo que se desea ejecutar. [![Ejecutar script.png](https://libros.catedu.es/uploads/images/gallery/2022-09/scaled-1680-/ejecutar-script.png)](https://libros.catedu.es/uploads/images/gallery/2022-09/ejecutar-script.png) El resultado de la ejecución se carga en la consola de debajo. En el caso del script de creación de la base de datos de recetas, como no son consultas, no muestra nada por pantalla, así que si no muestra ningún error, es que todo ha ido bien. [![image-1662366980077.png](https://libros.catedu.es/uploads/images/gallery/2022-09/scaled-1680-/image-1662366980077.png)](https://libros.catedu.es/uploads/images/gallery/2022-09/image-1662366980077.png) Con esto ya deberíamos tener la base de datos creada en el servidor de coding rooms para empezar a hacer consultas. #### Consultas SQL sencillas En el archivo que podéis descargar [aquí](https://drive.google.com/file/d/16KHVSkkvYkAUoVP8CKM47EO4QjoF3DwC/view?usp=sharing), hay ejemplos de consultas que a continuación se explican. ##### Ejecutar consultas en Coding Rooms Para ejecutar cada consulta en Coding Rooms, hay que poner la consulta en un archivo y ejecutar ese archivo. Para crear un archivo nuevo hay que pulsar en el + del navegador de ficheros: [![image-1662367796199.png](https://libros.catedu.es/uploads/images/gallery/2022-09/scaled-1680-/image-1662367796199.png)](https://libros.catedu.es/uploads/images/gallery/2022-09/image-1662367796199.png) En ese nuevo archivo podéis ir escribiendo cada consulta, y el resultado se mostrará en la consola. ##### Ejemplos del archivo ***1. Mostrar todos los tipos de recetas que hay en la base de datos:*** ```SQL select * from tipo_receta; ``` La consola muestra el resultado: [![image-1662368642075.png](https://libros.catedu.es/uploads/images/gallery/2022-09/scaled-1680-/image-1662368642075.png)](https://libros.catedu.es/uploads/images/gallery/2022-09/image-1662368642075.png) ***2. Mostrar el nombre de todas las recetas que no tienen anotaciones (en el campo notas)*** ```SQL select nombre from receta where notas is null; ``` Resultado: [![Consulta ejemplo 2.png](https://libros.catedu.es/uploads/images/gallery/2022-10/scaled-1680-/consulta-ejemplo-2.png)](https://libros.catedu.es/uploads/images/gallery/2022-10/consulta-ejemplo-2.png) ***3. Queremos saber cómo se prepara la "Ensalada de verano"*** ```SQL select preparacion from receta where nombre like 'Ensalada de verano'; ``` Resultado: [![Consulta ejemplo 3.png](https://libros.catedu.es/uploads/images/gallery/2022-10/scaled-1680-/consulta-ejemplo-3.png)](https://libros.catedu.es/uploads/images/gallery/2022-10/consulta-ejemplo-3.png) **Ahora vamos a ver cómo sacaríamos información que hay en varias tablas sin haber visto las consultas multitabla.** ***4. Queremos saber qué recetas llevan 'Ternera'.*** Los ingredientes están en la tabla **ingrediente**, la unión de recetas con ingredientes está en la tabla **receta\_tiene\_ingrediente**, pero el nombre de las recetas está en la tabla **receta**. Primero hay que buscar cuál es el identificador del ingrediente 'Ternera' para buscarlo en la tabla **receta\_tiene\_ingrediente**. Así esta tabla nos dará los identificadores de las recetas que llevan ternera y con ese identificador podremos ir a buscar las recetas en la tabla **receta**. Identificador del ingrediente 'Ternera': ```SQL select id_ingrediente from ingrediente where nombre like 'Ternera'; ``` Resultado: [![Consulta ejemploe 4_1.png](https://libros.catedu.es/uploads/images/gallery/2022-10/scaled-1680-/consulta-ejemploe-4-1.png)](https://libros.catedu.es/uploads/images/gallery/2022-10/consulta-ejemploe-4-1.png) Identificador de las recetas que llevan 'Ternera': ```SQL select id_receta from receta_tiene_ingrediente where id_ingrediente=1; ``` Resultado: [![Consulta ejemplo 4_2.png](https://libros.catedu.es/uploads/images/gallery/2022-10/scaled-1680-/consulta-ejemplo-4-2.png)](https://libros.catedu.es/uploads/images/gallery/2022-10/consulta-ejemplo-4-2.png) Recetas que llevan 'Ternera': ```SQL select nombre from receta where id_receta=9 or id_receta=1; ``` Resultado: [![Consulta ejemplo 4_3.png](https://libros.catedu.es/uploads/images/gallery/2022-10/scaled-1680-/consulta-ejemplo-4-3.png)](https://libros.catedu.es/uploads/images/gallery/2022-10/consulta-ejemplo-4-3.png)
***5. Contar cuántas recetas tienen anotaciones (en el campo notas).***
```SQL select count(*) from receta where notas is not null; ``` Resultado: [![Consulta ejemplo 5.png](https://libros.catedu.es/uploads/images/gallery/2022-10/scaled-1680-/consulta-ejemplo-5.png)](https://libros.catedu.es/uploads/images/gallery/2022-10/consulta-ejemplo-5.png)
{{@5685}} # Un ejemplo de consulta multitabla Vamos a ver cómo sacaríamos los nombres de las recetas que llevan ternera usando solo una consulta sobre arias tablas a la vez. **La manera de hacerlo consultando las tablas por separado** Los ingredientes están en la tabla **ingrediente**, la unión de recetas con ingredientes está en la tabla **receta\_tiene\_ingrediente**, pero el nombre de las recetas está en la tabla **receta**. Primero hay que buscar cuál es el identificador del ingrediente 'Ternera' para buscarlo en la tabla **receta\_tiene\_ingrediente**. Así esta tabla nos dará los identificadores de las recetas que llevan ternera y con ese identificador podremos ir a buscar las recetas en la tabla **receta**. Identificador del ingrediente 'Ternera': ```SQL select id_ingrediente from ingrediente where nombre like 'Ternera'; ``` Identificador de las recetas que llevan 'Ternera': ```SQL select id_receta from receta_tiene_ingrediente where id_ingrediente=1; ``` Recetas que llevan 'Ternera': ```SQL select nombre from receta where id_receta=9 or id_receta=1; ``` ##### Consulta multitabla El modo básico de hacerlo es poniendo en la cláusula **from** las tablas separadas por comas, y en la cláusula **where** indicar cómo se relacionan esas tablas, es decir, indicando qué columnas son las que deben ser iguales en cada fila. En el ejemplo anterior sería: ```SQL SELECT receta.nombre FROM ingrediente, receta_tiene_ingrediente, receta WHERE ingrediente.id_ingrediente = receta_tiene_ingrediente.id_ingrediente and receta_tiene_ingrediente.id_receta = receta.id_receta and ingrediente.nombre like 'Ternera'; ```

Fíjate que se están indicando las columnas con el nombre de la tabla delante seguidos por un punto. Esto es necesario cuando en una consulta multitabla hay columnas en diferentes tablas con el mismo nombre, como es este caso, para saber a la columna de qué tabla se está haciendo referencia.

{{@5685}}