UAM

Introducción al Diseño de Bases de Datos

Soto Hernández Christian

205318638

30-may-10

Práctica 1

Base de datos en MySQL

OBJETIVOS:
Realizar una serie de consultas en MySQL que originalmente son de ORACLE, resaltando
las diferencias entre los 2 lenguajes y haciendo comentarios de los resultados.

INTRODUCCION:
SQL es un lenguaje de consulta para bases de datos, basado en el modelo E-R, está dotado
de las expresiones necesarias para manipular de forma completa varios tipos de datos,
existen otros lenguajes de bases de datos como Access y MySQL, este último será el
utilizado en esta práctica.

DESARROLLO:
1. Creación de la tabla dept, en SQL se usa number() en lugar de int() y varchar2()
en lugar de varchar().
mysql> CREATE TABLE dept(
-> deptno int(2) PRIMARY KEY,
-> dname varchar(12),
-> loc varchar (11) );
Query OK, 0 rows affected (0.05 sec)

2. Descripción de los campos de la tabla dept.

mysql> describe dept;
+--------+-------------+------+-----+---------+-------+
| Field | Type | Null | Key | Default | Extra |
+--------+-------------+------+-----+---------+-------+
| deptno | int(2) | NO | PRI | NULL | |
| dname | varchar(12) | YES | | NULL | |
| loc | varchar(11) | YES | | NULL | |
+--------+-------------+------+-----+---------+-------+
3 rows in set (0.19 sec)

3. Insertar datos especificando el campo en el que se deben colocar.

mysql> INSERT INTO dept(deptno, dname, loc)
-> VALUES(10, 'ACCOUTING', 'NEW_YORK');
Query OK, 1 row affected (0.00 sec)

4. Insertar datos, debido a que el orden es el mismo que el de las columnas de la

tabla no es necesario especificar en que campo se colocan los datos.
mysql> INSERT INTO dept
-> VALUES(20, 'RESEARCH', 'DALLAS') ;
Query OK, 1 row affected (0.00 sec)

5. Inserción de datos
mysql> INSERT INTO dept
-> VALUES(30,'SALES','CHICAGO');
Query OK, 1 row affected (0.00 sec)

6. Inserción de datos
mysql> INSERT INTO dept
-> VALUES(40,'OPERATIONS','BOSTON');
Query OK, 1 row affected (0.00 sec)

7. Una consulta a la tabla dept, el carácter * indica que debe de traer toda la
informacion
mysql> SELECT *
-> FROM dept;
+--------+------------+----------+
| deptno | dname | loc |
+--------+------------+----------+
| 10 | ACCOUNTING | NEW_YORK |
| 20 | RESEARCH | DALLAS |
| 30 | SALES | CHICAGO |
| 40 | OPERATIONS | BOSTON |
+--------+------------+----------+
4 rows in set (0.00 sec)

8. Selección de los campos loc y dname de la tabla dept, a esto se le llama

proyección.
mysql> SELECT loc, dname
-> FROM dept;
+----------+------------+
| loc | dname |
+----------+------------+
| NEW_YORK | ACCOUNTING |
| DALLAS | RESEARCH |
| CHICAGO | SALES |
| BOSTON | OPERATIONS |
+----------+------------+
4 rows in set (0.00 sec)

9. Selección de todos los campos con restricción sobre el valor deptno, a esto se le
llama restricción.
mysql> SELECT *
-> FROM dept
-> WHERE deptno < 30;
+--------+------------+----------+
| deptno | dname | loc |
+--------+------------+----------+
| 10 | ACCOUNTING | NEW_YORK |
| 20 | RESEARCH | DALLAS |
+--------+------------+----------+
2 rows in set (0.06 sec)

10. Restriccion sobre una proyección.

mysql> SELECT loc, dname
-> FROM dept
-> WHERE deptno < 30;
+----------+------------+
| loc | dname |
+----------+------------+
| NEW_YORK | ACCOUNTING |
| DALLAS | RESEARCH |
+----------+------------+
2 rows in set (0.00 sec)

11. Creacion de la tabla empleados, en MySQL se usa decimal(7,2) en lugar de

number(7,2) de SQL.
mysql> drop TABLE emp;
Query OK, 0 rows affected (0.00 sec)

mysql> CREATE TABLE emp (

-> empno int(4) primary key,
-> ename varchar(11) not null,
-> job varchar(13) not null,
-> mgr int(4),
-> hiredate date not null,
-> sal decimal(7,2) not null,
 -> comm decimal(7,2),
-> deptno int(2),
-> foreign key (deptno) references dept (deptno),
-> foreign key (mgr) references emp (empno) );
Query OK, 0 rows affected (0.05 sec)

12. Descripción de la tabla emp.

mysql> describe emp;
+----------+--------------+------+-----+---------+-------+
| Field | Type | Null | Key | Default | Extra |
+----------+--------------+------+-----+---------+-------+
| empno | int(4) | NO | PRI | NULL | |
| ename | varchar(11) | NO | | NULL | |
| job | varchar(13) | NO | | NULL | |
| mgr | int(4) | YES | MUL | NULL | |
| hiredate | date | NO | | NULL | |
| sal | decimal(7,2) | NO | | NULL | |
| comm | decimal(7,2) | YES | | NULL | |
| deptno | int(2) | YES | MUL | NULL | |
+----------+--------------+------+-----+---------+-------+
8 rows in set (0.00 sec)

13. Insercion de datos

mysql> INSERT INTO emp
-> values(7839, 'king', 'presindent', null, '1981-11-17', 5000, null, 10 );
Query OK, 1 row affected (0.00 sec)

14. Los guientes 12 query’s son inserción de datos al igual que este
mysql> INSERT INTO emp
-> values(7698, 'blake', 'manager', 7839, '1981-05-01', 2850, null, 30 );
Query OK, 1 row affected (0.00 sec)

15.
mysql> INSERT INTO emp
-> values(7782, 'clark', 'manager', 7839, '1981-06-09', 2450, null, 10 );
Query OK, 1 row affected (0.00 sec)

16.
mysql> INSERT INTO emp
-> values(7566, 'jones', 'manager', 7839, '1981-04-02', 2975, null, 20 );
Query OK, 1 row affected (0.00 sec)

17.
mysql> INSERT INTO emp
-> values(7654, 'martin', 'salesman', 7698, '1981-09-28', 1250, 14000, 30 );

Query OK, 1 row affected (0.00 sec)

18.
mysql> INSERT INTO emp
-> values(7499, 'allen', 'salesman', 7698, '1981-02-20', 1600, 300, 30 );
Query OK, 1 row affected (0.00 sec)

19.
mysql> INSERT INTO emp
-> values(7844, 'turner', 'salesman', 7698, '1981-09-08', 1500, 0, 30 );
Query OK, 1 row affected (0.00 sec)

20.
mysql> INSERT INTO emp
-> values(7900, 'james', 'clerk', 7698, '1981-12-03', 950, null, 30 );
Query OK, 1 row affected (0.00 sec)

21.
mysql> INSERT INTO emp
-> values(7521, 'ward', 'salesman', 7698, '1981-02-22', 1250, 500, 30 );
Query OK, 1 row affected (0.00 sec)

22.
mysql> INSERT INTO emp
-> values(7902, 'ford', 'analyst', 7566, '1981-12-03', 3000, null, 20 );
Query OK, 1 row affected (0.00 sec)

23.
mysql> INSERT INTO emp
-> values(7369, 'smith', 'clerk', 7902, '1980-12-17', 800, null, 20 );
Query OK, 1 row affected (0.00 sec)

24.
mysql> INSERT INTO emp
-> values(7788, 'scott', 'analyst', 7566, '1982-12-09', 3000, null, 20 );
Query OK, 1 row affected (0.00 sec)

25.
mysql> INSERT INTO emp
-> values(7876, 'adams', 'clerk', 7788, '1983-01-12', 1100, null, 20 );
Query OK, 1 row affected (0.00 sec)

26.
mysql> INSERT INTO emp
-> values(7934, 'miller', 'clerk', 7782, '1982-01-23', 1300, null, 10 );
Query OK, 1 row affected (0.00 sec)

27. Selección de todos los campos de emp.

mysql> select *
-> from emp;
+-------+--------+------------+------+------------+---------+----------+--------
+
| empno | ename | job | mgr | hiredate | sal | comm | deptno
|
+-------+--------+------------+------+------------+---------+----------+--------
+
| 7839 | king | presindent | 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 | 14000.00 | 30
|
| 7499 | allen | salesman | 7698 | 1981-02-20 | 1600.00 | 300.00 | 30
|
| 7844 | 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
|
+-------+--------+------------+------+------------+---------+----------+--------
+
14 rows in set (0.00 sec)

28. Creacion de la tabla salarios.

mysql> CREATE TABLE salgrade (
-> grade int(1) primary key,
-> losal decimal(6,2) not null,
-> hisal decimal(6,2) not null);
Query OK, 0 rows affected (0.05 sec)

29. Descripcion de la tabla salario.

mysql> describe salgrade;
+-------+--------------+------+-----+---------+-------+
| Field | Type | Null | Key | Default | Extra |
+-------+--------------+------+-----+---------+-------+
| grade | int(1) | NO | PRI | NULL | |
| losal | decimal(6,2) | NO | | NULL | |
| hisal | decimal(6,2) | NO | | NULL | |
+-------+--------------+------+-----+---------+-------+
3 rows in set (0.00 sec)

30. Insercion de datos, al igual que en los siguientes 4 query’s.

mysql> INSERT INTO salgrade
-> values(1,700,1200);
Query OK, 1 row affected (0.00 sec)

31.
mysql> INSERT INTO salgrade
-> values(2,1201,1400);
Query OK, 1 row affected (0.00 sec)

32.
mysql> INSERT INTO salgrade
-> values(3,1401,2000);
Query OK, 1 row affected (0.00 sec)

33.
mysql> INSERT INTO salgrade
-> values(4,2001,3000);
Query OK, 1 row affected (0.00 sec)

34.
mysql> INSERT INTO salgrade
-> values(5,3001,9999);
Query OK, 1 row affected (0.00 sec)

35. Selección de todos los campos de la tabla salario.

mysql> select *
-> from 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 |
+-------+---------+---------+
5 rows in set (0.00 sec)

36. Selección de todos los campos con restricción en el valor del salario, se pueden
usar operadores binarios AND y OR en las expresiones de restricción.
mysql> select *
-> from salgrade
-> where losal > 1400 and hisal < 4000;
+-------+---------+---------+
| grade | losal | hisal |
+-------+---------+---------+
| 3 | 1401.00 | 2000.00 |
| 4 | 2001.00 | 3000.00 |
+-------+---------+---------+
2 rows in set (0.00 sec)

37. Proyeccion de la tabla emp sobre los valores nombre, fecha y salario.
mysql> select ename, hiredate, sal
-> from emp;
+--------+------------+---------+
| ename | hiredate | sal |
+--------+------------+---------+
| king | 1981-11-17 | 5000.00 |
| blake | 1981-05-01 | 2850.00 |
| clark | 1981-06-09 | 2450.00 |
| jones | 1981-04-02 | 2975.00 |
| martin | 1981-09-28 | 1250.00 |
| allen | 1981-02-20 | 1600.00 |
| turner | 1981-09-08 | 1500.00 |
| james | 1981-12-03 | 950.00 |
| ward | 1981-02-22 | 1250.00 |
| ford | 1981-12-03 | 3000.00 |
| smith | 1980-12-17 | 800.00 |
| scott | 1982-12-09 | 3000.00 |
| adams | 1983-01-12 | 1100.00 |
| miller | 1982-01-23 | 1300.00 |
+--------+------------+---------+
14 rows in set (0.00 sec)

38. Proyeccion de la tabla emp, dentro de la consulta se añade una columna que no
existe en la tabla original, esta se crea durante la consulta y contiene el
resultado de una expresión, en este caso una suma sobre el salario
mysql> select ename, sal, sal+300
-> from emp;
+--------+---------+---------+
| ename | sal | sal+300 |
+--------+---------+---------+
| king | 5000.00 | 5300.00 |
| blake | 2850.00 | 3150.00 |
| clark | 2450.00 | 2750.00 |
| jones | 2975.00 | 3275.00 |
| martin | 1250.00 | 1550.00 |
| allen | 1600.00 | 1900.00 |
| turner | 1500.00 | 1800.00 |
| james | 950.00 | 1250.00 |
| ward | 1250.00 | 1550.00 |
| ford | 3000.00 | 3300.00 |
| smith | 800.00 | 1100.00 |
| scott | 3000.00 | 3300.00 |
| adams | 1100.00 | 1400.00 |
| miller | 1300.00 | 1600.00 |
+--------+---------+---------+
14 rows in set (0.03 sec)

39. Proyeccion de la tabla emp, con un campo que vale “12*sal+100” es decir el salario
de un año más 100
mysql> select ename, sal, 12*sal+100
-> from emp;
+--------+---------+------------+
| ename | sal | 12*sal+100 |
+--------+---------+------------+
| king | 5000.00 | 60100.00 |
| blake | 2850.00 | 34300.00 |
| clark | 2450.00 | 29500.00 |
| jones | 2975.00 | 35800.00 |
| martin | 1250.00 | 15100.00 |
| allen | 1600.00 | 19300.00 |
| turner | 1500.00 | 18100.00 |
| james | 950.00 | 11500.00 |
| ward | 1250.00 | 15100.00 |
| ford | 3000.00 | 36100.00 |
| smith | 800.00 | 9700.00 |
| scott | 3000.00 | 36100.00 |
| adams | 1100.00 | 13300.00 |
| miller | 1300.00 | 15700.00 |
+--------+---------+------------+
14 rows in set (0.00 sec)

40. Proyeccion de la tabla emp, con un campo que tiene una expresión diferente a la
consulta anterior, pero el resultado es el mismo
mysql> select ename, sal, 100+sal*12
-> from emp;
+--------+---------+------------+
| ename | sal | 100+sal*12 |
+--------+---------+------------+
| king | 5000.00 | 60100.00 |
| blake | 2850.00 | 34300.00 |
| clark | 2450.00 | 29500.00 |
| jones | 2975.00 | 35800.00 |
| martin | 1250.00 | 15100.00 |
| allen | 1600.00 | 19300.00 |
| turner | 1500.00 | 18100.00 |
| james | 950.00 | 11500.00 |
| ward | 1250.00 | 15100.00 |
| ford | 3000.00 | 36100.00 |
| smith | 800.00 | 9700.00 |
| scott | 3000.00 | 36100.00 |
| adams | 1100.00 | 13300.00 |
| miller | 1300.00 | 15700.00 |
+--------+---------+------------+
14 rows in set (0.00 sec)

41. Debido a la precedencia de los operadores, la consulta anterior no entrego el

resultado deseado, para ello se pueden agrupar expresiones con paréntesis.
mysql> SELECT ename, sal, 12*(sal+100)
-> FROM emp;
+--------+---------+--------------+
| ename | sal | 12*(sal+100) |
+--------+---------+--------------+
| KING | 5000.00 | 61200.00 |
| BLAKE | 2850.00 | 35400.00 |
| CLARK | 2450.00 | 30600.00 |
| JONES | 2975.00 | 36900.00 |
| MARTIN | 1250.00 | 16200.00 |
| ALLEN | 1600.00 | 20400.00 |
| TURNER | 1500.00 | 19200.00 |
| JAMES | 950.00 | 12600.00 |
| WARD | 1250.00 | 16200.00 |
| FORD | 3000.00 | 37200.00 |
| SMITH | 800.00 | 10800.00 |
| SCOTT | 3000.00 | 37200.00 |
| ADAMS | 1100.00 | 14400.00 |
| MILLER | 1300.00 | 16800.00 |
+--------+---------+--------------+
14 rows in set (0.00 sec)

42. Consulta repetida.

43. Proyección de la tabla emp, debido a que no todos los empleados tienen comisión
aparece la leyenda NULL en su lugar.
mysql> SELECT ename, job, sal, comm
-> FROM emp;
+--------+-----------+---------+---------+
| ename | job | sal | comm |
+--------+-----------+---------+---------+
| KING | PRESIDENT | 5000.00 | NULL |
| BLAKE | MANAGER | 2850.00 | NULL |
| CLARK | MANAGER | 2450.00 | NULL |
| JONES | MANAGER | 2975.00 | NULL |
| MARTIN | SALESMAN | 1250.00 | 1400.00 |
| ALLEN | SALESMAN | 1600.00 | 300.00 |
| TURNER | SALESMAN | 1500.00 | 0.00 |
| JAMES | CLERK | 950.00 | NULL |
| WARD | SALESMAN | 1250.00 | 500.00 |
| FORD | ANALYST | 3000.00 | NULL |
| SMITH | CLERK | 800.00 | NULL |
| SCOTT | ANALYST | 3000.00 | NULL |
| ADAMS | CLERK | 1100.00 | NULL |
| MILLER | CLERK | 1300.00 | NULL |
+--------+-----------+---------+---------+
14 rows in set (0.00 sec)

44. Restricción sobre una proyección.

mysql> SELECT ename, sal, 12*(sal+100)
-> FROM emp
-> WHERE ename='KING';
+-------+---------+--------------+
| ename | sal | 12*(sal+100) |
+-------+---------+--------------+
| KING | 5000.00 | 61200.00 |
+-------+---------+--------------+
1 row in set (0.00 sec)

45. Restricción sobre una proyección mas pequeña.

mysql> SELECT ename, 12*sal+comm
-> FROM emp
-> WHERE ename='KING';
+-------+-------------+
| ename | 12*sal+comm |
+-------+-------------+
| KING | NULL |
+-------+-------------+
1 row in set (0.00 sec)

46. Proyeccion de la tabla emp, con cambio del título de columna con la instrucción AS
mysql> SELECT ename AS nombre, sal AS salario
-> FROM emp;
+--------+---------+
| nombre | salario |
+--------+---------+
| KING | 5000.00 |
| BLAKE | 2850.00 |
| CLARK | 2450.00 |
| JONES | 2975.00 |
| MARTIN | 1250.00 |
| ALLEN | 1600.00 |
| TURNER | 1500.00 |
| JAMES | 950.00 |
| WARD | 1250.00 |
| FORD | 3000.00 |
| SMITH | 800.00 |
| SCOTT | 3000.00 |
| ADAMS | 1100.00 |
| MILLER | 1300.00 |
+--------+---------+
14 rows in set (0.09 sec)

47. Es posible usar títulos con varias separadas con espacio usando comillas dobles
para indicar el inicio y final de la cadena de texto
mysql> SELECT ename as Nombre, 12*sal as "salario anual"
-> FROM emp;
+--------+---------------+
| Nombre | salario anual |
+--------+---------------+
| KING | 60000.00 |
| BLAKE | 34200.00 |
| CLARK | 29400.00 |
| JONES | 35700.00 |
| MARTIN | 15000.00 |
| ALLEN | 19200.00 |
| TURNER | 18000.00 |
| JAMES | 11400.00 |
| WARD | 15000.00 |
| FORD | 36000.00 |
| SMITH | 9600.00 |
| SCOTT | 36000.00 |
| ADAMS | 13200.00 |
| MILLER | 15600.00 |
+--------+---------------+
14 rows in set (0.01 sec)

48. Uso de la función CONCAT(str1,str2) en SQL se puede usar str1 || str2 para
concatenar dos cadenas.
mysql> SELECT concat(ename,job) as empleado
-> FROM emp;
+----------------+
| empleado |
+----------------+
| KINGPRESIDENT |
| BLAKEMANAGER |
| CLARKMANAGER |
| JONESMANAGER |
| MARTINSALESMAN |
| ALLENSALESMAN |
| TURNERSALESMAN |
| JAMESCLERK |
| WARDSALESMAN |
| FORDANALYST |
| SMITHCLERK |
| SCOTTANALYST |
| ADAMSCLERK |
| MILLERCLERK |
+----------------+
14 rows in set (0.00 sec)

