Introducción al diseño de bases de datos

Practica 1. SQL

Por definición una base de datos es un conjunto de datos de diferentes tipos organizados y
relacionados, deben estar libres de redundancia y ser independientes de los programas que los usan.

En las Bases de datos relacionales:

-El usuario percibe la información en la BD como tablas.
-Estas tablas satisfacen ciertas restricciones de integridad.
-Las tablas se pueden manipular mediante operadores que derivan tablas a partir de tablas

Un SGBD, es un sistema de software que permite a los usuarios definir, crear, mantener y controlar
el acceso a las bases de datos, esto mediante un lenguaje de definición de datos (DDL), un lenguaje de
manipulación de datos (DML), y un lenguaje de control de datos (DCL).

-DDL. Permite especificar las estructuras y tipos de datos, y las restricciones aplicables a los datos que
se van a almacenar en la BD.
-DML. Permite insertar, actualizar, borrar y extraer datos de la BD.
-DCL. Ayuda a sistematizar la seguridad (para evitar accesos no autorizados), la integridad (para
mantener la coherencia de los datos), la concurrencia (para permitir el acceso compartido), y la
recuperación (para restaurar un estado previo coherente de la BD, después de una falla de software o
hardware).

Uno de los lenguajes que ha emergido a partir del desarrollo del modelo relacional es el SQL
(Structured Query Language) el cual es un estándar internacional aceptado por los fabricantes de
sistemas gestores de bases de datos.
Esencialmente trabaja mediante una arquitectura cliente/servidor: la computadora cliente hace
peticiones a la computadora servidor, la cual responde con transferencias de textos que el cliente se
encarga de presentar en pantalla. Es un lenguaje declarativo, esto significa que las instrucciones
especifican que es lo que se quiere, sin decir como hacerlo. SQL asume la función de DDL, DML y
DCL, a través de comandos o consultas que integran sentencias y clausulas como:

INSERT: Inserta valores en una tabla

UPDATE: Modifica el contenido de los registros de una tabla
DELETE: Elimina registros de una tabla
SELECT: Permite devolver información de una o mas tablas
CREATE: Crea un objeto dentro de la base de datos. Puede ser una tabla, vista, índice, trigger,
función, procedimiento o cualquier otro objeto que el motor de la base de datos soporte.
ALTER: Permite modificar la estructura de un objeto. Se pueden agregar/quitar campos a una tabla,
modificar el tipo de un campo, agregar/quitar índices a una tabla, modificar un trigger, etc.
DROP: Elimina un objeto de la base de datos.
TRUNCATE: Trunca el contenido de una tabla, es decir borra todo el contenido a partir de un lugar
especificado.

El SQL permite principalmente dos modos de uso:

Interactivo. Las diversas sentencias SQL se escriben y ejecutan desde línea de comandos.
Integrado (embebiod). Las sentencias se usan como un sublenguaje dentro de programas escritos en
algún otro lenguaje, por ejemplo en Java o PHP.
 En esta practica haremos uso del gestor de bases de datos MySQL para crear una pequeña base de
datos que está constituida por tres tablas; con ello conoceremos el papel de SQL como lenguaje de
definición de datos (DDL) y como lenguaje de manipulación de datos (DML). Al crear las tablas
cuidaremos la relación entre ellas, asignando llaves primarias y foráneas, para evitar la redundancia y la
inconsistencia.

INSTRUCCIONES
Ejecutar los siguientes comandos SQL, documentar los resultados, proponer consultas para los
enunciados indicados, escribir junto a las consulta las dudas sobre la estructura o su significado, e
incluir comentarios finales o conclusiones.

-Los resultados deben ser entregados en un documento pdf.

Nota: Las sentencias y clausulas están escritas en mayúsculas con el fin de proporcionar claridad a
las consultas, pero MySQL también las acepta en minúsculas.

1.-Entrar a MySQL
$ mysql -u root -p

2.-Ver que bases de datos existen

mysql> SHOW DATABASES;

3.-Crar una base de datos

mysql> CREATE DATABASE practica1;

4.-Comprobar que se haya creado

5.-De este momento en adelante usaremos la BD practica1

mysql> USE practica1;

6.-CREACIÓN DE LAS TRES TABLAS

mysql> CREATE TABLE salgrade( grade TINYINT(1) UNSIGNED PRIMARY KEY, losal
DECIMAL(8,2) UNSIGNED NOT NULL, hisal DECIMAL(8,2) UNSIGNED NOT NULL);

mysql> CREATE TABLE dept(

-> deptno TINYINT(2) UNSIGNED,
-> dname VARCHAR(20) NOT NULL,
-> loc VARCHAR(20) NOT NULL,
-> PRIMARY KEY(deptno));

mysql> CREATE TABLE emp(

-> empno SMALLINT(4) PRIMARY KEY,
-> ename VARCHAR(40) NOT NULL,
-> job VARCHAR(40) NOT NULL,
-> mgr SMALLINT(4),
-> hiredate DATE NOT NULL,
-> sal DECIMAL(8,2) NOT NULL,
-> comm DECIMAL(8,2),
-> DEPTNO tinyint(2),
-> CONSTRAINT emp_mgr FOREIGN KEY(mgr) REFERENCES emp(empno),
-> CONSTRAINT emp_deptno FOREIGN KEY(deptno) REFERENCES dept(deptno));

En la tercera tabla tenemos una llave primaria y dos llaves foráneas que
relacionan las dos tablas anteriores con esta. Las llaves foráneas son deptno y
mgr, hacen referencia a las columnas deptno de la tabla dept y empno de la tabla
emp, respectivamente. Vemos que se puede crear una llave primaria de dos formas
distintas, en las tablas salgrade y emp se creo a nivel columna y en dept a nivel
tabla.

7.-Ver las características de las tablas creadas.

mysql> DESC salgrade;

mysql> SHOW COLUMNS FROM dept;

mysql> DESCRIBE emp;

Vemos las columnas de cada tabla haciendo la solicitud de tres formas diferentes.
Se pueden ver las diferentes características de cada atributo: tipo, si pude ser
nulo o no, el valor que toman por default y cuales son llaves primarias (PRI) y
cuales secundarias (MUL).
Al seleccionar dptno como llave primaria, automáticamente se le asignan las
características not null.

8.-Insertar valores en las tablas creadas

mysql> INSERT INTO salgrade VALUES(1,700,1200);
mysql> INSERT INTO dept VALUES(10,'Accounting','New York');
mysql> INSERT INTO emp VALUES(7839,'King','President',NULL,'1981-11-
17',5000,NULL,10);

Completar con la siguiente información:

salgrade
+-------+---------+---------+
| grade | losal | hisal |
+-------+---------+---------+
| 1 | 700.00 | 1200.00 |
| 2 | 1201.00 | 1400.00 |
| 3 | 1401.00 | 2000.00 |
| 4 | 2001.00 | 3000.00 |
| 5 | 3001.00 | 9999.00 |
+-------+---------+---------+
dept
+--------+------------+----------+
| deptno | dname | loc |
+--------+------------+----------+
| 10 | Accounting | New York |
| 20 | Research | Dallas |
| 30 | Sales | Chicago |
| 40 | Operations | Boston |
+--------+------------+----------+
emp
+-------+--------+-----------+------+------------+---------+---------+--------+
| empno | ename | job | mgr | hiredate | sal | comm | DEPTNO |
+-------+--------+-----------+------+------------+---------+---------+--------+
| 7839 | King | President | NULL | 1981-11-17 | 5000.00 | NULL | 10 |
| 7698 | Blake | Manager | 7839 | 1981-05-01 | 2850.00 | NULL | 30 |
| 7782 | Clark | Manager | 7839 | 1981-06-09 | 2450.00 | NULL | 10 |
| 7566 | Jones | Manager | 7839 | 1981-04-02 | 2975.00 | NULL | 20 |
| 7654 | Martin | Salesman | 7698 | 1981-09-28 | 1250.00 | 1400.00 | 30 |
| 7499 | Allen | Salesman | 7698 | 1981-02-20 | 1600.00 | 300.00 | 30 |
| 7834 | Turner | Salesman | 7698 | 1981-09-08 | 1500.00 | 0.00 | 30 |
| 7900 | James | Clerk | 7698 | 1981-12-03 | 950.00 | NULL | 30 |
| 7521 | Ward | Salesman | 7698 | 1981-02-22 | 1250.00 | 500.00 | 30 |
| 7902 | Ford | Analyst | 7566 | 1981-12-03 | 3000.00 | NULL | 20 |
| 7369 | Smith | Clerk | 7902 | 1980-12-17 | 800.00 | NULL | 20 |
| 7788 | Scott | Analyst | 7566 | 1982-12-09 | 3000.00 | NULL | 20 |
| 7876 | Adams | Clerk | 7788 | 1983-01-12 | 1100.00 | NULL | 20 |
| 7934 | Miller | Clerk | 7782 | 1982-01-23 | 1300.00 | NULL | 10 |
+-------+--------+-----------+------+------------+---------+---------+--------+
9.-Ver el contenido de las tablas
mysql> SELECT * FROM salgrade;

revisar el contenido de las otras dos tablas.

10.-Para agregar una tupla (renglon) en un determinado orden se usa:

mysql> INSERT INTO emp(EMPNO,JOB,ENAME,HIREDATE,MGR,SAL,DEPTNO)
-> VALUES(1000,'Clerk','Fuentes','82-01-23',7782,1300,10);

En este caso omitimos un valor que acepta null, y no marcó ningún error o
warning. Al hacer la siguiente consulta vemos que automáticamente se le asigno el
valor NULL.

11.-Ver los renglones que coincidan con el valor especificado de coluna.

mysql> SELECT * FROM emp WHERE ename='Fuentes';

12.-Que pasa si insertamos lo siguiente:

mysql> INSERT INTO emp(empno) VALUES(1);

12.-Veamos que fue lo que se inserto:

mysql> SELECT * FROM emp WHERE empno=1;

Vemos que se asignaron valores por defecto y en algunos casos ningún valor.

13.-De igual forma:

mysql> INSERT INTO emp(comm) VALUES(NULL);

mysql> SELECT * FROM emp WHERE empno=0;

Para evitar los problemas de este tipo se deben poner más constraints y valores
por default.

14.-Mostrar las columnas loc y deptno de la tabla dept.

mysql> SELECT loc,deptno FROM dept;

15.-Mostrar nombre, fecha de contratación y salario de cada uno de los empleados:

mysql> SELECT ename,hiredate,sal FROM emp;

16.-Presentar el nombre y lo que resulte de la operación 12 por salario mas

comisión del empleado con nombre King.
mysql> SELECT ename,12*sal+comm
-> FROM emp
-> WHERE ename='King';

En este caso comm=NULL, y cuando participa null en una operación, el resultado

es null. Nota: elegir valores por default adecudos.

17.-Seleccionar ename y sal de la tabla emp, presentado las columnas con la leyenda
nombre y salario, respectivamente.
mysql> SELECT ename AS Nombre, sal Salario FROM emp;

nostar que funciona con y sin AS.

18.-Presentar la columna deptno de la tabla emp y notar la diferencia con la

siguiente consulta:
mysql> SELECT DISTINCT deptno
 -> FROM emp;

19.-Cuando se usa DISTINCT para seleccionar varios campos, considera toda la tupla
para hacer distinción entre ellas y presentar el resultado.
mysql> SELECT DISTINCT mgr,deptno
-> FROM emp;

mysql> SELECT DISTINCT job,deptno

-> FROM emp;

USO DE COMODINES
20.-Seleccionar los nombres que inicien con S.
mysql> SELECT ename
-> FROM emp
-> WHERE ename LIKE 's%';

20.-Seleccionar las tuplas cuyo campo común es null.

mysql> SELECT * FROM emp WHERE comm IS NULL;

21.-Tambien se puede utilizar >= y <= para discriminar tuplas.

mysql> SELECT * FROM emp WHERE deptno=10;
mysql> SELECT * FROM emp WHERE sal>=3000;
mysql> SELECT * FROM emp WHERE sal<=3000;

22.-Seleccionar nombre, cargo, departamento, fecha de contratación y presentarlos

desde el más reciente al de mayor antigüedad.
mysql> SELECT ename, job, deptno, hiredate
-> FROM emp
-> ORDER BY hiredate DESC;

23.-Recuperar el número y el nombre de los empleados, mostrar su salrio anual, y

ordenarlos de acuerdo a éste último.
mysql> SELECT empno,ename,sal*12 'Salario Anual'
-> FROM emp
-> ORDER BY 'Salario Anual';

24.-borrar a los empleados con empno=0 y empno=1, verificar que existan antes de
borrarlos.
mysql> SELECT * FROM emp WHERE empno=0 or empno=1;
mysql> DELETE FROM emp WHERE empno=0;
mysql> DELETE FROM emp WHERE empno=1;
mysql> SELECT * FROM emp WHERE empno=0 or empno=1;

25.-Borrar a los empleados contratados en 1983, verificar si existen antes y

después.
mysql> SELECT * FROM emp
-> WHERE hiredate LIKE '1983%' ;

mysql> DELETE FROM emp

-> WHERE hiredate LIKE '1983%';

mysql> SELECT * FROM emp WHERE hiredate LIKE '1983%';

25.-Recuperar la infomración de los empleados que no sean analistas u oficinistas.

mysql> SELECT * FROM emp
-> WHERE job NOT IN ('Analyst','Clerk');

26.-Recuperar la información de los empleados que sean oficinistas y ganen más de

1000
mysql> SELECT * FROM emp WHERE job='Clerk' AND sal>1000;

27.-Modificar el salario del empleado 7844 a 2000. Nota: si se omite WHERE, el

valor se cambia en todos los renglones.
mysql> UPDATE emp
-> SET sal=2000
-> WHERE empno=7844;

28.-Recuperar la información de los empleados que ganan menos de 1000 o más de

1500. También se puede utilizar NOT BETWEEN.

29.-Recuperar la información de los empleados cuyo nombre no inicia con A.

mysql> SELECT * FROM emp WHERE ename NOT LIKE 'A%';

30.-Recuperar la información de los empleados de los departamentos 20 y 30 cuyo

salario es menor a 1000 o mayor a 2000.

31.-Cambiar la comisión de los empleados a 5420.14, para aquellos cuya comisión no

sea nula.

32.-Recuperar el salario promedio de los empleados.

33.-Contar cuantos empleados hay de cada cargo y agruparlos.

Tip: COUNT(job), GROUP BY JOB.

34.-Mostrar cuantos empleados son oficinistas

35.-Mostrar el número de registros de la tabla de empleados

36.-Decir cual es el salario más alto.

Tip: MAX(sal)

37.-Mostrar el promedio de los salarios de cada departamento ordenados de menor a

mayor.
Tip: AVB(sal), GROUP BY, ORDER BY.

38.-Agrupar a las personas de acuerdo a su jefe inmediato y mostrar la suma de sus

salarios.
Tip: Sum(sal)