Sei sulla pagina 1di 9

Linux examen 102 de LPIC-1

openwebinars.net/academia/curso/linux-lpi-102/340

Comprendiendo SQL
El Lenguaje de Consultas Estructurado (Structured Query Language - SQL) como su
nombre indica, es un lenguaje usado para recuperar datos de una base de datos (BBDD).
Se trata de una herramienta para acceder a bases de datos y más específicamente, bases
de datos relacionales. El siguiente ejemplo ilustra la relación entre los datos en una base
de datos relacional:

Atributos (columnas)

lagarto verde 5 centímetros blando 10€

árbol verde 100 centímetros semiduro 200€

Filas almohada blanco 18 centímetros blando 5€

ladrillo rojo 8 centímetros duro 1€

plátano amarillo 10 centímetros blando 0,25€

Cada fila representa un objeto simple y cada columna representa una característica
específica, por lo que la combinación de filas y columnas es conocida como tabla.

Cada base de datos puede contener múltiples tablas, y SQL soporta múltiples bases de
datos. Para acceder a los datos, primero se debe seleccionar una base de datos y una
tabla. Los datos en una tabla están desordenados, al menos conceptualmente, aunque en
la práctica están almacenados en un orden en el disco y dicho orden es arbitrario. Se
puede imponer un orden en los resultados de una consulta; por ejemplo se podrían
recuperar datos de la BBDD representada en el anterior ejemplo ordenando los resultados
en base al coste (última columna).

Una BBDD permite la recuperación de información que coincida con criterios específicos.
En el ejemplo anterior se podrían buscar todos los objetos verdes. También se puede
insertar, borrar, y actualizar información de una tabla.

SQL soporta múltiples tablas, de forma que se pueden tener por ejemplo diferentes tablas
para pertenencias de una oficina y para empleados que trabajen en dicha oficina.

Las columnas en una BBDD almacenan tipos específicos de datos, e intercambiarlos


puede provocar que tengan poco sentido. Por ejemplo, es lógico que la segunda columna
del ejemplo anterior sea un color y la columna final un precio expresado en euros. Tendría
poco sentido introducir "verde" como un valor en la última columna o 1€ como un color en
la segunda columna.

Las restricciones impuestas en cada columna concreta son conocidas como dominio o tipo
de datos, de forma que el dominio para la segunda columna es una colección de nombres
1/9
de colores, mientras que el dominio para la última columna es un valor numérico
expresado en euros.

A continuación se resumen algunos tipos de datos comunes SQL:

INTEGER (o INT): Valor entero de 4 bytes


SMALLINT: Valor entero de 2 bytes
DECIMAL: Almacena un número exacto de valores decimales
NUMERIC: Almacena un número exacto de valores enteros y decimales
FLOAT: Permite tanto números enteros como decimales
DOUBLE PRECISION: Valores float almacenados con el doble de precisión
DATETIME: Almacena la fecha y la hora
DATE: Almacena la fecha
TIME: Almacena una hora, en formato HH:MM:SS, puede ser la hora de un día o un
intervalo de horas
CHAR: Uno o más caracteres
VARCHAR: Un número variable de caracteres
ENUM: Una lista enumerada, como podría ser: pequeño, mediano, grande
SET: Datos que podrían tener cero o más valores, como podría ser una colección de
galletas, fruta, leche para hacer helados

Existen más tipos de datos y aquí se han resumido los tipos que son más comunes. Cada
uno de estos tipos de datos tienen sus propias características, por ejemplo los datos
numéricos (INTEGER, DECIMAL, etc ...) pueden ser manipulados por operadores
matemáticos.

Almacenamiento de Datos
Para aprender SQL se debe acceder a una BBDD SQL. Para ilustrar este apartado se
utilizará MySQL como referencia. Otras implementaciones SQL son similares a ella aunque
se puede diferenciar en algunos detalles. Uno de ellos es la forma de iniciar la BBDD ya
que en el caso de MySQL la distribución debería incluir un script de inicio para el servidor
SQL.

Este servidor debería necesitar también ser configurado con su propio password de root.
Debian y otras distribuciones relacionadas lo solicitarán cuando se instale el paquete así
que es posible que se necesite configurar manualmente en otras distribuciones.

Consideramos que existe la BBDD "test", que consta de la tabla objetos y a su vez
contiene 5 campos diferentes: nombre (varchar (30)), color (varchar (20)), tamaño (float),
tipo (enum) y valor (decimal) .

Cada uno de esos campos es del tipo que se corresponde con el tipo de datos que se van
a almacenar. A continuación se muestra la secuencia de creación de esta BBDD y su
tabla:

2/9
mysql> CREATE DATABASE test;
Query OK, 1 row affected (0.00 sec)

mysql> show databases;


+--------------------+
| Database |
+--------------------+
| information_schema |
| mysql |
| performance_schema |
| test |
+--------------------+
4 rows in set (0.00 sec)

mysql> USE test;


Database changed

mysql> CREATE TABLE objetos (nombre VARCHAR(30), color VARCHAR(20), tamaño FLOAT,
tipo ENUM('blando','medio','duro'),valor DECIMAL(10,2));

mysql> SHOW TABLES;


+----------------+
| Tables_in_test |
+----------------+
| objetos |
+----------------+
1 row in set (0.00 sec)

mysql> DESCRIBE objetos;


+---------+-------------------------------+------+-----+---------+-------+
| Field | Type | Null | Key | Default | Extra |
+---------+-------------------------------+------+-----+---------+-------+
| nombre | varchar(30) | YES | | NULL | |
| color | varchar(20) | YES | | NULL | |
| tamaño | float | YES | | NULL | |
| tipo | enum('blando','medio','duro') | YES | | NULL | |
| valor | decimal(10,2) | YES | | NULL | |
+---------+-------------------------------+------+-----+---------+-------+
5 rows in set (0.00 sec)

Ahora se puede comenzar a almacenar datos en la BBDD y para ello se usa el comando
INSERT INTO :

mysql> INSERT INTO objetos VALUES('lagarto','verde',6,'blando',10.00);


Query OK, 1 row affected (0.10 sec)

mysql> INSERT INTO objetos VALUES('arbol','verde',100,'medio',200.00);


Query OK, 1 row affected (0.02 sec)

mysql> INSERT INTO objetos VALUES('almohada','blanco',18,'blando',5.00);


Query OK, 1 row affected (0.03 sec)

mysql> INSERT INTO objetos VALUES('ladrillo','rojo',8,'duro',1.00);


Query OK, 1 row affected (0.04 sec)

mysql> INSERT INTO objetos VALUES('plátano','amarillo',10,'blando',0.25);


Query OK, 1 row affected (0.04 sec)

3/9
Este ejemplo crea los registros mostrados en la tabla inicial del tema. Para verificar que la
BBDD almacena esta información:

mysql> SELECT * FROM objetos;


+----------+----------+---------+--------+--------+
| nombre | color | tamaño | tipo | valor |
+----------+----------+---------+--------+--------+
| lagarto | verde | 6 | blando | 10.00 |
| arbol | verde | 100 | medio | 200.00 |
| almohada | blanco | 18 | blando | 5.00 |
| ladrillo | rojo | 8 | duro | 1.00 |
| plátano | amarillo | 10 | blando | 0.25 |
+----------+----------+---------+--------+--------+
5 rows in set (0.00 sec)

El resultado es una lista con todos los datos de la tabla objetos, que en este caso deberían
ser una sola entrada. El ejemplo anterior introdujo datos incorrectos en uno de los campos:
El registro 'lagarto' ha sido introducido en la tabla con un tamaño de 6 centímetros, en
lugar de 5. Esto se puede corregir utilizando UPDATE :

mysql> UPDATE objetos SET tamaño=5 WHERE nombre='lagarto';


Query OK, 1 row affected (0.11 sec)
Rows matched: 1 Changed: 1 Warnings: 0

Este ejemplo comienza con la sentencia UPDATE y el nombre de tabla (objetos) como en
el ejemplo anterior. La sentencia indica a MySQL que actualice el campo "tamaño" a 5. La
clave WHERE especifica la fila o registro a ser modificado. En este caso, al existir solo un
registro se puede usar cualquier dato o incluso omitir la clave WHERE .

En la mayoría de los casos se puede indicar el dato que sea suficiente para identificar de
forma única el registro que se desea modificar. Aunque en el ejemplo se ha usado el
campo nombre, cualquier otro campo que identificara inequívocamente el registro 'lagarto'
hubiera sido válido.

Extracción de Datos
El punto fuerte de tener una BBDD es poder recuperar datos de ella. El comando principal
para realizar esta tarea es SELECT .

Se pueden usar variedad de claves para seleccionar datos que coincidan con distintos
criterios, así como coincidencias exactas o basadas en un rango de valores.

La forma general de la sentencia SELECT es usar un asterisco (*) como el campo a


mostrar significando que el comando devolverá todas las columnas que coincidan con el
criterio buscado.

Por ejemplo, imaginemos que solo se está interesado en los colores y valores de objetos.
Para obtener esta información y que solo se muestre esta colección de atributos de la
tabla objetos se utiliza SELECT de la forma siguiente:

4/9
mysql> SELECT valor,color FROM objetos;
+-------+-------+
| valor | color |
+-------+-------+
| 10.00 | verde |
+-------+-------+
1 row in set (0.00 sec)

Los criterios que se muestran aparecen como una lista separada por comas consistente
en distintas columnas de la tabla. En este ejemplo, los criterios son listados en el orden
inverso al que tienen en la BBDD.

Una forma más interesante de extraer datos es usar la condición WHERE . Se pueden usar
condiciones de extracción de datos específicos de distintas formas:

Coincidencias exactas: ​ Usando un nombre de columna, un signo igual y un valor


que devuelva solo aquellas filas que coincidan con el valor especificado. Por
ejemplo, la siguiente sentencia devuelve las dos entradas de la tabla cuyo color es
verde (árbol y lagarto):

mysql> SELECT * FROM objetos WHERE color='verde';


+---------+-------+---------+--------+--------+
| nombre | color | tamaño | tipo | valor |
+---------+-------+---------+--------+--------+
| lagarto | verde | 5 | blando | 10.00 |
| arbol | verde | 100 | medio | 200.00 |
+---------+-------+---------+--------+--------+
2 rows in set (0.00 sec)

Tests numéricos: Se pueden extraer datos que coincidan con ciertos criterios
numéricos.

Por ejemplo, para extraer datos de todos los objetos mayores de 10 centímetros:

mysql> SELECT * FROM objetos WHERE tamaño>10;


+----------+--------+---------+--------+--------+
| nombre | color | tamaño | tipo | valor |
+----------+--------+---------+--------+--------+
| arbol | verde | 100 | medio | 200.00 |
| almohada | blanco | 18 | blando | 5.00 |
+----------+--------+---------+--------+--------+
2 rows in set (0.00 sec)

Tests alfabéticos: Los operadores "mayor que" (>) y "menor que" (<) funcionan
tanto para letras como para números. Este hecho puede ser usado para extraer
datos basándose en la primera letra de una cadena.

Por ejemplo para extraer registros cuyo nombre comience con la letra "b" o letras
posteriores en el alfabeto:

5/9
mysql> SELECT * FROM objetos WHERE nombre>'b';
+----------+----------+---------+--------+-------+
| nombre | color | tamaño | tipo | valor |
+----------+----------+---------+--------+-------+
| lagarto | verde | 5 | blando | 10.00 |
| ladrillo | rojo | 8 | duro | 1.00 |
| plátano | amarillo | 10 | blando | 0.25 |
+----------+----------+---------+--------+-------+
3 rows in set (0.00 sec)

Tests múltiples: Se pueden combinar múltiples criterios usando los operadores


AND y OR.

Por ejemplo, se pueden extraer datos de objetos blandos valorados en más de 7.50€:

mysql> SELECT * FROM objetos WHERE tipo='blando' AND valor>7.50;


+---------+-------+---------+--------+-------+
| nombre | color | tamaño | tipo | valor |
+---------+-------+---------+--------+-------+
| lagarto | verde | 5 | blando | 10.00 |
+---------+-------+---------+--------+-------+
1 row in set (0.00 sec)

También se pueden extraer datos SQL ordenándolos por algún criterio, especificando el
nombre del campo por el que se desea ordenar tras la clave ORDER BY :

mysql> SELECT * FROM objetos WHERE tipo='blando' ORDER BY valor;


+----------+----------+---------+--------+-------+
| nombre | color | tamaño | tipo | valor |
+----------+----------+---------+--------+-------+
| plátano | amarillo | 10 | blando | 0.25 |
| almohada | blanco | 18 | blando | 5.00 |
| lagarto | verde | 5 | blando | 10.00 |
+----------+----------+---------+--------+-------+
3 rows in set (0.00 sec)

Combinando Datos de Múltiples Tablas


Como se ha mencionado anteriormente, una BBDD puede contener múltiples tablas, lo
que habilita a SQL a poder crear tablas para diferentes funciones.

En los ejemplos anteriores se ha representado una BBDD de objetos y una tabla con las
características de cada uno. Se podría también tener una tabla conteniendo las
localizaciones y condiciones (en una escala de 10 puntos) de diferentes objetos, como se
muestra más adelante.

Se podrían combinar dos tablas para crear una tabla "master" en la que se puedan realizar
consultas y para ello ambas tablas deben tener un campo coincidente que servirá para
unirlas y un campo cuyo valor identifique únicamente cada fila. Este campo identificador
único es conocido como clave primaria .

Se puede considerar la creación de una segunda tabla y su posterior inserción de datos


para continuar con la casuística descrita:

6/9
mysql> CREATE TABLE localizaciones (id INTEGER, nombre VARCHAR(30), localizacion
VARCHAR(30), condicion INTEGER);
Query OK, 0 rows affected (0.11 sec)

mysql> INSERT INTO localizaciones VALUES(1, 'plátano', 'cocina', 9);


Query OK, 1 row affected (0.03 sec)

mysql> INSERT INTO localizaciones VALUES(2, 'plátano', 'cocina', 8);


Query OK, 1 row affected (0.05 sec)

mysql> INSERT INTO localizaciones VALUES(3, 'árbol', 'patio trasero', 2);


Query OK, 1 row affected (0.04 sec)

mysql> INSERT INTO localizaciones VALUES(4, 'ladrillo', 'garage', 10);


Query OK, 1 row affected (0.19 sec)

mysql> INSERT INTO localizaciones VALUES(5, 'ladrillo', 'garage', 9);


Query OK, 1 row affected (0.05 sec)

mysql> INSERT INTO localizaciones VALUES(6, 'ladrillo', 'patio trasero', 9);


Query OK, 1 row affected (0.04 sec)

mysql> INSERT INTO localizaciones VALUES(7, 'lagarto', 'sala de estar', 8);


Query OK, 1 row affected (0.03 sec)

En este punto, se puede usar el operador SELECT para seleccionar datos basados en
campos de ambas tablas.

Por ejemplo, si se desea conocer dónde están todos los objetos verdes y sus
localizaciones. La primera tabla (objetos) contiene los datos del color pero no las
localizaciones, mientras que la segunda tabla (localizaciones) almacena la localización
pero no los colores. Se pueden combinar ambas tablas de la siguiente forma:

mysql> SELECT objetos.nombre, objetos.color, localizaciones.localizacion FROM


objetos, localizaciones WHERE objetos.nombre=localizaciones.nombre AND
objetos.color='verde';
+---------+-------+---------------+
| nombre | color | localizacion |
+---------+-------+---------------+
| arbol | verde | patio trasero |
| lagarto | verde | sala de estar |
+---------+-------+---------------+
2 rows in set (0.00 sec)

En el caso del ejemplo de la tabla "objetos" la primera columna (nombre) puede servir
como clave primaria.

Mysql combina automáticamente las dos tablas y produce la salida basada en los criterios
especificados. El resultado final en este ejemplo incluye el nombre, color y localización de
los objetos, incluso aunque cada tabla tenga solo dos de estos tres valores.

Otra forma de combinar datos entre múltiples tablas es usar JOIN . Esta utilidad es muy
similar a la anterior pero se puede especificar una tabla usando FROM y la otra usando
JOIN :

7/9
mysql> SELECT objetos.nombre, objetos.color, localizaciones.localizacion FROM
objetos JOIN localizaciones WHERE objetos.nombre=localizaciones.nombre AND
objetos.color=’verde’;

La combinación de datos permite simplificar la estructura de la BBDD en ciertas


situaciones como ilustran los ejemplos aquí usados, aunque no obstante con muy pocos
datos.

Los datos en la tabla de objetos describen objetos generales mientras que los datos de la
tabla de ubicaciones describen objetos específicos.

Una orden de recuperación que requiere una mención especial es GROUP BY. Este
comando se utiliza junto con los operadores matemáticos, tales como SUM (), para
restringir el funcionamiento del operador a las columnas especificadas. Si quiere conocer
por ejemplo el valor total de todos los objetos de la base de datos, agrupados por tipo de
objeto se puede hacer combinando los datos de las dos tablas:

mysql> SELECT objetos.nombre, objetos.valor, SUM(valor)

-> FROM objetos, localizaciones

->WHERE localizaciones.nombre=objetos.nombre

-> GROUP BY valor;

Si se omite GROUP BY se devolverá es un mensaje de error.

Borrando Datos
Si se necesita borrar registros de una tabla de una base de datos se debe utilizar el
comando DELETE, que tiene la siguiente sintaxis:

DELETE FROM table WHERE conditions

En la siguiente tabla:

Nombre almacenado Ventas Fecha

Los Angeles 1500 € 05-Jan-1999

San Diego 250 € 07-Jan-1999

Los Angeles 300 € 08-Jan-1999

Boston 700 € 08-Jan-1999

Si se pretende borrar todos los datos sobre Los Ángeles se utiliza la siguiente sentencia:

mysql> DELETE FROM info_almacenado


-> WHERE nombre_almacenado = "Los Angeles";

Ahora el contenido de la tabla sería el siguiente:

Nombre almacenado Ventas Fecha

San Diego 250 € 07-Jan-1999


8/9
Boston 700 € 08-Jan-1999

9/9