Documentos de Académico
Documentos de Profesional
Documentos de Cultura
Comandos
Comando Descripción
CREATE
Este comando crea un objeto dentro del gestor de base de datos. Puede ser
una base de datos, tabla, índice, procedimiento almacenado o vista.
ALTER
DROP
Este comando elimina un objeto de la base de datos. Puede ser una tabla,
vista, índice, trigger, función, procedimiento o cualquier otro objeto que el motor
de la base de datos soporte. Se puede combinar con la sentencia ALTER.
Ejemplo:
TRUNCATE
Ejemplo:
Comando Descripción
Una sentencia INSERT de SQL agrega uno o más registros a una (y sólo una)
tabla en una base de datos relacional.
Forma básica:
Ejemplo:
UPDATE
Ejemplo:
# UPDATE mi_tabla SET campo1 = 'nuevo valor campo1' WHERE campo2 = 'N';
DELETE
Una sentencia DELETE de SQL borra uno o más registros existentes en una
tabla.
Forma básica:
# DELETE FROM 'tabla' WHERE 'columna1' = 'valor1'
Ejemplo:
Clausulas
Las cláusulas son condiciones de modificación utilizadas para definir los datos
que desea seleccionar o manipular.
Comando Descripción
GROUP
Utilizada para separar los registros seleccionados en grupos específicos
BY
HAVING Utilizada para expresar condición que debe satisfacer cada grupo
Operadores
Operadores Lógicos
Operado
Uso
r
Operador Uso
<> Distinto de
BETWEE
Intervalo
N
LIKE Comparación
In Especificar
Funciones de agregado
Comando Descripción
Consultas
Consultas de selección
14. DISTINCT Omite los registros que contienen datos duplicados en los
campos seleccionados. Para que los valores de cada campo listado
en la instrucción SELECT se incluyan en la consulta deben ser
únicos:
15. # SELECT DISTINCT Apellido FROM Empleados;
Criterios de selección
Operadores Lógicos
# SELECT * FROM Empleados WHERE Edad > 25 AND Edad < 50;
# SELECT * FROM Empleados WHERE (Edad > 25 AND Edad < 50) OR Sueldo = 100;
# SELECT * FROM Empleados WHERE NOT Estado = 'Soltero';
# SELECT * FROM Empleados WHERE (Sueldo > 100 AND Sueldo < 500) OR (Provincia =
'Madrid' AND Estado = 'Casado');
Operador BETWEEN
Para indicar que deseamos recuperar los registros según el intervalo de valores
de un campo emplearemos el operador Between:
Operador IN
Este operador devuelve aquellos registros cuyo campo indicado coincide con
alguno de los indicados en una lista. Su sintaxis es:
Clausula WHERE
La cláusula WHERE puede usarse para determinar qué registros de las tablas
enumeradas en la cláusula FROM aparecerán en los resultados de la
instrucción SELECT. WHERE es opcional, pero cuando aparece debe ir a
continuación de FROM:
AVG
Avg(expr)
MAX, MIN
Un ejemplo de su uso:
SUM
Sum(expr)
Por ejemplo:
GROUP BY
1. Tabla clientes
2. +------+--------+----------+
3. | cid | nombre | telefono |
4. +------+--------+----------+
5. | 1 | jose | 111 |
6. | 2 | maria | 222 |
7. | 3 | manuel | 333 |
8. | 4 | jesus | 4444 |
9. +------+--------+----------+
JOIN
La sentencia SQL JOIN se utiliza para relacionar varias tablas. Nos permitirá
obtener un listado de los campos que tienen coincidencias en ambas tablas:
resultando:
+--------+----------+--------+----------+
| nombre | telefono | accion | cantidad |
+--------+----------+--------+----------+
| maria | 222 | REDHAT | 10 |
| jesus | 4444 | NOVELL | 20 |
| jesus | 4444 | SUN | 30 |
+--------+----------+--------+----------+
LEFT JOIN
La sentencia LEFT JOIN nos dará el resultado anterior mas los campos de la
tabla de la izquierda del JOIN que no tienen coincidencias en la tabla de la
derecha:
# select nombre, telefono, accion, cantidad from clientes left join acciones on
clientes.cid=acciones.cid;
con resultado:
+--------+----------+--------+----------+
| nombre | telefono | accion | cantidad |
+--------+----------+--------+----------+
| jose | 111 | NULL | NULL |
| maria | 222 | REDHAT | 10 |
| manuel | 333 | NULL | NULL |
| jesus | 4444 | NOVELL | 20 |
| jesus | 4444 | SUN | 30 |
+--------+----------+--------+----------+
RIGHT JOIN
Identico funcionamiento que en el caso anterior pero con la tabla que se incluye
en la consulta a la derecha del JOIN:
# select nombre, telefono, accion, cantidad from clientes right join acciones on
clientes.cid=acciones.cid;
+--------+----------+--------+----------+
| nombre | telefono | accion | cantidad |
+--------+----------+--------+----------+
| maria | 222 | REDHAT | 10 |
| jesus | 4444 | NOVELL | 20 |
| jesus | 4444 | SUN | 30 |
| NULL | NULL | FORD | 100 |
+--------+----------+--------+----------+
# select nombre, telefono, accion, cantidad from clientes left join acciones on
clientes.cid=acciones.cid where accion is null union select nombre, telefono, accion,
cantidad from clientes right join acciones on clientes.cid=acciones.cid where nombre
is null;
que mostrará:
+--------+----------+--------+----------+
| nombre | telefono | accion | cantidad |
+--------+----------+--------+----------+
| jose | 111 | NULL | NULL |
| manuel | 333 | NULL | NULL |
| NULL | NULL | FORD | 100 |
+--------+----------+--------+----------+
Vistas
Las vistas (“views”) en SQL son un mecanismo que permite generar un
resultado a partir de una consulta (query) almacenado, y ejecutar nuevas
consultas sobre este resultado como si fuera una tabla normal. Las vistas
tienen la misma estructura que una tabla: filas y columnas. La única diferencia
es que sólo se almacena de ellas la definición, no los datos.
La cláusula CREATE VIEW permite la creación de vistas. La cláusula asigna un
nombre a la vista y permite especificar la consulta que la define. Su sintaxis es: