Prácticas de Bases de Datos

1. TOMA DE CONTACTO Prácticas de Bases de Datos Fernando Cano Espinosa Juan David González Cobas (In memoriam) Curso 2011-2012 1. Virtualización. Para el desarrollo de las prácticas de Bases de Datos vamos a utilizar un gestor de bases de datos llamado Postgres. Lo haremos sobre Ubuntu, una distribución de linux, que correrá como una máquina virtual. El software de virtualización es VirtualBox, recientemente adquirido por Oracle. Por tanto, para comenzar las prácticas, desde Windows y con vuestra cuenta autenticada por Ident, ejecutáis VirtualBox y arrancáis la máquina virtual denominada Linux. Una vez hecho esto se os comunicará el nombre de usuario y clave, para poder empezar a utilizar Ubuntu. Accederéis primeramente como usuario privilegiado, para poder crear vuestro propio usuario, que será con el que trabajaréis a lo largo del curso. Para crearlo podéis utilizar el comando adduser y suministrar el nombre se usuario con el que trabajaréis, vuestro nombre completo (el real) y la password. Desde este momento esta cuenta ya no será necesario utilizar la cuenta privilegiada, a no ser que necesitemos realizar alguna labor administrativa. 2. Qué es postgresql. De forma sencilla diremos que postgresql es un gestor de bases de datos. En http://www.postgresql.org tendréis acceso a todo la información que necesitéis. postgresql, normalmente llamado postgres, es una aplicación que nos permite entre otras muchas cosas definir y manipular bases de datos. Se trata de software libre que corre sobre Linux- Unix aunque existen versiones para otros sistemas operativos (MAC OS, Windows). Como gestor es posiblemente uno de los que incluye un SQL (lenguaje con el que realizaremos nuestras operaciones) más estándar. Para manejar postgresql disponemos, entre otras muchas opciones, de un intérprete de comandos (un terminal-based front-end), el psql, con el que podremos trabajar en modo texto. Existen otras aplicaciones en modo gráfico como pgadmin3 que podremos utilizar en alguna ocasión. También es posible trabajar con prostgresql a través de la web con php (phppgadmin). Nosotros vamos a trabajar con la más sencilla. Dependiendo del ordenador que nos ha tocado es posible que no dispongamos de un servidor postgres bien configurado. Para ello será necesario seguir las instrucciones del documento configuracion_postgres.pdf que se encontrará en la página web de las prácticas. 3. Ejecutar psql. Para empezar cada alumno ya debería tener su propia cuenta en Linux. Una vez iniciada la sesión abrimos un terminal y vamos a ejecutar la siguiente secuencia de comandos. Ejecutamos el psql de la forma $ psql -U username base_de_datos NOTA: en lo que sigue vamos a utilizar como username un usuario de la base de datos que debe estar creado en cada máquina y que tiene como nombre alumno y de password alumna. Si no estuviera creado podemos crearlo tal y como se detalla en configuracion_postgres.pdf. En el caso del parámetro base_de_datos, se trata de una base de datos que ya exista. En una instalación normal de prostgresql existe una base de datos de nombre template1 a la que siempre es posible conectarnos. Por lo tanto nuestra orden será: $ psql -U alumno template1 Una vez en el intérprete veremos el prompt template1=> que nos indica que la base de datos a la que estamos conectados es template1. Se trata de una base de datos patrón que no vamos a utilizar. El símbolo > significa que no somos superusuarios de postgresql, en otro caso se nos mostrará el símbolo #. 4. Un rápido ejemplo. Ahora, sin salir del psql vamos a crear nuestra propia base de datos mediante la orden template1=> create database miprueba; No olvidar el ; para finalizar la orden. Ya tenemos creada nuestra base de datos de nombre miprueba. Si lo que queremos ahora es conectarnos a ella debemos ejecutar 1

template1=> \c miprueba; En este momento el prompt debe indicar el nombre de nuestra base de datos, que se encuentra vacía. miprueba=> Vamos a crear una tabla t1 con dos columnas id, nombre, una de tipo entero (int) y otra de tipo cadena (text). Ejecutaremos miprueba=> create table t1 (id int, nombre text); Como la tabla está vacía vamos a insertar un par de filas: miprueba=> insert into t1 values (1, Ana ); miprueba=> insert into t1 values (2, Luis ); Comprobamos que el contenido de la tabla es el que esperamos. miprueba=> select id, nombre from t1; Ante un imprevisto cambio de sexo vamos a modificar nuestros datos de la forma: miprueba=> update t1 set nombre= Luisa where id=2; Ahora, ahítos de alegría, volvemos a dejar las cosas como al principio y salimos ejecutando la secuencia de órdenes: miprueba=> delete from t1; miprueba=> drop table t1; miprueba=> \c template1 template1=> drop database miprueba; template1=> \q 5. El entorno de trabajo. El intérprete de comandos psql puede parecer un poco incómodo para aquellos que no estén acostumbrados a trabajar con este tipo de entornos, por ello vamos a ver un par de detalles para agilizar nuestro trabajo. Como muchas órdenes pueden ocupar más que una línea, es normal hacer uso de un editor. Podemos definir el editor que preferimos (kwrite, kate, vi, emacs, gedit, joe, pico, etc.), para ello desde la línea de comandos de Linux, ejecutaremos la orden $ export PSQL_EDITOR=mieditor_preferido Si entramos de nuevo en el intérprete psql, nos daremos cuenta que con las flechas del cursor podemos recuperar las órdenes que dimos anteriormente; psql guarda un histórico de nuestras órdenes por lo que fácilmente podemos volver a crear nuestra base de datos miprueba. Podemos optar por no usar un editor y trabajar con múltiples lineas de tal forma que mientras que no finalicemos la orden, el intérprete nos presentará un prompt que va cambiando en la sucesivas líneas. Por ejemplo si queremos insertar un cliente nuevo, en una sola línea podemos poner. miprueba=> insert into t1 values (3, Pedrito ); Pero vamos a ver lo que sucede si lo hacemos en diferentes líneas: miprueba=> insert miprueba-> into t1 miprueba-> values (3, miprueba(> Pedrito miprueba > miprueba(> ) miprueba-> ; Observar que el prompt va cambiando dependiendo del estado en que que nos encontremos ( =>, ->, >) y que la orden se finaliza con el ;. Cada orden se guarda en un buffer, que se llama el query buffer. Si invocamos al editor nos permitirá modificar la última orden. Para hacer esto tan sólo tendremos que ejecutar \edit o 2

sencillamente \e. Al salir del editor el intérprete ejecutará lo que hemos escrito. Invocar al editor y veréis el insert anterior, y podéis insertar otro cliente. Otra alternativa, posiblemente más cómoda, sobre todo si lo que queremos es ejecutar un fichero entero de órdenes, consiste en mantener un editor abierto en una ventana, y en otra ventana, tener el intérprete de psql. Supongamos que el fichero que editamos se corresponde con /home/pepe/bdatos/mificherodeordenes.sql; nos colocamos en el directorio /home/pepe/bdatos, (dentro de psql, con la orden \cd, nos podemos cambiar al directorio que especifiquemos, sin necesidad de salir del intérprete); y para ejecutar el fichero bastaría poner en el prompt miprueba=>\i mificherodeordenes.sql 6. Crear la base de datos. En el directorio de prácticas de la asignatura existen varios ficheros que deberíais copiar en un directorio vuestro. Estos son: createpedidos.sql: es un scrpit sql que contiene las órdenes de creación de la base de datos y las tablas. insertpedidos.sql: es un scrpit sql que inserta valores en las tablas. Pedidos.pdf y pedidos_uml.pdf: enunciado, diagrama Entidad Relación y tablas resultantes de la base de datos de pedidos Una vez hecho desde el psql ejecutar las órdenes: template1=> \i createpedidos.sql pedidos=> \i insertpedidos.sql En este momento deberíais tener creada la base de datos e insertados los datos en las tablas y por tanto listos para empezar a realizar consultas. 7. Los metadatos. Ahora vamos a ver algunas órdenes para ir manejándonos. template1=> \l - muestra las base de datos template1=> \dt - muestra las tablas de la actual base de datos template1=> \d tabla - muestra información de la tabla template1=> \du - muestra las usuarios template1=> \e - edita el query-buffer template1=> \i - ejecuta un fichero template1=> \o - redirecciona la salida template1=> \h - muestra la ayuda SQL Ejecutar algunas de estas órdenes. Aún así se recomienda tener a mano, ya sea en papel o en pantalla, los nombres de las tablas y de las columnas. 8. Practicamos. Vamos a conectarnos a la base de datos de pedidos y a ejecutar varias órdenes sencillas sobre la tabla de clientes desde el psql. Para ello se puede editar la orden en la propia línea de comandos o utilizando el editor elegido. a) mostrar toda la tabla from clientes; b) mostrar el id_cliente y el nombre de todos los clientes select id_cliente,nombre from clientes; c) mostrar toda la información de los clientes de Gijón (ojo con las mayúsculas y minúsculas) from clientes where ciudad= GIJON ; 3

d) mostar el id_cliente y el nombre de todos los clientes que sean de Gijón o de Mieres select id_cliente, nombre from clientes where ciudad= GIJON or ciudad = MIERES ; 9. Borrar la base de datos y volver al mismo punto en el que estábamos. Teniendo los scripts de creación e inserción de datos es fácil reconstruir nuestra base de datos de forma rápida. 10. Vamos a utilizar la ayuda y ver algunos ejemplos de cómo se expresa la sintaxis de órdenes SQL. Para mostrar la ayuda de postgresql abrimos con un navegador el fichero file:///usr/share/doc/postgresql-doc-8.4/html/index.html La sintaxis de las órdenes SQL se encuentra descrita en la P art V I de la documentación. También podemos llegar a ella directamente abriendo el fichero: file:///usr/share/doc/postgresql-doc-8.4/html/reference.html Es posible, no hayamos instalado la documentación, y que no encontremos estos ficheros. Para instalar la documentación bastaría con ejecutar: $ sudo apt-get install postgresql-doc-8.4 pero siempre nos quedará París o la página oficial http://www.postgresql.org Es muy importante familiarizarse con esta notación, ya no solo para aprender SQL. Se trata, más o menos, de una gramática libre de contexto, y lo que se nos muestra son las reglas de producción. En esta notación tenemos que recordar que: Los símbolos terminales (palabras que aparecen tal cual en las órdenes) se expresan en mayúsculas( ej. SELECT ). Los símbolos no terminales (símbolos que producen cadenas de otros símbolos) se expresan en minúsculas (ej. condition, expression) Las barras verticales expresan distintas alternativas. Los corchetes expresan que lo que hay dentro es opcional. Las llaves expresan alguna de las alternativas que se incluyen debe aparecer. Los puntos suspensivos se utilizan para describir una repetición, generalmente separados por comas, del símbolo que se encuentra a la izquierda de los puntos suspensivos. Al aparecer entre corchetes se describe una lista de uno a más elementos. Para cada orden encontraremos generalmente con los siguientes apartados El nombre de la orden. La sintaxis de la orden (synopsis). Una descripción. Una explicación de los parámetros. Unas notas. Unos ejemplos. La compatibilidad con otras versiones de SQL. Algunos aspectos de la sintaxis no son fáciles de encontrar en esta documentación, pero dado que se trata de un SQL bastante estándar cualquier sintaxis nos puede servir para crear consultas sencillas. Aún así es recomendable echar un vistazo al Chapter 7. Queries donde podemos ir desmenuzando la sintaxis del select. 4

11. Seguimos probando algunas órdenes sencillas: Mostrar (SELECT ) los productos cuyo precio esté entre 90 y 120. Disponemos del predicado between para ello. from productos where precio between 90 and 120; Insertamos (INSERT ) un nuevo producto insert into productos (id_producto, nombre, precio) values (7, KIWI, 100); Observar que no hemos introducido un valor para existencias. Para ello hemos escrito los nombres (y el orden) de las columnas que vamos a introducir. También podríamos haber utilizado la palabra reservada null para dicha columna. Actualizamos (U P DAT E) las existencias del nuevo producto e incrementamos el precio en un 10 % update productos set existencias= 50, precio = precio * 1.1 where id_producto=7; Borramos (DELET E) el nuevo producto delete from productos where id_producto=7; 5

2. EL SELECT COMO UNA FORMA DE VIDA 1. Nos conectamos a nuestra base de datos de pedidos (crearla si fuera necesario) 2. Es fundamental ver y entender bien el significado del Producto (join) de tablas. Cuando queremos recuperar información que se encuentra repartida entre distintas tablas vamos a basarnos en dos ideas: la primera es la de repetir columnas en diferentes tablas para poder enlazar dicha información y la segunda es utilizar la operación producto cartesiano de conjunto (entendiendo que una tabla en un conjunto de filas). Para realizar el producto cartesiano (cross join) de pedidos con clientes podemos expresarlo así: from pedidos, clientes; o de forma algo más elegante así: from pedidos cross join clientes; Para ver más claramente lo que hace esta consulta vamos a mostrar las columnas pedidos.id_cliente y clientes.id_cliente select pedidos.id_cliente, clientes.id_cliente from pedidos cross join clientes; Añadimos al from la tabla de empleados y mostramos también pedidos.id_empleado y empleados.id_empleado. Observamos cuántas filas obtenemos. Y nos damos cuenta que equivale al producto de los cardinales de los tres conjuntos de filas (tablas). Estudiar sobre la anterior consulta from pedidos cross join clientes; qué condición que debe imponerse a las filas en la cláusula W HERE para obtener un resultado coherente. Modificar esta consulta de forma que no sea necesario imponer la condición en el W HERE. Para ello podemos realizar el producto natural (NAT URAL JOIN). O también el INNER JOIN que como veremos presenta dos alternativas, una con utilizando la cláusula ON y otra con la cláusula USING. 3. Obtener el id_pedido, el nombre del cliente para todos los pedidos. 4. Obtener el id_pedido, el nombre del cliente y el nombre del empleado para los pedidos atendidos por empleados de Mieres. 5. Obtener el id_pedido, el nombre del cliente y el nombre del empleado para los pedidos realizados el 2 de septiembre de 2006 que han sido atendidos por empleados de Mieres. 6. Introducir las variables de tupla (con el primer objetivo de ahorrarse escribir mucho). 7. Ver cómo se renombran las columnas para distinguir entre el nombre del cliente y del empleado. 8. Obtener el id_pedido, el nombre del cliente, el nombre de los productos y cantidad de los mismos para todos los pedidos. 9. Nombre del cliente y nombre del empleados que comparten ciudad 10. Parejas de nombres de clientes que comparten ciudad 6

3. EL SELECT Y SUS AMIGOS 1. Comparaciones de cadenas (Pattern Matching, LIKE). Para comparar cadenas tenemos el operador LIKE que podemos utilizar en combinación con los caracteres % y _ que tienen, respectivamente, el mismo significado que el * y? en linux y otros sistemas operativos. Mostrar el identificador y nombre de aquellos productos que cumplen lo siguiente: empiezan por P terminan en AS contienen las subcadena TA En postgresql podemos utilizar el ILIKE para que no se distingan mayúsculas de minúsculas (case insensitive). 2. El operador IN (NOT IN ) Mostrar el identificador y nombre de aquellos productos pedidos por PEPE Mostrar el identificador y nombre de aquellos productos NO pedidos por PEPE En muchos casos el IN permite hacer intersecciones de conjuntos y el NOT IN nos sirve para la diferencia de conjuntos. 3. Otras comparaciones Mostrar el identificador y nombre de aquellos productos que cuestan más que alguno de los que ha pedido PEPE 4. El predicado EXISTS 5. La UNION Mostrar pedidos con su fecha en los que no aparece ningún producto. Mostrar los nombres de empleados o clientes que viven en MIERES Añadimos la calle 6. La INTERSECCIÓN (INTERSECT) Mostrar aquellas ciudades donde viven tanto empleados como clientes. 7. El MINUS (EXCEPT) Mostrar aquellas ciudades donde viven empleados pero no clientes. 7

8. El inexistente CON T AIN S El CONT AINS sirve para implementar la inclusión de conjuntos ( ), a diferencia del IN ( ) que nos permite comprobar si un elemento pertenece a un conjunto. Por tanto los parámetros de CONT AINS son dos conjuntos (el resultado de dos select s). Se suele utilizar en consultas del tipo Para todo. Mostrar los clientes que han pedido todos los productos que ha pedido PEPE. Vamos a definirnos dos conjuntos: A y B. Conjunto A: productos pedidos por cada cliente (c 1 ). Conjunto B: productos pedidos por clientes cuyo nombre es PEPE. Si se cumple que B A entonces el cliente c 1 deber ser mostrado. select nombre from clientes c1 where ( select id_producto -- Conjunto A: productos pedidos por c1 from pedidos p inner join detalles_pedido dp using (id_pedido) where p.id_cliente = c1.id_cliente) contains ( select id_producto -- Conjunto B: productos pedidos por PEPE from clientes c2 inner join pedidos p using (id_cliente) inner join detalles_pedido dp using(id_pedido) where c2.nombre ilike PEPE ); Si se observa el predicado contains devuelve TRUE si el conjunto A contiene al conjunto B. Lamentablemente SQL no implementa este predicado y tiene que ser simulado con la condición NOT EXISTS (B MINUS A), es decir NOT EXISTS (B EXCEPT A). Demostramos nuestra capacidad de aprendizaje: mostrar aquellos productos que aparecen en todos los pedidos Insistimos: clientes que han sido atendidos por todos los empleados de Gijón. 9. Algo sobre Valores nulos. Para poder manejar los valores nulos en SQL tenemos que tener en cuenta algunos criterios. Además SQL nos ofrece algunos operadores que nos facilitan el tratamiento de los valores null. En general, las expresiones que incluyen valores nulos devuelven como resultado null. En las expresiones lógicas se siguen las reglas mostradas en las tablas del epígrafe 9.1. Logical Operators. El operador IS (value IS null) nos devuelve true si value contiene el valor null. La expresión CASE nos permite, entre otras cosas, controlar que si un resultado es null podemos cambiarle su valor para poder trabajar mejor con él. Por ejemplo, en algunas expresiones aritméticas es útil convertir valores nulos en ceros (ver 9.12.1). La función COALESCE() también nos permite algo parecido a lo anterior pero de otra forma(ver 9.12.2). La función NULLIF () es como la función inversa a la anterior (ver 9.12.3). Mostrar los identificadores de pedido y los del empleado, pero si no tiene un empleado asociado mostrar un 0. Mostrar los identificadores de pedido y los del empleado, pero si no tiene un empleado asociado mostrar la cadena sin asignar. Mostrar los empleados que no han atendido ningún pedido utilizando el operador NOT IN, ver qué pasa y arreglarlo. 8

10. Empezamos a agrupar (group by, having, count(), max(), etc.) Mostrar el número de pedidos atendidos por MARIA. Identificador del empleado y número de pedidos atendidos por él. Nombre del empleado y número de pedidos atendidos por él. Fecha y número de empleados que han atendido algún pedido en dicha fecha. Identificador de Pedido, fecha del mismo, número de de productos diferentes que incluye y la cantidad media de productos por pedido. Identificador de Pedido y coste total del mismo para aquellos pedidos que incluyen más de dos productos distintos. Para aquellos productos cuyas existencias no cubren las cantidades pedidas, obtener su nombre, sus existencias, las cantidades pedidas y las cantidades necesarias que la empresa tiene que comprar para poder cubrir todos los pedidos. 11. Ordenamos un poco Nombres de productos y el número de pedidos en los que aparecen, ordenados por el nombre alfabéticamente y por el número de pedidos de forma descendente 9

4. Práctica 4: EL SELECT Y LOS JOINS Nombre de los empleados con los identificadores de los pedidos atendidos por ellos Nombre de TODOS los empleados con los identificadores de los pedidos atendidos por ellos Productos y el número de pedidos en los que aparecen Relaciones entre clientes y empleados. Mostrando TODOS los clientes y TODOS los empleados aunque no haya realizado ningún pedido 10