49. La función concat() puede recibir más de 2 argumentos y estos pueden ser cadenas
de texto definidas con comilla simple.
mysql> SELECT concat(ename,' is a ',job) AS "Detalles de empleo"
-> FROM emp;
+----------------------+
| Detalles de empleo |
+----------------------+
| KING is a PRESIDENT |
| BLAKE is a MANAGER |
| CLARK is a MANAGER |
| JONES is a MANAGER |
| MARTIN is a SALESMAN |
| ALLEN is a SALESMAN |
| TURNER is a SALESMAN |
| JAMES is a CLERK |
| WARD is a SALESMAN |
| FORD is a ANALYST |
| SMITH is a CLERK |
| SCOTT is a ANALYST |
| ADAMS is a CLERK |
| MILLER is a CLERK |
+----------------------+
14 rows in set (0.05 sec)

50. El uso de la expresión DISTINCT permite que se ignoren los valores repetidos de un
campo.
mysql> SELECT distinct deptno
-> FROM emp;
+--------+
| deptno |
+--------+
| 10 |
| 20 |
| 30 |
+--------+
3 rows in set (0.01 sec)

51. LA expresión DISTINCT afecta a todos los campos que le siguen asi que en este
query, se obtiene como resultado una única combinación deptno-job.
mysql> SELECT distinct deptno, job
-> FROM emp;
+--------+-----------+
| deptno | job |
+--------+-----------+
| 10 | PRESIDENT |
| 30 | MANAGER |
| 10 | MANAGER |
| 20 | MANAGER |
| 30 | SALESMAN |
| 30 | CLERK |
| 20 | ANALYST |
| 20 | CLERK |
| 10 | CLERK |
+--------+-----------+
9 rows in set (0.02 sec)

52. Restricción de job sobre proyección de emp.

mysql> SELECT ename, job, deptno
-> FROM emp
-> WHERE job= 'CLERK';
+--------+-------+--------+
| ename | job | deptno |
+--------+-------+--------+
| JAMES | CLERK | 30 |
| SMITH | CLERK | 20 |
| ADAMS | CLERK | 20 |
| MILLER | CLERK | 10 |
+--------+-------+--------+
4 rows in set (0.00 sec)

53. Restricción de un aproyección.

mysql> SELECT ename, sal, comm
-> FROM emp
-> WHERE sal <=comm;
+--------+---------+---------+
| ename | sal | comm |
+--------+---------+---------+
| MARTIN | 1250.00 | 1400.00 |
+--------+---------+---------+
1 row in set (0.00 sec)

54. Expresion x BETWEEN val1 AND val2 es equivalente a ”x < val1 AND > val2”
mysql> SELECT ename, sal
-> FROM emp
-> WHERE sal between 1000 AND 1500;
+--------+---------+
| ename | sal |
+--------+---------+
| MARTIN | 1250.00 |
| TURNER | 1500.00 |
| WARD | 1250.00 |
| ADAMS | 1100.00 |
| MILLER | 1300.00 |
+--------+---------+
5 rows in set (0.00 sec)

55. Expresion IN(x1,x2,x3,…) representa una lista de valores discretos.

mysql> SELECT empno, ename, sal, mgr
-> FROM emp
-> WHERE mgr in (7902,7566,7788);
+-------+-------+---------+------+
| empno | ename | sal | mgr |
+-------+-------+---------+------+
| 7902 | FORD | 3000.00 | 7566 |
| 7369 | SMITH | 800.00 | 7902 |
| 7788 | SCOTT | 3000.00 | 7566 |
| 7876 | ADAMS | 1100.00 | 7788 |
+-------+-------+---------+------+
4 rows in set (0.00 sec)

56. La expresión IN() puede contener diferentes tipos de valores en este caso texto.
mysql> SELECT empno, ename, mgr, deptno
-> FROM emp
-> WHERE ename in ('FORD','ALLEN');
+-------+-------+------+--------+
| empno | ename | mgr | deptno |
+-------+-------+------+--------+
| 7499 | ALLEN | 7698 | 30 |
| 7902 | FORD | 7566 | 20 |
+-------+-------+------+--------+
2 rows in set (0.00 sec)

57. Expresion LIKE permite comparar cadenas de caracteres de las cuales se conosca
información parcial, usando el signo de porcentaje se le indica que representa uno
o varios caracteres desconocidos; en este caso se usa para decir que la palabra
empieza con ‘s’.
mysql> SELECT ename
-> FROM emp
-> WHERE ename LIKE 's%';
+-------+
| ename |
+-------+
| SMITH |
| SCOTT |
+-------+
2 rows in set (0.02 sec)

58. LIKE también se puede usar con valores de fecha, pero hay que tener en cuenta la
forma en la que se escribe la fecha ya que en SQL se usa dd/mm/yy y en MySQL yyyy-
mm-dd.
mysql> SELECT ename, hiredate
-> FROM emp
-> WHERE hiredate LIKE '1981%';
+--------+------------+
| ename | hiredate |
+--------+------------+
| KING | 1981-11-17 |
| BLAKE | 1981-05-01 |
| CLARK | 1981-06-09 |
| JONES | 1981-04-02 |
| MARTIN | 1981-09-28 |
| ALLEN | 1981-02-20 |
| TURNER | 1981-09-08 |
| JAMES | 1981-12-03 |
| WARD | 1981-02-22 |
| FORD | 1981-12-03 |
+--------+------------+
10 rows in set, 1 warning (0.00 sec)

59. Al usar LIKE se puede usar el guion bajo para representar que existe un único
carácter desconocido, para este caso se indica que el segundo carácter de la
palabra es ‘a’
mysql> SELECT ename
-> FROM emp
-> WHERE ename LIKE '_A%';
+--------+
| ename |
+--------+
| MARTIN |
| JAMES |
| WARD |
+--------+
3 rows in set (0.00 sec)

60. Debido a que el carácter _ puede representar cualquier letra no se puede usar para
decir que el carácter que se busca es un guion bajo pues la consulta entregaría
este resultado.
mysql> SELECT *
-> FROM dept
-> WHERE loc LIKE '%_%';
+--------+------------+----------+
| deptno | dname | loc |
+--------+------------+----------+
| 10 | ACCOUNTING | NEW_YORK |
| 20 | RESEARCH | DALLAS |
| 30 | SALES | CHICAGO |
| 40 | OPERATIONS | BOSTON |
+--------+------------+----------+
4 rows in set (0.00 sec)

61. Si se desea que el guion bajo se interpretado como el valor de un carácter y no

como comodín, debe usarse diagonal invertida.
mysql> SELECT *
-> FROM dept
-> WHERE loc LIKE '%\_%';
+--------+------------+----------+
| deptno | dname | loc |
+--------+------------+----------+
| 10 | ACCOUNTING | NEW_YORK |
+--------+------------+----------+
1 row in set (0.00 sec)

62. También es posible hacer una consulta donde la restricción sea un valor nullo
mysql> SELECT ename, mgr
-> FROM emp
-> WHERE mgr is null;
+-------+------+
| ename | mgr |
+-------+------+
| KING | NULL |
+-------+------+
1 row in set (0.00 sec)

63. Otra consulta donde la condición es un valor nullo

mysql> SELECT ename, job, comm
-> FROM emp
-> WHERE comm is null;
+--------+-----------+------+
| ename | job | comm |
+--------+-----------+------+
| KING | PRESIDENT | NULL |
| BLAKE | MANAGER | NULL |
| CLARK | MANAGER | NULL |
| JONES | MANAGER | NULL |
| JAMES | CLERK | NULL |
| FORD | ANALYST | NULL |
| SMITH | CLERK | NULL |
| SCOTT | ANALYST | NULL |
| ADAMS | CLERK | NULL |
| MILLER | CLERK | NULL |
+--------+-----------+------+
10 rows in set (0.00 sec)

64. Otra consulta donde se usa el operador AND para ser más específicos en el
resultado.
mysql> SELECT empno, ename, job, sal
-> FROM emp
-> WHERE sal >= 1100
-> AND job = 'CLERK';
+-------+--------+-------+---------+
| empno | ename | job | sal |
+-------+--------+-------+---------+
| 7876 | ADAMS | CLERK | 1100.00 |
| 7934 | MILLER | CLERK | 1300.00 |
+-------+--------+-------+---------+
2 rows in set (0.00 sec)

65. Esta consulta es parecida a la anterior, con la diferencia que el operador usado
en OR lo que aumenta la cantidad de resultados.
mysql> SELECT empno, ename, job, sal
-> FROM emp
-> WHERE sal >= 1100
-> OR job = 'CLERK';
+-------+--------+-----------+---------+
| empno | ename | job | sal |
+-------+--------+-----------+---------+
| 7839 | KING | PRESIDENT | 5000.00 |
| 7698 | BLAKE | MANAGER | 2850.00 |
| 7782 | CLARK | MANAGER | 2450.00 |
| 7566 | JONES | MANAGER | 2975.00 |
| 7564 | MARTIN | SALESMAN | 1250.00 |
| 7499 | ALLEN | SALESMAN | 1600.00 |
| 7844 | TURNER | SALESMAN | 1500.00 |
| 7900 | JAMES | CLERK | 950.00 |
| 7521 | WARD | SALESMAN | 1250.00 |
| 7902 | FORD | ANALYST | 3000.00 |
| 7369 | SMITH | CLERK | 800.00 |
| 7788 | SCOTT | ANALYST | 3000.00 |
| 7876 | ADAMS | CLERK | 1100.00 |
| 7934 | MILLER | CLERK | 1300.00 |
+-------+--------+-----------+---------+
14 rows in set (0.00 sec)

66. Esta vez se añade un operador unario, el de negación, en combinación con IN ayuda
a eliminar resultados que no nos interesan
mysql> SELECT ename, job
-> FROM emp
-> WHERE job NOT IN ('CLERK','MANAGER', 'ANALYST');
+--------+-----------+
| ename | job |
+--------+-----------+
| KING | PRESIDENT |
| MARTIN | SALESMAN |
| ALLEN | SALESMAN |
| TURNER | SALESMAN |
| WARD | SALESMAN |
+--------+-----------+
5 rows in set (0.00 sec)

67. El operador not puede usarse con cualquier restricción.

mysql> SELECT ename, job, sal
-> FROM emp
-> WHERE sal not between 1000 AND 1500;
+-------+-----------+---------+
| ename | job | sal |
+-------+-----------+---------+
| KING | PRESIDENT | 5000.00 |
| BLAKE | MANAGER | 2850.00 |
| CLARK | MANAGER | 2450.00 |
| JONES | MANAGER | 2975.00 |
| ALLEN | SALESMAN | 1600.00 |
| JAMES | CLERK | 950.00 |
| FORD | ANALYST | 3000.00 |
| SMITH | CLERK | 800.00 |
| SCOTT | ANALYST | 3000.00 |
+-------+-----------+---------+
9 rows in set (0.00 sec)

68. En esta consulta se usa el operador not para eliminar los resultados cuyos nombres
contengan una A.
mysql> SELECT ename, sal, job
-> FROM emp
-> WHERE ename not LIKE '%A%';
+--------+---------+-----------+
| ename | sal | job |
+--------+---------+-----------+
| KING | 5000.00 | PRESIDENT |
| JONES | 2975.00 | MANAGER |
| TURNER | 1500.00 | SALESMAN |
| FORD | 3000.00 | ANALYST |
| SMITH | 800.00 | CLERK |
| SCOTT | 3000.00 | ANALYST |
| MILLER | 1300.00 | CLERK |
+--------+---------+-----------+
7 rows in set (0.00 sec)

69. Es sintácticamente incorrecto escribir not is null, se debe usar is not null como
en la siguiente consulta.
mysql> SELECT ename, sal, comm
-> FROM emp
-> WHERE comm is not null;
+--------+---------+---------+
| ename | sal | comm |
+--------+---------+---------+
| MARTIN | 1250.00 | 1400.00 |
| ALLEN | 1600.00 | 300.00 |
| TURNER | 1500.00 | 0.00 |
| WARD | 1250.00 | 500.00 |
+--------+---------+---------+
4 rows in set (0.00 sec)

70. Una consulta donde se usan los operadores AND y OR.

mysql> SELECT ename, job, sal
-> FROM emp
-> WHERE job='SALESMAN'
-> OR job='PRESIDENT'
-> AND sal >1500;
+--------+-----------+---------+
| ename | job | sal |
+--------+-----------+---------+
| KING | PRESIDENT | 5000.00 |
| MARTIN | SALESMAN | 1250.00 |
| ALLEN | SALESMAN | 1600.00 |
| TURNER | SALESMAN | 1500.00 |
| WARD | SALESMAN | 1250.00 |
+--------+-----------+---------+
5 rows in set (0.00 sec)

71. Debido a que existe una precedencia de los operadores (NOT, AND, OR) la consulta
anterior no entrego el resultado deseado, para corregirlo es posible usar
paréntesis y así especificar lo que se desea.
mysql> SELECT ename, job, sal
-> FROM emp
-> WHERE (job='SALESMAN'
-> OR job='PRESIDENT')
-> AND sal >1500;
+-------+-----------+---------+
| ename | job | sal |
+-------+-----------+---------+
| KING | PRESIDENT | 5000.00 |
| ALLEN | SALESMAN | 1600.00 |
+-------+-----------+---------+
2 rows in set (0.00 sec)

72. Es posible elegir el orden en el que aparezcan los resultados, para eso se usa la
expresión ORDER BY.
mysql> SELECT ename, job, deptno, hiredate
-> FROM emp
-> ORDER BY hiredate;
+--------+-----------+--------+------------+
| ename | job | deptno | hiredate |
+--------+-----------+--------+------------+
| SMITH | CLERK | 20 | 1980-12-17 |
| ALLEN | SALESMAN | 30 | 1981-02-20 |
| WARD | SALESMAN | 30 | 1981-02-22 |
| JONES | MANAGER | 20 | 1981-04-02 |
| BLAKE | MANAGER | 30 | 1981-05-01 |
| CLARK | MANAGER | 10 | 1981-06-09 |
| TURNER | SALESMAN | 30 | 1981-09-08 |
| MARTIN | SALESMAN | 30 | 1981-09-28 |
| KING | PRESIDENT | 10 | 1981-11-17 |
| FORD | ANALYST | 20 | 1981-12-03 |
| JAMES | CLERK | 30 | 1981-12-03 |
| MILLER | CLERK | 10 | 1982-01-23 |
| SCOTT | ANALYST | 20 | 1982-12-09 |
| ADAMS | CLERK | 20 | 1983-01-12 |
+--------+-----------+--------+------------+
14 rows in set (0.02 sec)

73. Al usar ORDER BY el resultado se entrega de forma ascendente, si se quiere en

forma descendente se añade DESC.
mysql> SELECT ename, job, deptno, hiredate, sal
-> FROM emp
-> ORDER BY sal desc;
+--------+-----------+--------+------------+---------+
| ename | job | deptno | hiredate | sal |
+--------+-----------+--------+------------+---------+
| KING | PRESIDENT | 10 | 1981-11-17 | 5000.00 |
| SCOTT | ANALYST | 20 | 1982-12-09 | 3000.00 |
| FORD | ANALYST | 20 | 1981-12-03 | 3000.00 |
| JONES | MANAGER | 20 | 1981-04-02 | 2975.00 |
| BLAKE | MANAGER | 30 | 1981-05-01 | 2850.00 |
| CLARK | MANAGER | 10 | 1981-06-09 | 2450.00 |
| ALLEN | SALESMAN | 30 | 1981-02-20 | 1600.00 |
| TURNER | SALESMAN | 30 | 1981-09-08 | 1500.00 |
| MILLER | CLERK | 10 | 1982-01-23 | 1300.00 |
| WARD | SALESMAN | 30 | 1981-02-22 | 1250.00 |
| MARTIN | SALESMAN | 30 | 1981-09-28 | 1250.00 |
| ADAMS | CLERK | 20 | 1983-01-12 | 1100.00 |
| JAMES | CLERK | 30 | 1981-12-03 | 950.00 |
| SMITH | CLERK | 20 | 1980-12-17 | 800.00 |
+--------+-----------+--------+------------+---------+
14 rows in set (0.02 sec)

74. Otro ejemplo del uso de la sentencia ORDER BY.

mysql> SELECT empno, ename, sal*12 as sal_anual
-> FROM emp
-> ORDER BY sal_anual;
+-------+--------+-----------+
| empno | ename | sal_anual |
+-------+--------+-----------+
| 7369 | SMITH | 9600.00 |
| 7900 | JAMES | 11400.00 |
| 7876 | ADAMS | 13200.00 |
| 7521 | WARD | 15000.00 |
| 7564 | MARTIN | 15000.00 |
| 7934 | MILLER | 15600.00 |
| 7844 | TURNER | 18000.00 |
| 7499 | ALLEN | 19200.00 |
| 7782 | CLARK | 29400.00 |
| 7698 | BLAKE | 34200.00 |
| 7566 | JONES | 35700.00 |
| 7902 | FORD | 36000.00 |
| 7788 | SCOTT | 36000.00 |
| 7839 | KING | 60000.00 |
+-------+--------+-----------+
14 rows in set (0.00 sec)

75. Al igual que con la expresión DISTINCT, ORDER BY puede afectar a más de un
argumento, en este caso se ordena por departamento y cada departamento por
salario.
mysql> SELECT ename, deptno, sal
-> FROM emp
-> ORDER BY deptno, sal desc;
+--------+--------+---------+
| ename | deptno | sal |
+--------+--------+---------+
| KING | 10 | 5000.00 |
| CLARK | 10 | 2450.00 |
| MILLER | 10 | 1300.00 |
| SCOTT | 20 | 3000.00 |
| FORD | 20 | 3000.00 |
| JONES | 20 | 2975.00 |
| ADAMS | 20 | 1100.00 |
| SMITH | 20 | 800.00 |
| BLAKE | 30 | 2850.00 |
| ALLEN | 30 | 1600.00 |
| TURNER | 30 | 1500.00 |
| WARD | 30 | 1250.00 |
| MARTIN | 30 | 1250.00 |
| JAMES | 30 | 950.00 |
+--------+--------+---------+
14 rows in set (0.00 sec)
 76. Consulta igual a la anterior sin mostrar la columna del departamento.
mysql> SELECT ename, sal
-> FROM emp
-> ORDER BY deptno, sal desc;
+--------+---------+
| ename | sal |
+--------+---------+
| KING | 5000.00 |
| CLARK | 2450.00 |
| MILLER | 1300.00 |
| SCOTT | 3000.00 |
| FORD | 3000.00 |
| JONES | 2975.00 |
| ADAMS | 1100.00 |
| SMITH | 800.00 |
| BLAKE | 2850.00 |
| ALLEN | 1600.00 |
| TURNER | 1500.00 |
| WARD | 1250.00 |
| MARTIN | 1250.00 |
| JAMES | 950.00 |
+--------+---------+
14 rows in set (0.00 sec)

77. Entre las funciones con las que cuenta SQL y MySQL poseen algunas para manejar
cadenas de texto, anteriormente se uso la de concatenación, aquí se muestra el uso
de lower() que sirve para cambiar a minúsculas el contenido de una cadena de
texto.
mysql> SELECT concat('El cargo de ', ename,’ es ',lower(job)) as "Detalle de empleo"
-> FROM emp;
+--------------------------------+
| Detalle de empleo |
+--------------------------------+
| El cargo de KING es president |
| El cargo de BLAKE es manager |
| El cargo de CLARK es manager |
| El cargo de JONES es manager |
| El cargo de MARTIN es salesman |
| El cargo de ALLEN es salesman |
| El cargo de TURNER es salesman |
| El cargo de JAMES es clerk |
| El cargo de WARD es salesman |
| El cargo de FORD es analyst |
| El cargo de SMITH es clerk |
| El cargo de SCOTT es analyst |
| El cargo de ADAMS es clerk |
| El cargo de MILLER es clerk |
+--------------------------------+
14 rows in set (0.00 sec)

78. También se cuenta con la función UPPER() que realiza la acción inversa de lower(),
es decir cambia a mayúsculas el contenido de una cadena de texto.
mysql> SELECT empno, ename, deptno
-> FROM emp
-> WHERE ename=upper('blake');
+-------+-------+--------+
| empno | ename | deptno |
+-------+-------+--------+
| 7698 | BLAKE | 30 |
+-------+-------+--------+
1 row in set (0.00 sec)
79. La función INITCAP() sirve para cambiar a mayúscula la primera letra de una cadena
de texto.
mysql> SELECT empno, INITCAP(enmae), deptno
-> FROM emp
-> WHERE ename=UPPER('blake');
ERROR 1305 (42000): FUNCTION test.INITCAP does not exist

Pero esta función solo existe en SQL, para obtener el mismo resultado se puede hacer una
concatenación de dos subcadenas de la cadena principal, además de que primero hay que
revisar que la cadena tenga más de una letra, a continuación se muestra un ejemplo de
cómo sería la expresión que equivaldría a INITCAP(), sin embargo ya que es una expresión
muy larga es mejor abstenerse de usarla y conformarse con el resultado sin ella.
mysql> SELECT empno, IF(LENGTH(ename)>1,CONCAT(UPPER(LEFT(ename,1)),LOWER(RIGHT(
ename,LENGTH(ename)-1))),UPPER(ename)) AS inimayusc, deptno
-> FROM emp
-> WHERE ename=UPPER('blake');
+-------+-----------+--------+
| empno | inimayusc | deptno |
+-------+-----------+--------+
| 7698 | Blake | 30 |
+-------+-----------+--------+
1 row in set (0.00 sec)

80. Algunas otras de las funciones de texto son LENGTH() que sirve para conocer la
longitud de una cadena de texto, pero hay que tener cuidado al usarla pues lo que
mide es la cantidad de bytes, si la cadena está formada por caracteres de 2 bytes
entregara un resultado del doble del que en realidad es; por otro lado tenemos la
función INSTR() que devuelve la posición de un caracter dentro de una cadena.
mysql> SELECT ename, concat(ename,job), length(ename), instr(ename,'A')
-> FROM emp
-> WHERE substr(job,1,5)='SALES';
+--------+-------------------+---------------+------------------+
| ename | concat(ename,job) | length(ename) | instr(ename,'A') |
+--------+-------------------+---------------+------------------+
| MARTIN | MARTINSALESMAN | 6 | 2 |
| ALLEN | ALLENSALESMAN | 5 | 1 |
| TURNER | TURNERSALESMAN | 6 | 0 |
| WARD | WARDSALESMAN | 4 | 2 |
+--------+-------------------+---------------+------------------+
4 rows in set (0.03 sec)

81. De las funciones de cadenas una es la de substr() que devuelve una cadena de otra
donde se le indica de que punto comenzar y cuantos caracteres tomar, si el valor
de posición es negativo la cuenta se toma desde el final.
mysql> SELECT ename, concat(ename,job), length(ename), instr(ename, 'A')
-> FROM emp
-> WHERE substr(ename, -1,1)='N';
+--------+-------------------+---------------+-------------------+
| ename | concat(ename,job) | length(ename) | instr(ename, 'A') |
+--------+-------------------+---------------+-------------------+
| MARTIN | MARTINSALESMAN | 6 | 2 |
| ALLEN | ALLENSALESMAN | 5 | 1 |
+--------+-------------------+---------------+-------------------+
2 rows in set (0.14 sec)

82. La función trúncate() sirve para limitar el número de decimales que se van a tomar
encuenta de un resultado.
mysql> SELECT ename, truncate(sal/3,3)
-> FROM emp;
+--------+-------------------+
| ename | truncate(sal/3,3) |
+--------+-------------------+
| KING | 1666.666 |
| BLAKE | 950.000 |
| CLARK | 816.666 |
| JONES | 991.666 |
| MARTIN | 416.666 |
| ALLEN | 533.333 |
| TURNER | 500.000 |
| JAMES | 316.666 |
| WARD | 416.666 |
| FORD | 1000.000 |
| SMITH | 266.666 |
| SCOTT | 1000.000 |
| ADAMS | 366.666 |
| MILLER | 433.333 |
+--------+-------------------+
14 rows in set (0.01 sec)

83. La función MOD() devuelve el residuo de la división de sus argumentos, si la

división es entre cero, regresa nulo y si la división no es mayor a 1, regresa el
primer argumento.
mysql> SELECT ename, sal comm, MOD(sal, comm)
-> FROM emp
-> WHERE job='SALESMAN';
+--------+---------+----------------+
| ename | comm | MOD(sal, comm) |
+--------+---------+----------------+
| MARTIN | 1250.00 | 1250.00 |
| ALLEN | 1600.00 | 100.00 |
| TURNER | 1500.00 | NULL |
| WARD | 1250.00 | 250.00 |
+--------+---------+----------------+
4 rows in set (0.00 sec)

84. También se tienen funciones para operar con fechas, la función CURDATE() es
equivalente a CURRENT_DATE() y CURRENT_DATE, y devuelven el valor de la fecha
actual.
mysql> SELECT ename, (CURRENT_DATE-hiredate)/7 Semanas
-> FROM emp
-> WHERE deptno=10;
+--------+-----------------+
| ename | Semanas |
+--------+-----------------+
| KING | 41343.428571429 |
| CLARK | 41416 |
| MILLER | 40056.857142857 |
+--------+-----------------+
3 rows in set (0.02 sec)

85. 85
Vaico

86. 86
Vacio

87. 87
Vacio

88. 88
Vacio

89. 89
Vacio

90. 90
Vacio

91. 91
Vacio

92. 92
Vacio

93. 93
Vacio

94. 94
Vacio

95. 95
Vacio

96. Hacer una consulta de dos bases diferentes al mismo tiempo debe ser realizada
cuidadosamente, pues si se hace de la forma en que se muestra a continuación, lo
que se obtiene es el producto cartesiano, es decir todas las combinaciones
posibles entre los elementos de ambas tablas.
mysql> SELECT ename, dname
-> FROM emp, dept;
+--------+------------+
| ename | dname |
+--------+------------+
| KING | ACCOUNTING |
| KING | RESEARCH |
| KING | SALES |
| KING | OPERATIONS |
| BLAKE | ACCOUNTING |
| BLAKE | RESEARCH |
| BLAKE | SALES |
| BLAKE | OPERATIONS |
| CLARK | ACCOUNTING |
| CLARK | RESEARCH |
| CLARK | SALES |
| CLARK | OPERATIONS |
| JONES | ACCOUNTING |
| JONES | RESEARCH |
| JONES | SALES |
| JONES | OPERATIONS |
| MARTIN | ACCOUNTING |
| MARTIN | RESEARCH |
| MARTIN | SALES |
| MARTIN | OPERATIONS |
| ALLEN | ACCOUNTING |
| ALLEN | RESEARCH |
| ALLEN | SALES |
| ALLEN | OPERATIONS |
| TURNER | ACCOUNTING |
| TURNER | RESEARCH |
| TURNER | SALES |
| TURNER | OPERATIONS |
| JAMES | ACCOUNTING |
| JAMES | RESEARCH |
| JAMES | SALES |
| JAMES | OPERATIONS |
| WARD | ACCOUNTING |
| WARD | RESEARCH |
| WARD | SALES |
| WARD | OPERATIONS |
| FORD | ACCOUNTING |
| FORD | RESEARCH |
| FORD | SALES |
| FORD | OPERATIONS |
| SMITH | ACCOUNTING |
| SMITH | RESEARCH |
| SMITH | SALES |
| SMITH | OPERATIONS |
| SCOTT | ACCOUNTING |
| SCOTT | RESEARCH |
| SCOTT | SALES |
| SCOTT | OPERATIONS |
| ADAMS | ACCOUNTING |
| ADAMS | RESEARCH |
| ADAMS | SALES |
| ADAMS | OPERATIONS |
| MILLER | ACCOUNTING |
| MILLER | RESEARCH |
| MILLER | SALES |
| MILLER | OPERATIONS |
+--------+------------+
56 rows in set (0.00 sec)

97. Las dos tablas, están relacionadas entre si debido a una llave foránea, lo que
sirve como restricción del producto cartesiano, en este caso el número de
departamento.
mysql> SELECT empno, ename, emp.deptno, loc
-> FROM emp, dept
-> WHERE emp.deptno=dept.deptno
-> AND ename='KING';
+-------+-------+--------+----------+
| empno | ename | deptno | loc |
+-------+-------+--------+----------+
| 7839 | KING | 10 | NEW_YORK |
+-------+-------+--------+----------+
1 row in set (0.00 sec)
98. Debido a que las dos tablas cuentan con el mismo campo “deptno” es necesario
especificar de qué tabla se toma el valor, para ello se usa el nombre de la tabla
seguido de un punto y el nombre del campo.
mysql> SELECT emp.empno, emp.ename, emp.deptno, dept.deptno, dept.loc
-> FROM emp, dept
-> WHERE emp.deptno=dept.deptno;
+-------+--------+--------+--------+----------+
| empno | ename | deptno | deptno | loc |
+-------+--------+--------+--------+----------+
| 7839 | KING | 10 | 10 | NEW_YORK |
| 7782 | CLARK | 10 | 10 | NEW_YORK |
| 7934 | MILLER | 10 | 10 | NEW_YORK |
| 7566 | JONES | 20 | 20 | DALLAS |
| 7902 | FORD | 20 | 20 | DALLAS |
| 7369 | SMITH | 20 | 20 | DALLAS |
| 7788 | SCOTT | 20 | 20 | DALLAS |
| 7876 | ADAMS | 20 | 20 | DALLAS |
| 7698 | BLAKE | 30 | 30 | CHICAGO |
| 7564 | MARTIN | 30 | 30 | CHICAGO |
| 7499 | ALLEN | 30 | 30 | CHICAGO |
| 7844 | TURNER | 30 | 30 | CHICAGO |
| 7900 | JAMES | 30 | 30 | CHICAGO |
| 7521 | WARD | 30 | 30 | CHICAGO |
+-------+--------+--------+--------+----------+
14 rows in set (0.00 sec)

99. No es necesario escribir el nombre completo de la tabla, se puede usar un alias,

pero este se debe definir en la expresión FROM.
mysql> SELECT e.empno, e.ename, e.deptno, d.deptno, d.loc
-> FROM emp e, dept d
-> WHERE d.deptno=e.deptno;
+-------+--------+--------+--------+----------+
| empno | ename | deptno | deptno | loc |
+-------+--------+--------+--------+----------+
| 7839 | KING | 10 | 10 | NEW_YORK |
| 7782 | CLARK | 10 | 10 | NEW_YORK |
| 7934 | MILLER | 10 | 10 | NEW_YORK |
| 7566 | JONES | 20 | 20 | DALLAS |
| 7902 | FORD | 20 | 20 | DALLAS |
| 7369 | SMITH | 20 | 20 | DALLAS |
| 7788 | SCOTT | 20 | 20 | DALLAS |
| 7876 | ADAMS | 20 | 20 | DALLAS |
| 7698 | BLAKE | 30 | 30 | CHICAGO |
| 7564 | MARTIN | 30 | 30 | CHICAGO |
| 7499 | ALLEN | 30 | 30 | CHICAGO |
| 7844 | TURNER | 30 | 30 | CHICAGO |
| 7900 | JAMES | 30 | 30 | CHICAGO |
| 7521 | WARD | 30 | 30 | CHICAGO |
+-------+--------+--------+--------+----------+
14 rows in set (0.00 sec)

100. Esta consulta no puede entregar resultados, ya que no existen las tablas a
las que se hace referencia.
mysql> SELECT c.name, o.ordid, i.itemid, o.total
-> FROM customer c, ord o, item i
-> WHERE c.custid=o.custid AND o.ordid=i.ordid AND c.name='TKB SPORT SHOP';
ERROR 1146 (42S02): Table 'test.customer' doesnt exist

101. En esta consulta no es necesario especificar de qué tabla se toman los

atributos, pues no existen atributos en común.
mysql> SELECT e.ename, e.sal, s.grade
-> FROM emp e, salgrade s
-> WHERE e.sal BETWEEN s.losal AND s.hisal;
+--------+---------+-------+
| ename | sal | grade |
+--------+---------+-------+
| KING | 5000.00 | 5 |
| BLAKE | 2850.00 | 4 |
| CLARK | 2450.00 | 4 |
| JONES | 2975.00 | 4 |
| MARTIN | 1250.00 | 2 |
| ALLEN | 1600.00 | 3 |
| TURNER | 1500.00 | 3 |
| JAMES | 950.00 | 1 |
| WARD | 1250.00 | 2 |
| FORD | 3000.00 | 4 |
| SMITH | 800.00 | 1 |
| SCOTT | 3000.00 | 4 |
| ADAMS | 1100.00 | 1 |
| MILLER | 1300.00 | 2 |
+--------+---------+-------+
14 rows in set (0.08 sec)

102. El producto cartesiano no limita de ninguna forma el resto de las

expresiones, aquí se ve un ejemplo del uso de ORDER BY.
mysql> SELECT e.ename, d.deptno, d.dname
-> FROM emp e, dept d
-> WHERE e.deptno=d.deptno
-> ORDER BY e.deptno;
+--------+--------+------------+
| ename | deptno | dname |
+--------+--------+------------+
| CLARK | 10 | ACCOUNTING |
| MILLER | 10 | ACCOUNTING |
| KING | 10 | ACCOUNTING |
| JONES | 20 | RESEARCH |
| FORD | 20 | RESEARCH |
| SMITH | 20 | RESEARCH |
| SCOTT | 20 | RESEARCH |
| ADAMS | 20 | RESEARCH |
| BLAKE | 30 | SALES |
| MARTIN | 30 | SALES |
| ALLEN | 30 | SALES |
| TURNER | 30 | SALES |
| JAMES | 30 | SALES |
| WARD | 30 | SALES |
+--------+--------+------------+
14 rows in set (0.00 sec)

103. Los alias son de utilidad al realizar restricciones sobre los atributos de
una misma tabla, en este ejemplo vemos como llaman a la misma tabla de dos formas
diferentes para usar dos atributos de la misma tabla.
mysql> SELECT CONCAT(workers.ename,' works for ',manager.ename)
-> FROM emp workers, emp manager
-> WHERE workers.mgr=manager.empno;
+---------------------------------------------------+
| CONCAT(workers.ename,' works for ',manager.ename) |
+---------------------------------------------------+
| BLAKE works for KING |
| CLARK works for KING |
| JONES works for KING |
| MARTIN works for BLAKE |
| ALLEN works for BLAKE |
| TURNER works for BLAKE |
| JAMES works for BLAKE |
| WARD works for BLAKE |
| FORD works for JONES |
| SMITH works for FORD |
| SCOTT works for JONES |
| ADAMS works for SCOTT |
| MILLER works for CLARK |
+---------------------------------------------------+
13 rows in set (0.00 sec)

104. En MySQL también se cuentan con funciones matemáticas, algunas de estas

son AVG() para calcular el promedio, SUM() que devuelve la suma de los elementos,
MIN() que regresa el valor mas pequeño encontrado en una lista, y MAX() que
realiza la operación inversa de MIN().
mysql> SELECT AVG(sal), MAX(sal), MIN(sal), SUM(sal)
-> FROM emp
 -> WHERE job LIKE 'SALES%';
+-------------+----------+----------+----------+
| AVG(sal) | MAX(sal) | MIN(sal) | SUM(sal) |
+-------------+----------+----------+----------+
| 1400.000000 | 1600.00 | 1250.00 | 5600.00 |
+-------------+----------+----------+----------+
1 row in set (0.05 sec)

105. Las funciones MIN() y MAX() no se limitan a tratar con valores de tipo
numérico, también se pueden usar con fechas.
mysql> SELECT MIN(hiredate), MAX(hiredate)
-> FROM emp;
+---------------+---------------+
| MIN(hiredate) | MAX(hiredate) |
+---------------+---------------+
| 1980-12-17 | 1983-01-12 |
+---------------+---------------+
1 row in set (0.00 sec)

106. Otra función útil es COUNT() que cuenta el número de ocurrencias.

mysql> SELECT COUNT(*)
-> FROM emp
-> WHERE deptno=30;
+----------+
| COUNT(*) |
+----------+
| 6 |
+----------+
1 row in set (0.00 sec)

107. Los parámetros que recibe la función COUNT() son un atributo de tabla o
una expresión.
mysql> SELECT COUNT(comm)
-> FROM emp
-> WHERE deptno=30;
+-------------+
| COUNT(comm) |
+-------------+
| 4 |
+-------------+
1 row in set (0.00 sec)

108. En el ejemplo anterior la consulta regreso 4 valores, siendo que son 14

entidades, pero la función COUNT() ignora los valores nulos como se muestra en la
siguiente consulta.
mysql> SELECT COUNT(deptno)
-> FROM emp
-> ;
+---------------+
| COUNT(deptno) |
+---------------+
| 14 |
+---------------+
1 row in set (0.00 sec)

109. Aquí hay un ejemplo de una expresión dentro del argumento de COUNT(), en
este caso para no contar los valores repetidos.
mysql> SELECT COUNT(DISTINCT(deptno))
-> FROM emp;
+-------------------------+
| COUNT(DISTINCT(deptno)) |
+-------------------------+
| 3 |
+-------------------------+
1 row in set (0.02 sec)

110. Al igual que la función COUNT() la función AVG() realiza el promedio sobre
los valores que no son nulos.
mysql> SELECT AVG(comm)
-> FROM emp;
+------------+
| AVG(comm) |
+------------+
| 550.000000 |
+------------+
1 row in set (0.00 sec)

111. Para corregir esto se puede usar la función IFNULL(,).

mysql> SELECT AVG(IFNULL(comm,0))
-> FROM emp;
+---------------------+
| AVG(IFNULL(comm,0)) |
+---------------------+
| 157.142857 |
+---------------------+
1 row in set (0.02 sec)

112. La cláusula GROUP BY es de mucha ayuda para realizar consultas sobre

ciertos grupos, lo que hace es subdividir la tabla en tablas temporales y después
a cada una aplicarles la consulta deseada.
mysql> SELECT deptno, AVG(sal)
-> FROM emp
-> GROUP BY deptno;
+--------+-------------+
| deptno | AVG(sal) |
+--------+-------------+
| 10 | 2916.666667 |
| 20 | 2175.000000 |
| 30 | 1566.666667 |
+--------+-------------+
3 rows in set (0.00 sec)

113. Una consulta igual a la anterior con un atributo menos.

mysql> SELECT AVG(sal)
-> FROM emp
-> GROUP BY deptno;
+-------------+
| AVG(sal) |
+-------------+
| 2916.666667 |
| 2175.000000 |
| 1566.666667 |
+-------------+
3 rows in set (0.00 sec)

114. La cláusula GOUP BY devuelve un valor por cada subtabla, asi que es
posible ordenar esos valores con la clausula ORDER BY.
mysql> SELECT deptno, AVG(sal)
-> FROM emp
-> GROUP BY deptno
-> ORDER BY AVG(sal);
+--------+-------------+
| deptno | AVG(sal) |
+--------+-------------+
| 30 | 1566.666667 |
| 20 | 2175.000000 |
| 10 | 2916.666667 |
+--------+-------------+
3 rows in set (0.00 sec)

115. Igual que ORDER BY, la cláusula GROUP BY puede afectar a más de un
argumento, en este caso primero se agrupan por departamento y luego por trabajo.
mysql> SELECT deptno, job, SUM(sal)
-> FROM emp
-> GROUP BY deptno, job;
+--------+-----------+----------+
| deptno | job | SUM(sal) |
+--------+-----------+----------+
| 10 | CLERK | 1300.00 |
| 10 | MANAGER | 2450.00 |
| 10 | PRESIDENT | 5000.00 |
| 20 | ANALYST | 6000.00 |
| 20 | CLERK | 1900.00 |
| 20 | MANAGER | 2975.00 |
| 30 | CLERK | 950.00 |
| 30 | MANAGER | 2850.00 |
| 30 | SALESMAN | 5600.00 |
+--------+-----------+----------+
9 rows in set (0.01 sec)

116. Aquí hay un ejemplo de la combinación de GROUP BY con COUNT().

mysql> SELECT deptno, COUNT(ename)
-> FROM emp
-> GROUP BY deptno;
+--------+--------------+
| deptno | COUNT(ename) |
+--------+--------------+
| 10 | 3 |
| 20 | 5 |
| 30 | 6 |
+--------+--------------+
3 rows in set (0.00 sec)

117. La cláusula HAVING sólo puede ser usada después de GROUP BY, y sirve para
discriminar que subtablas se utilizarán para la consulta.
mysql> SELECT deptno, AVG(sal)
-> FROM emp
-> GROUP BY deptno
-> HAVING AVG(sal) > 2000;
+--------+-------------+
| deptno | AVG(sal) |
+--------+-------------+
| 10 | 2916.666667 |
| 20 | 2175.000000 |
+--------+-------------+
2 rows in set (0.03 sec)

118. Las restricciones que se pueden hacer con HAVING son similares a las de
WHERE pero hay que tener claro que, HAVING actúa sobre subtablas y WHERE sobre
filas de una tabla.
mysql> SELECT deptno, MAX(sal)
-> FROM emp
-> GROUP BY deptno
 -> HAVING MAX(sal) >2900;
+--------+----------+
| deptno | MAX(sal) |
+--------+----------+
| 10 | 5000.00 |
| 20 | 3000.00 |
+--------+----------+
2 rows in set (0.00 sec)
119. El uso de HAVING no limita el uso de WHERE aquí hay un ejemplo de el uso
de estas dos al mismo tiempo.
mysql> SELECT job, SUM(sal) AS "roll de pago"
-> FROM emp
-> WHERE job NOT LIKE 'SALES%'
-> GROUP BY job
-> HAVING SUM(sal) > 5000
-> ORDER BY SUM(sal) DESC;
+---------+--------------+
| job | roll de pago |
+---------+--------------+
| MANAGER | 8275.00 |
| ANALYST | 6000.00 |
+---------+--------------+
2 rows in set (0.00 sec)

120. Consulta idéntica a la 113.

121. Subconsultas o consultas anidadas, es posible anidar una consulta dentro

de otra, pero esta debe devolver un valor o valores válidos.
mysql> SELECT ename
-> FROM emp
-> WHERE sal= (SELECT sal
-> FROM emp
-> WHERE empno=7566);
+-------+
| ename |
+-------+
| JONES |
+-------+
1 row in set (0.00 sec)

122. En este ejemplo se realizan 2 subconsultas, es posible hacer hasta 6

consultas anidadas.
mysql> SELECT ename, job
-> FROM emp
-> WHERE job = (SELECT job
-> FROM emp
-> WHERE empno=7369)
-> AND sal > (SELECT sal
-> FROM emp
-> WHERE empno=7876);
+--------+-------+
| ename | job |
+--------+-------+
| MILLER | CLERK |
+--------+-------+
1 row in set (0.00 sec)

123. Las subconsultas no tienen restricción, son igual a cualquier consulta

normal.
mysql> SELECT ename, job, sal
-> FROM emp
 -> WHERE sal = (SELECT MIN(sal)
-> FROM emp);
+-------+-------+--------+
| ename | job | sal |
+-------+-------+--------+
| SMITH | CLERK | 800.00 |
+-------+-------+--------+
1 row in set (0.00 sec)
124. Aquí hay un ejemplo de una combinación de subconsulta y GROUP BY.
mysql> SELECT deptno, MIN(sal)
-> FROM emp
-> GROUP BY deptno
-> HAVING MIN(sal) > (SELECT MIN(sal)
-> FROM emp
-> WHERE deptno = 20);
+--------+----------+
| deptno | MIN(sal) |
+--------+----------+
| 10 | 1300.00 |
| 30 | 950.00 |
+--------+----------+
2 rows in set (0.00 sec)

125. En esta consulta, se muestra como una subconsulta devuelve más de un

valor, y esto se toma como un conjunto de valores de la sentencia IN().
mysql> SELECT ename, sal, deptno
-> FROM emp
-> WHERE sal IN (SELECT MIN(sal)
-> FROM emp
-> GROUP BY deptno);
+--------+---------+--------+
| ename | sal | deptno |
+--------+---------+--------+
| JAMES | 950.00 | 30 |
| SMITH | 800.00 | 20 |
| MILLER | 1300.00 | 10 |
+--------+---------+--------+
3 rows in set (0.01 sec)

126. Aquí se realiza la misma consulta pero con valores numéricos en lugar de
una subconsulta y el resultado es el mismo.
mysql> SELECT ename, sal, deptno
-> FROM emp
-> WHERE sal IN (800,950,1300);
+--------+---------+--------+
| ename | sal | deptno |
+--------+---------+--------+
| JAMES | 950.00 | 30 |
| SMITH | 800.00 | 20 |
| MILLER | 1300.00 | 10 |
+--------+---------+--------+
3 rows in set (0.00 sec)

127. El conjunto de valores devueltos por la subconsulta también sirve como

argumento para la sentencia ANY(); esta sentencia es equivalente a realizar tantas
comparaciones como valores tenga el argumento y si alguna de estas resulta
verdadera, el resultado es verdadero.
mysql> SELECT empno, ename, job
-> FROM emp
-> WHERE sal < ANY (SELECT sal
-> FROM emp
 -> WHERE job='CLERk');
+-------+--------+----------+
| empno | ename | job |
+-------+--------+----------+
| 7564 | MARTIN | SALESMAN |
| 7900 | JAMES | CLERK |
| 7521 | WARD | SALESMAN |
| 7369 | SMITH | CLERK |
| 7876 | ADAMS | CLERK |
+-------+--------+----------+
5 rows in set (0.00 sec)

128. La sentencia ALL() es parecida a ANY() pero todas las comparaciones deben
devolver verdadero para que el resultado final sea verdadero.
mysql> SELECT empno, ename, job
-> FROm emp
-> WHERE sal > ALL (SELECT AVG(sal)
-> FROM emp
-> GROUP BY deptno);
+-------+-------+-----------+
| empno | ename | job |
+-------+-------+-----------+
| 7839 | KING | PRESIDENT |
| 7566 | JONES | MANAGER |
| 7902 | FORD | ANALYST |
| 7788 | SCOTT | ANALYST |
+-------+-------+-----------+
4 rows in set (0.00 sec)

129. Aquí se muestra un ingenioso uso de una subconsulta, de esta forma se

obtiene los nombres de los que son jefes de algún empleado.
mysql> SELECT e.ename
-> FROM emp e
-> WHERE e.empno IN (SELECT m.mgr
-> FROM emp m);
+-------+
| ename |
+-------+
| KING |
| BLAKE |
| CLARK |
| JONES |
| FORD |
| SCOTT |
+-------+
6 rows in set (0.00 sec)

130. Esta consulta devuelve error debido a que no existen las tablas a las que
se hacen referencia.
mysql> SELECT ordid, proid, qty
-> FROM item
-> WHERE (prodid,qty) IN (SELECT prodid,qty
-> FROM item
-> WHERE ordid=605)
-> AND ordid<>605;
ERROR 1146 (42S02): Table 'test.item' doesnt exist

131. Esta consulta está bien realizada, y se le pide que devuelva los
resultados omitidos en la consulta 129, sin embarno no devuelva ningún valor.
mysql> SELECT e.ename
-> FROM emp e
 -> WHERE e.empno NOT IN (SELECT m.mgr
-> FROM emp m);
Empty set (0.00 sec)

132. Un conjunto de valores puede ser considerado una tabla, aquí se muestra
cómo una subconsulta se le asigna un alias para ser tomada como una tabla.
mysql> SELECT a.ename, a.sal, a.deptno, b.salavg
-> FROM emp a, (SELECT deptno, AVG(sal) salavg
-> FROM emp
-> GROUP BY deptno) b
-> WHERE a.deptno =b.deptno
-> AND a.sal > b.salavg;
+-------+---------+--------+-------------+
| ename | sal | deptno | salavg |
+-------+---------+--------+-------------+
| KING | 5000.00 | 10 | 2916.666667 |
| JONES | 2975.00 | 20 | 2175.000000 |
| FORD | 3000.00 | 20 | 2175.000000 |
| SCOTT | 3000.00 | 20 | 2175.000000 |
| BLAKE | 2850.00 | 30 | 1566.666667 |
| ALLEN | 1600.00 | 30 | 1566.666667 |
+-------+---------+--------+-------------+
6 rows in set (0.00 sec)

133. Insercion de nuevo empleado en la tabla empleados.

mysql> INSERT INTO emp
-> VALUES(7196,'GREEN','SALESMAN',7782,CURRENT_DATE,2000,NULL,10);
Query OK, 1 row affected (0.02 sec)

134. En las siguientes 3 consultas, se crea una tabla, se realiza una

32inserción en la tabla creada y una consulta de los valores existentes en la
tabla. La tabla creada es parecida a la de empleados y está destinada a contener
los datos de los empleados con el puesto de MANAGER.
mysql> CREATE TABLE manager (
-> id INT(4) PRIMARY KEY,
-> name VARCHAR(8) NOT NULL,
-> salary DECIMAL(7,2) NOT NULL,
-> hiredate DATE NOT NULL);
Query OK, 0 rows affected (0.08 sec)

Es posible insertar más de un registro a la vez, y aquí se hace con una subconsulta.
mysql> INSERT INTO manager (id,name,salary,hiredate)
-> SELECT empno,ename,sal,hiredate FROM emp WHERE job='MANAGER';
Query OK, 3 rows affected (0.00 sec)
Records: 3 Duplicates: 0 Warnings: 0

mysql> SELECT *
-> FROM manager;
+------+-------+---------+------------+
| id | name | salary | hiredate |
+------+-------+---------+------------+
| 7698 | BLAKE | 2850.00 | 1981-05-01 |
| 7782 | CLARK | 2450.00 | 1981-06-09 |
| 7566 | JONES | 2975.00 | 1981-04-02 |
+------+-------+---------+------------+
3 rows in set (0.00 sec)

135. La sentencia UPDATE se usa para actualizar datos, y se usa junto con SET.
mysql> UPDATE emp
-> SET deptno=20
-> WHERE empno=7782;
Query OK, 1 rows affected (0.02 sec)
Rows matched: 1 Changed: 1 Warnings: 0

136. Hay que tener cuidado al usar estas sentencias, pues si no se especifica
el objetivo con WHERE, la expresión afectará todas las ocurrencias de la tabla.
mysql> UPDATE emp
-> SET deptno=20;
Query OK, 10 rows affected (0.00 sec)
Rows matched: 15 Changed: 10 Warnings: 0

137. Es posible modificar varios atributos de una entidad a la vez, pero la

sintaxis no permite que sea en forma de conjunto como lo es la inserción de datos.
mysql> UPDATE emp
-> SET (job,deptno)=(SELECT job,deptno
-> FROM emp
-> WHERE empno=7499)
-> WHERE empno=7698;
ERROR 1064 (42000): You have an error in your SQL syntax; check the manual that
corresponds to your MySQL server version for the right syntax to use near '(job,
deptno)=(SELECT job,deptno
FROM emp
WHERE empno=7499)
WHERE empno=7698' at line 2

La sentencia set no permite subconsultas, por lo que el siguiente ejemplo marca error.
mysql> UPDATE emp
-> SET job=(SELECT job FROM emp WHERE empno=7499),
-> deptno=(SELECT deptno FROM emp WHERE empno=7479)
-> WHERE empno=7698;
ERROR 1093 (HY000): You cant specify target table 'emp' for update in FROM clau
Se
La forma correcta de hacer esta actualización es dando los valores que se quieren
actualizar.
mysql> UPDATE emp
-> SET job='SALESMAN', deptno=20
-> WHERE empno=7698;
Query OK, 1 row affected (0.00 sec)
Rows matched: 1 Changed: 1 Warnings: 0

138. Como se mencionó antes, no se pueden usar subconsultas en la sentencia

SET.
mysql> UPDATE emp
-> SET deptno=(SELECT deptno
-> FROM emp
-> WHERE empno=7788)
-> WHERE job=(SELECT job
-> FROM emp
-> WHERE empno=7788);
ERROR 1093 (HY000): You cant specify target table 'emp' for update in FROM clau
Se

139. En este ejemplo se cambia el valor del número de departamento.

mysql> UPDATE dept
-> SET deptno=55
-> WHERE deptno=10;
Query OK, 1 row affected (0.02 sec)
Rows matched: 1 Changed: 1 Warnings: 0

140. Las siguientes 5 consultas son: crear tabla, describir tabla, insertar
datos, seleccionar datos y borrar datos.
mysql> CREATE TABLE departament (
 -> id INT(4) PRIMARY KEY,
-> dname VARCHAR(12) NOT NULL);
Query OK, 0 rows affected (0.06 sec)

mysql> DESCRIBE departament;

+-------+-------------+------+-----+---------+-------+
| Field | Type | Null | Key | Default | Extra |
+-------+-------------+------+-----+---------+-------+
| id | int(4) | NO | PRI | NULL | |
| dname | varchar(12) | NO | | NULL | |
+-------+-------------+------+-----+---------+-------+
2 rows in set (0.00 sec)

mysql> INSERT INTO departament

-> VALUES (40,'DEVELOPMENT');
Query OK, 1 row affected (0.02 sec)

mysql> SELECT * FROM departament;

+----+-------------+
| id | dname |
+----+-------------+
| 40 | DEVELOPMENT |
+----+-------------+
1 row in set (0.00 sec)

mysql> DELETE FROM departament

-> WHERE dname='DEVELOPMENT';
Query OK, 1 row affected (0.00 sec)

141. La cláusula DELETE sirve para eliminar registros, su sintaxis es parecida

a la de SELECT.
mysql> DELETE FROM manager;
Query OK, 3 rows affected (0.00 sec)

142. Es posible hacer una copia de una tabla, para eso se crea una nueva tabla
y se le dice que sea como una tabla ya existente, se usa la expresión AS SELECT *
FROM tabla_origen.
mysql> CREATE TABLE employee
-> AS SELECT *
-> FROM emp;
Query OK, 15 rows affected (0.05 sec)
Records: 15 Duplicates: 0 Warnings: 0

En la siguiente consulta, se quiere eliminar registros que pertenezcan al departamento de

ventas, pero en una consulta anterior todos los empleados fueron asignados al
departamento 20, por lo que la consulta no tiene efecto.
mysql> DELETE FROM employee WHERE deptno=(SELECT deptno
-> FROM dept WHERE dname='SALES');
Query OK, 0 rows affected (0.00 sec)

143. En esta consulta se elimina el departamento 30 de la tabla de

departamentos.
mysql> DELETE FROM dept WHERE deptno=30;
Query OK, 1 row affected (0.00 sec)

144. Se crea una nueva tabla llamada departamento 30 que es una copia de la
tabla empleados, pero sólo contiene los registros que pertenecen al departamento
30
mysql> CREATE TABLE dept30
-> AS SELECT * FROM emp WHERE deptno=30;
Query OK, 0 rows affected (0.03 sec)
Records: 0 Duplicates: 0 Warnings: 0

La cláusula ALTER sirve para alterar una tabla, en este caso se añade una nueva columna a
la tabla llamada dirección.
mysql> ALTER TABLE dept30
-> ADD (address VARCHAR(9));
Query OK, 0 rows affected (0.06 sec)
Records: 0 Duplicates: 0 Warnings: 0

145. La cláusula MODIFY puede modificar una columna pero con ciertas
restricciones. En este caso se cambia la longitud del campo nombre.
mysql> ALTER TABLE dept30
-> MODIFY ename VARCHAR(20) NOT NULL;
Query OK, 0 rows affected (0.06 sec)
Records: 0 Duplicates: 0 Warnings: 0

146. La cláusula DROP sirve para borrar por completo, a diferencia de DELETE
que solo borra registros.
mysql> ALTER TABLE dept30
-> DROP COLUMN job;
Query OK, 0 rows affected (0.06 sec)
Records: 0 Duplicates: 0 Warnings: 0

147. Con la cláusula DROP se pueden eliminar tablas.

mysql> DROP TABLE dept30;
Query OK, 0 rows affected (0.00 sec)

148. Con la cláusula RENAME se puede cambiar el nombre de una tabla, pero su
sintaxis es diferente en MySQL donde se tiene que especificar que se quiere
afectar a una tabla.
mysql> RENAME employee TO empl1;
ERROR 1064 (42000): You have an error in your SQL syntax; check the manual that
corresponds to your MySQL server version for the right syntax to use near 'emplo
yee TO empl1' at line 1
mysql> RENAME TABLE employee TO empl1;
Query OK, 0 rows affected (0.03 sec)

149. TUNCATE tiene el mismo efecto que DELETE FROM nombre_tabla.

mysql> TRUNCATE TABLE empl1;
Query OK, 0 rows affected (0.00 sec)

150. A una tabla se le pueden añadir comentarios, esto para añadir alguna
descripción que no se encuentre en la tabla misma.
mysql> COMMENT ON TABLE emp
-> IS 'Informacion de empleados';
ERROR 1064 (42000): You have an error in your SQL syntax; check the manual that
corresponds to your MySQL server version for the right syntax to use near 'COMME
NT ON TABLE emp
IS 'Informacion de empleados'' at line 1

Sin embargo para poder hacerlo en MySQL se tiene que hacer dentro de la expresión ALTER
TABLE
mysql> ALTER TABLE emp COMMENT='Informacion de empleados';
Query OK, 0 rows affected (0.05 sec)
Records: 0 Duplicates: 0 Warnings: 0

151. Se pueden añadir restricciones en una tabla después de crearla.

mysql> ALTER TABLE emp
-> ADD CONSTRAINT emp_mgr_fk
-> FOREIGN KEY (mgr)
 -> REFERENCES emp (empno);
Query OK, 15 rows affected (0.06 sec)
Records: 15 Duplicates: 0 Warnings: 0

152. Y se puede hacer el proceso inverso, es decir eliminar una restricción.

mysql> ALTER TABLE emp
-> DROP CONSTRAINT emp_mgr_fk;
ERROR 1064 (42000): You have an error in your SQL syntax; check the manual that
corresponds to your MySQL server version for the right syntax to use near 'CONST
RAINT emp_mgr_fk' at line 2

Pero en MySQL se hace referencia a la restricción que se desea eliminar como FOREIGN KEY.
mysql> ALTER TABLE emp
-> DROP FOREIGN KEY emp_mgr_fk;
Query OK, 15 rows affected (0.08 sec)
Records: 15 Duplicates: 0 Warnings: 0

153. También se puede eliminar la llave primaria, es decir, el campo se

conserva pero ya no es la llave primaria; se puede usar en conjunto con CASCADE,
lo que permite que todas las otras tablas y atributos que dependan de esta se
actualicen también. Sin embargo para que esta acción tenga efecto en MySQL la
tabla debía contener esa propiedad al ser creada, y por eso la siguiente consultas
marca error.
mysql> ALTER TABLE dept
-> DROP PRIMARY KEY CASCADE;
ERROR 1064 (42000): You have an error in your SQL syntax; check the manual that
corresponds to your MySQL server version for the right syntax to use near 'CASCA
DE' at line 2

154. Eliminación de llave primaria en cascada fallida.

mysql> ALTER TABLE emp
-> DROP PRIMARY KEY CASCADE;
ERROR 1064 (42000): You have an error in your SQL syntax; check the manual that
corresponds to your MySQL server version for the right syntax to use near 'CASCA
DE' at line 2

155. Aquí se quiere añadir una restricción, pero marca erro pues ya existe una
sobre el mismo campo que no se pudo eliminar en la consulta anterior.
mysql> ALTER TABLE emp
-> ADD CONSTRAINT emp_empno_pk
-> PRIMARY KEY (empno);
ERROR 1068 (42000): Multiple primary key defined

156. Aunque las restricciones existen se pueden deshabilitar o habilitar, sin

embargo esta instrucción sólo es válida para SQL.
mysql> ALTER TABLE emp
-> DISABLE CONSTRAINT emp_empno_pk CASCADE;
ERROR 1064 (42000): You have an error in your SQL syntax; check the manual that
corresponds to your MySQL server version for the right syntax to use near 'CONST
RAINT emp_empno_pk CASCADE' at line 2

157. Mismo caso que la consulta anterior.

mysql> ALTER TABLE emp
-> ENABLE CONSTRAINT emp_empno_pk;
ERROR 1064 (42000): You have an error in your SQL syntax; check the manual that
corresponds to your MySQL server version for the right syntax to use near 'CONST
RAINT emp_empno_pk' at line 2