Documenti di Didattica
Documenti di Professioni
Documenti di Cultura
205318638
30-may-10
Práctica 1
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)
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)
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)
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 );
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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
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)
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)
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)
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)
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)
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)
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)
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)
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)
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
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
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)
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
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
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)
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
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
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