El lenguaje SQL Licencia Introducción e historia

El lenguaje SQL
El lenguaje SQL
Índice de contenido
El lenguaje SQL..............................................................................................................................................1
Licencia......................................................................................................................................................1
Introducción e historia...............................................................................................................................1
Sentencias DDL..........................................................................................................................................2
Gestión de esquemas..............................................................................................................................2
Gestión de tablas....................................................................................................................................2
Sentencias DML.........................................................................................................................................3
Sentencias DCL..........................................................................................................................................3
Sentencias DQL..........................................................................................................................................3
Consultas básicas....................................................................................................................................3
Funciones de agregado...........................................................................................................................4
Joins.......................................................................................................................................................4
Subquerys...............................................................................................................................................5
Vistas......................................................................................................................................................5
Combinación de querys..........................................................................................................................5
Extensiones propietarias............................................................................................................................6
Lenguaje procedural PL/SQL.................................................................................................................6
Otros.......................................................................................................................................................6
Extensiones SQL'1999 i SQL'2003 orientadas a objetos..........................................................................7
SQL'1999................................................................................................................................................7
SQL'2003................................................................................................................................................7
Licencia
Este obra de Jesús Jiménez Herranz está bajo una licencia Creative Commons AtribuciónLicenciarIgual 3.0 España.
Basada en una obra en oposcaib.wikispaces.com.
Introducción e historia
SQL (Structured Query Language) es un lenguaje de acceso a bases de datos. Permite tanto
definir la estructura de los datos como hacer consultas sobre ellos, siempre según las directrices del
álgebra y el cálculo relacionales. A día de hoy, SQL es el lenguaje estándar de acceso a bases de
datos.
El origen de SQL viene de un intento de crear una sintaxis legible para el álgebra relacional
propuesta por Codd. Aunque los orígenes de SQL están en IBM, la primera implementación fue
llevada a cabo por Oracle a finales de los años 70. Posteriormente fue adoptado por el resto de
SGBD. En 1987, la ISO lo establece como estándar. A partir de aquí, ha habido diferentes
revisiones:
●
●
●
●
SQL'1987: Versión inicial.
SQL'1992: Se añade integridad referencial.
SQL'1999: Se añaden los triggers, así como características de orientación a objetos.
SQL'2003: Soporte para XML, mejor orientación a objetos.
Las instrucciones del lenguaje SQL se pueden dividir, según su función, en diferentes categorías:
●
DDL (Data Definition Language): Instrucciones para crear y alterar las estructuras relacionales.
Jesús Jiménez Herranz, http://oposcaib.wikispaces.com
1
El lenguaje SQL
●
●
●
DML (Data Manipulation Language): Instrucciones para manipular los datos.
DQL (Data Query Language): Instrucciones para consultar datos.
DCL (Data Control Language): Instrucciones de gestión interna del SGBD (permisos, etc.).
Sentencias DDL
Las sentencias de definición de datos permiten crear y alterar las estructuras básicas de la base de
datos. Si bien el modelo relacional establece que los datos se almacenan estructurados como
relaciones (llamadas tablas en SQL), el lenguaje permite agrupar las relaciones de forma lógica en
lo que se conoce como esquemas o bases de datos
Gestión de esquemas
Estas sentencias permiten crear o eliminar un esquema, que es una estructura lógica que
contendrá una o más tablas. La sintaxis es la siguiente:
CREATE SCHEMA nombre;
DROP SCHEMA nombre;
Es común que se utilice el término DATABASE en lugar de SCHEMA en muchos SGBDs.
Gestión de tablas
La sintaxis para gestionar tablas es la siguiente:
CREATE TABLE nombre (
columna tipodatos [NULL|NOT NULL] opciones,
...
);
ALTER TABLE nombre [ADD|DROP] [COLUMN|CONSTRAINT|INDEX|...] SET ...;
DROP TABLE nombre;
Por tanto, una tabla puede tener diferentes columnas, cada una de ellas con un tipo de datos. Los
tipos de datos básicos que define el estándar son:
●
●
●
Textuales: char, varchar
Numéricos: numeric, integer, float, double
Fecha y hora: date, time
En realidad, cada SGBD acostumbra a definir sus propios tipos de datos, por lo que los tipos de
datos estándar no se suelen usar demasiado.
Además de un tipo de datos, cada columna tiene asociadas una serie de opciones adicionales.
Estas opciones pueden ser:
●
●
●
Indicadores de clave primaria: Permiten establecer si la columna es o forma parte de la clave
primaria de la tabla.
Restricciones de integridad: Permite establecer restricciones para mantener la integridad de la
tabla. Por ejemplo, aquí se podría indicar si la columna es una clave externa a otra tabla, si se
permiten valores nulos o si se debe hacer alguna comprobación sobre los valores.
Otros: Por ejemplo, establecer valores por defecto de una columna o crear índices.
La sentencia ALTER permite hacer cambios a la estructura de tablas ya creadas, modificando,
añadiendo o eliminando características.
Jesús Jiménez Herranz, http://oposcaib.wikispaces.com
2
El lenguaje SQL
Sentencias DML
Las sentencias DML permiten actuar sobre los datos de la base de datos. Así, a diferencia de las
DDL, que definen la estructura de las tablas, las sentencias DML permiten alterar los datos
contenidos en las mismas.
Los tres tipos de sentencias DML son:
INSERT INTO tabla (col1,col2,...,coln) VALUES (val1,val2,...,valn);
UPDATE tabla SET col1=val1[,col2=val2,...,coln=valn] WHERE condicion;
DELETE FROM tabla [WHERE condicion];
De esta manera, la sentencia INSERT permite insertar nuevos datos a una tabla, mientras que la
sentencia UPDATE permite alterar datos ya existentes. La sentencia DELETE elimina registros de
una tabla.
Sentencias DCL
Las sentencias DCL permiten llevar a cabo tareas administrativas de la base de datos tales como
la asignación de permisos. Las instrucciones DCL definidas por SQL son:
GRANT [SELECT|INSERT|UPDATE|DELETE|REFERENCE] ON objeto TO usuario [WITH GRANT OPTION];
REVOKE [SELECT|INSERT|UPDATE|DELETE|REFERENCE] ON objeto TO usuario [WITH GRANT OPTION];
De esta manera, es posible asignar o eliminar permisos a un usuario, habilitándole para realizar
determinadas operaciones sobre los diferentes objetos de la base de datos. Además de esta
asignación, también es posible establecer si el usuario puede o no propagar sus permisos a otros
usuarios.
Sentencias DQL
Las sentencias DQL permiten consultar los datos de la base de datos, de diferentes maneras. Es
uno de los aspectos más potentes tanto de SQL como del modelo relacional en general.
Consultas básicas
El conjunto de sentencias DQL se compone únicamente de la sentencia SELECT. Si bien es una
instrucción relativamente compleja, su sintaxis básica es la siguiente:
SELECT [DISTINCT] columnas
FROM tablas
[WHERE condicion]
[GROUP BY columnas]
[ORDER BY columnas];
Por tanto, las únicas partes obligatorias de un SELECT son la especificación de la(s) tabla(s)
desde las que leer los datos, así como las columnas que se desean consultar. A partir de ahí, se
puede hacer más compleja la consulta indicando alguna condición extra que deban cumplir los datos
a consultar, estableciendo una ordenación de los resultados, o bien agrupando los resultados según
los valores de alguna de las columnas. Un ejemplo sería el siguiente:
SELECT dni,nombre,apellidos,salario
FROM empleado
WHERE salario>20000
ORDER BY dni;
Jesús Jiménez Herranz, http://oposcaib.wikispaces.com
3
El lenguaje SQL
Funciones de agregado
Además de obtener valores de columnas mediante la sentencia SELECT, también es posible
calcular determinadas estadísticas sobre el conjunto de los datos. Esto se consigue mediante las
funciones de agregado, como muestra el siguiente ejemplo:
SELECT MAX(salario) FROM empleado;
Las funciones de agregado disponibles en el SQL estándar son MAX, MIN, AVG, COUNT y
SUM.
Si además se quiere calcular estas estadísticas para los diferentes valores de una columna, se
puede hacer utilizando la cláusula GROUP BY, por ejemplo para saber cuántos empleados hay con
cada nombre:
SELECT COUNT(*) FROM empleado GROUP BY nombre;
Joins
La sentencia SELECT no está limitada a consultar datos de una sola tabla, sino que permite
consultar datos de diferentes tablas a la vez. Ahora bien, al ejecutar una sentencia SELECT sobre
varias tablas, se considera el producto cartesiano de todos sus valores, por lo que generalmente es
deseable añadir alguna condición que restrinja el número de resultados. Esto es lo que se conoce
como JOIN. Un ejemplo sería el siguiente:
SELECT e.dni,d.nombredep
FROM empleado e,departamento d
WHERE e.coddep=d.codigo;
Un aspecto a tener en cuenta de los JOINs es que sólo se mostrarán aquellos registros que
cumplan la condición especificada. Esto en ocasiones no es deseable, de manera que se definen
diferentes tipos de JOIN según el resultado deseado:
●
●
●
●
Equi-Join o Inner Join: Es el JOIN “estándar”, que se consigue mediante el uso de la cláusula
WHERE
Left Outer Join: Al hacer JOIN de dos tablas, recorre la tabla de la izquierda, buscando su
correspondencia en la de la derecha. Si no hay correspondencia, se muestra el registro con el
valor derecho a NULL
Right Outer Join: El mismo comportamiento, pero recorriendo la tabla de la derecha
Full Outer Join: El comportamiento de los JOINs left y right
El siguiente ejemplo muestra el resultado de hacer la misma consulta, pero utilizando diferentes
tipos de JOIN:
JOIN estándar
Left JOIN
Outer JOIN
Consulta
SELECT e.dni,d.nombredep
FROM empleado e,
departamento d
WHERE e.coddep=d.codigo;
SELECT e.dni,d.nombredep
FROM empleado e LEFT JOIN
departamento d
ON e.coddep=d.codigo;
SELECT e.dni,d.nombredep
FROM empleado e OUTER JOIN
departamento d
ON e.coddep=d.codigo;
Resultado
DNI
NOMBREDEP
---------- ---------43123456
Ventas
DNI
NOMBREDEP
---------- ---------43123456
Ventas
43111222
NULL
DNI
NOMBREDEP
---------- ---------43123456
Ventas
43111222
NULL
NULL
Personal
Jesús Jiménez Herranz, http://oposcaib.wikispaces.com
4
El lenguaje SQL
Subquerys
Las sentencias SELECT se pueden anidar, dando lugar a expresiones más complejas. Para ello,
se introduce la subsentencia SELECT entre paréntesis en cualquier lugar de la sentencia donde
generalmente se usaría un valor literal o un identificador de columna. A continuación se muestra un
ejemplo:
SELECT dni,nombre
FROM empleado e
WHERE e.salario=(SELECT MAX(salario) FROM empleado);
Vistas
Cuando se utilizan extensivamente los JOINs y los subquerys, es posible que el código SQL
pierda legibilidad. Para aliviar en cierta medida este problema, el lenguaje ofrece la posibilidad de
crear vistas, que no son más que tablas “virtuales” que contienen el resultado de una sentencia
SELECT. De esta manera, podemos extraer algunos subquerys de una sentencia SELECT compleja
en forma de vistas, ganando en legibilidad.
La sintaxis de creación de vistas es la siguiente:
CREATE VIEW nombre AS SELECT ...;
A partir de aquí, podemos usar la vista creada como si fuera cualquier otra tabla. En realidad, las
vistas normalmente no son más que una facilidad puramente sintáctica, y la mayoría de SGBDs las
implementan simplemente guardando su sentencia SELECT asociada. A la hora de ejecutar una
sentencia SELECT con vistas, se sustituyen internamente las referencias a las vistas por su código,
y se ejecuta la sentencia final resultante, por lo que desde el punto de vista del rendimiento no hay
ninguna diferencia entre usar vistas o subquerys (excepto, tal vez, el pequeño overhead adicional de
procesar las referencias a las vistas).
Algunos SGBDs permiten no sólo consultar las vistas, sino también manipular sus datos. Para
ello debe ser posible determinar a qué tabla corresponde cada una de las columnas de una vista. Por
supuesto, si la vista consiste en valores calculados (p. ej. con funciones de agregación, esto no es
posible).
Combinación de querys
Es posible combinar los resultados de varias sentencias SELECT en una sola, mediante el uso de
la siguiente sintaxis:
(SELECT ...) [UNION|INTERSECT|EXCEPT] [ALL|CORRESPONDING BY columna] (SELECT ...)
De esta manera, es posible combinar los resultados de diferentes consultas en una sola sentencia,
ya sea uniéndolos, mostrando sólo los registros comunes o efectuando la diferencia entre resultados.
Por defecto, se eliminan del resultado los registros repetidos, pero es posible mantener
absolutamente todos los registros, incluidos los repetidos, usando el modificador ALL. De la misma
manera, si no se usa ALL, es posible indicar qué columnas se compararán a la hora de buscar
repetidos mediante la cláusula CORRESPONDING BY.
Jesús Jiménez Herranz, http://oposcaib.wikispaces.com
5
El lenguaje SQL
Extensiones propietarias
Lenguaje procedural PL/SQL
El lenguaje PL/SQL es una extensión de SQL que permite escribir programas de forma modular.
Si bien es una extensión propietaria de Oracle, el resto de SGBDs han desarrollado extensiones
similares. Los programas PL/SQL se almacenan en la base de datos, ya sea como procedimientos
almacenados, que se ejecutan explícitamente, o bien como triggers, que son rutinas de código que se
ejecutan ante determinados eventos como insertar datos, eliminar tablas, etc.
La sintaxis de PL/SQL mezcla elementos del propio SQL con otros muy en la línea de lenguajes
como ADA, y así soporta la mayoría de construcciones de un lenguaje estructurado: variables,
bucles, condicionales, etc., así como otras menos habituales como excepciones.
La estructura básica de un bloque de código PL/SQL es la siguiente:
DECLARE
-- Declaración de variables
dni number(8);
s varchar2(100);
BEGIN
-- Cuerpo del programa
dni:=43123456;
select nombre into s from empleado e where e.dni=dni;
EXCEPTION
-- Gestión de excepciones
WHEN NO_DATA_FOUND THEN
dbms_output.put_line("Error");
END
Otros SGBDs disponen de lenguajes similares a PL/SQL, aunque la sintaxis varía de uno a otro.
Otros
Además de la sintaxis definida por el estándar SQL, cada fabricante de SGBDs acostumbra a
añadir ciertas extensiones específicas de su producto. Esto es especialmente aplicable a los tipos
básicos, para los que raramente se utilizan los que define el estándar sino que se usan los propios del
SGBD. A continuación se muestran algunas de estas extensiones para los SGBDs más importantes.
●
●
●
●
Tipos de datos: Cada SGBD acostumbra a implementar sus propios tipos de datos, que
sustituyen a los tipos especificados en el estándar.
Sentencia REPLACE: MySQL define la sentencia REPLACE, de funcionamiento idéntico a
INSERT pero que, en caso de que ya exista una fila con la clave primaria especificada, la
sustituye en lugar de mostrar un error. Otros SGBDs consiguen una funcionalidad similar
mediante la adición de nuevas opciones a la sentencia INSERT.
Operar tablas mediante SELECTS: La mayoría de SGBDs (Oracle, MySQL, PostgreSQL)
permiten hacer cosas como insertar en una tabla el resultado de un SELECT (INSERT INTO
tabla SELECT ...), o crear una tabla con la estructura y los datos de un SELECT (CREATE
TABLE tabla AS SELECT ...).
Limitar resultados de un SELECT: Mediante construcciones como SELECT FIRST, la mayoría
de SGBDs permiten limitar el número de resultados de una consulta.
Jesús Jiménez Herranz, http://oposcaib.wikispaces.com
6
El lenguaje SQL
Extensiones SQL'1999 i SQL'2003 orientadas a objetos
Desde la publicación de SQL'1992, el paradigma de la orientación a objetos ha ido tomando
fuerza tanto en el ámbito de la programación como en el de las bases de datos, apareciendo así
SGBDs orientados a objetos. Debido a esta tendencia, en las posteriores revisiones de SQL (en el
1999 y en el 2003) se añadieron diferentes mecanismos de orientación a objetos.
Si bien estas revisiones del estándar de 1992 añaden numerosas funcionalidades, el soporte de las
mismas por parte de los SGBDs es bastante irregular. Además, existen numerosas críticas a
determinados aspectos como los tipos estructurados, que chocan frontalmente con algunos
postulados del modelo relacional. Estos problemas hacen que el único estándar ampliamente
soportado sea el SQL'1992.
SQL'1999
SQL'1999 es la primera revisión del estándar desde 1992, e incluye una serie de nuevas
funcionalidades agrupadas en grupos. Así, un primer grupo de características, llamadas Core
Features, incluye pequeñas modificaciones y añadidos similares a las características propietarias de
cada SGBD. Así, por ejemplo, se añaden nuevas funciones, nuevos tipos de JOIN, etc. Además de
este grupo, hay una serie de novedades adicionales, de mayor envergadura, y que se separan de las
Core Features para no obligar a todos los SGBDs a cumplirlas, ya que puede ser complicado.
Estas características adicionales son principalmente:
●
●
●
●
Tipos personalizados: Pueden estar basados en un tipo ya existente (p. ej., un entero con un
rango de valores limitado), o bien tener una estructura. En este último caso, se permite además
crear jerarquías mediante el uso de herencia.
Arrays: Se soportan los arrays como un tipo básico más.
Procedimientos almacenados: Se permite almacenar procedimientos en la base de datos. Este
era un aspecto que ya soportaban la mayoría de SGBDs, si bien mediante sus propios
lenguajes. SQL'1999 define un dialecto estándar.
Microtransacciones: Se añade la posibilidad de guardar el estado de la transacción en un punto
dado, para volver a él si algo sale mal (microrollback).
SQL'2003
SQL'2003 refina algunos aspectos de SQL'1999 y añade nuevas características:
●
●
●
●
Nuevos tipos de datos: Entre otros, enteros grandes, conjuntos y el tipo XML.
Instrucción MERGE: Permite hacer inserts que tengan en cuenta que el registro ya existe.
Secuencias: Objetos especiales que generan una secuencia de números.
Columnas generadas: Es posible, en el momento de crear una tabla, indicar que una columna se
obtiene operando sobre otras, o a través de una secuencia. Esto permite simplificar los querys y
mejorar el rendimiento.
Jesús Jiménez Herranz, http://oposcaib.wikispaces.com
7