consultas en sql server

Pág. 1 de 21

Departamento de Lenguajes y Sistemas Informáticos E.T.S. Ingeniería Informática. Universidad de Sevilla

Avda Reina Mercedes s/n. 41012 Sevilla

Tlf/Fax 954 557 139 E-mail [email protected] Web www.lsi.us.es

E.T.S. Ingeniería Informática

Bases de Datos

SQL

Sevilla, octubre 2007 V 2007.10.1

Bases de Datos Sevilla, octubre 2007, V 2007.10.1

SQL

Pág. 2 de 21

1 SQL (STRUCTURED QUERY LANGUAGE).........................................3

1.1 OBJETIVOS Y ALCANCE DE SQL ..............................................................................3 1.2 EVOLUCIÓN DEL MODELO RELACIONAL .................................................................4

2 DEFINICIÓN DE DATOS EN SQL (DDL) ...........................................4

2.1 DOMINIOS SQL2.................................................................................................4 2.2 CREATE TABLE ..................................................................................................5

3 CONSULTAS SIMPLES............................................................................5

3.1 CONSULTAS DE VARIAS TABLAS....................................................................6 3.2 EXISTS ..................................................................................................................6 3.3 IN ...........................................................................................................................6 3.4 ANY, ALL ..............................................................................................................7 3.5 BETWEEN............................................................................................................8 3.6 LIMITACIÓN DE LA LISTA DE RESULTADOS..............................................8 3.7 SUBCADENAS (LIKE) .........................................................................................9 3.8 ORDENACIÓN (ORDER BY).............................................................................9

4 CONSULTAS AVANZADAS................................................................... 10

4.1 JOIN NATURAL Y OUTER JOIN ..................................................................... 10 4.2 FUNCIONES AGREGADAS.............................................................................. 11 4.3 GROUP BY .......................................................................................................... 12 4.4 EJEMPLO............................................................................................................ 13

5 ACTUALIZACIÓN DE DATOS ............................................................. 14

5.1 INSERT ............................................................................................................... 14 5.2 DELETE.............................................................................................................. 14 5.3 UPDATE.............................................................................................................. 14

6 VISTAS...................................................................................................... 14

7 SINTAXIS SQL-2 ..................................................................................... 15

7.1 INTRODUCCIÓN .................................................................................................... 15 7.2 LENGUAJE DE DEFINICIÓN DE DATOS (DDL) ..................................................... 15 7.3 LENGUAJE DE MANIPULACIÓN DE DATOS (DML)................................................ 17


SQL

Pág. 3 de 21

1 SQL (Structured Query Language)

1.1 Objetivos y alcance de SQL a) SQL es un lenguaje estándar(ISO) para definición manipulación en SGBD relacionales. b) El DML de SQL es un lenguaje de especificación; es decir, las expresiones definen el resultado

esperado, dejando que el SGBD se encargue de resolver el mejor método para ejecutar dicha especificación(optimización de la consulta); estos métodos generados por el subsistema de proceso de consultas se denominan planes1 de acceso o planes de ejecución de la consulta.

c) La gramática DML está basada en el cálculo relacional orientado a tuplas. d) Permite:

• Definición de tablas y vistas. • Especificar un modelo de seguridad de acceso a los datos (definición de usuarios, niveles de

autorización o acceso a los datos). • Definir restricciones de integridad declarativa. • Especificar transacciones. • El DML de SQL puede ser utilizado en lenguajes de programación de propósito general

como C o Pascal o bien en lenguajes específicos del fabricante (p.ej. PL/SQL en ORACLE, TRANSACT SQL en MS-SQL Server)..

1 Un plan de ejecución de una consulta es un programa a bajo nivel, generado por el subsistema de proceso de consultas del SGBD relacional. Este plan de acceso contiene el método de acceso a los datos en función de la situación del esquema de la base de datos(esquema interno, donde figuran detalles de índices, direccionamiento, etc.) y su volumetría (volúmenes de datos de las tablas en la base de datos)..


SQL

Pág. 4 de 21

1.2 Evolución del modelo relacional 1968 - 1970 ↔ Surge el modelo

1970 . . . ↔ Desarrollos teóricos

1973 - 1978 ↔ Prototipos (Ingres, sistema R, etc. . .)

P R E R E L A C I O N A L

1978 ↔ QBE

1979 ↔ Oracle

1980 ↔ Ingres

1981 ↔ SQL

1982 ↔ DB2

1986 ↔ SQL/ ANS

1987 ↔ SQL ISO (9075)

1989 ↔ SQL Addendum

1989 ↔ Manifiesto de los SGBO

R E L A C I O N A L

1990 ↔ Modelo Relacional Versión 2

1990 ↔ Manifiesto de los SGBO- 3G

1992 ↔ SQL 92

1995 ↔ 3er Manifiesto

P O S T R E L A C I O N A L

1999 ↔ SQL 3

2 Definición de datos en SQL (DDL)

2.1 DOMINIOS SQL2 En SQL2 es posible declarar un dominio y usar su nombre. CREATE DOMAIN <nombre_dominio> AS <tipo_datos>; Entre los tipos de datos disponibles para atributos están los numéricos, cadena de caracteres, cadena de bit, fecha y hora. a) Los tipos de datos numéricos incluyen números enteros de diversos tamaños (INTEGER

o INT, y SMALLINT) y números reales de diversas precisiones (FLOAT, REAL, DOUBLE PRECISION). Podemos declarar números con formato empleando DECIMAL(i,j) ( o DEC(i,j) NUMERIC(i,j)), donde i (precisión) es el número total de dígitos decimales y j (escala) el número de dígitos que aparecen después del punto decimal.

b) Los tipos de cadena de caracteres tienen longitud fija (CHAR(n) o CHARACTER(n) o variable VARCHAR (n) o CHAR VARYING (n) o CHARACTER VARYING (n).


SQL

Pág. 5 de 21

c) Los tipos de datos de cadena de bit tienen longitud fija n (BIT(n)) o (BIT VARYING (n)). d) SQL2 cuenta con nuevos tipos de datos para fecha y hora DATE y TIME.

Ej. CREATE DOMAIN importes AS DECIMAL(9,4);

2.2 CREATE TABLE La estructura de datos soportada por SQL es la tabla como soporte a la definición de una relación del modelo RM/B. La instrucción CREATE TABLE sirve para especificar una nueva tabla CREATE DOMAIN codigos AS VARCHAR(4) NOT NULL; CREATE DOMAIN nombres AS VARCHAR(20); CREATE DOMAIN cantidades AS INTEGER; CREATE TABLE productos ( Pid codigos, Pdes nombres, Ppeso cantidades, Pprecio cantidades, PRIMARY KEY (pid) );

3 Consultas simples La sentencia básica para recuperar información en SQL es la sentencia SELECT. SELECT <lista de atributos> FROM <lista de tablas> WHERE <condición> Productos

a) Descripción y código de piezas de todas las piezas existentes. SELECT pdesc, pid FROM Productos;

pdesc pid Televisor M1 P1 Televisor M2 P2 Televisor M3 P3 Mini TK67 P10 Mini TK68 P11

b) Piezas (todos los atributos) de peso mayor o igual a 30. SELECT * FROM Productos WHERE ppeso ≥ 30;

pid pdesc ppeso pprecio P2 Televisor M2 30 78000 P3 Televisor M3 35 97000

pid pdesc ppeso pprecio P1 Televisor M1 27 56000 P2 Televisor M2 30 78000 P3 Televisor M3 35 97000 P10 Mini TK67 12 112000 P11 Mini TK68 10 142000


SQL

Pág. 6 de 21

3.1 CONSULTAS DE VARIAS TABLAS a) Códigos de los almacenes que tienen existencias del producto ‘Televisor M2’ y cantidad

que tienen en stock.

AExistencias Aid pid acant A2 P1 156 A2 P2 1234 A2 P3 69 A2 P10 120 A2 P11 345 A3 P3 5000 A4 P1 200 A4 P2 956 A4 P3 134 A4 P10 120 A4 P11 542

Almacenes aid adir aloc A2 C/. Baja, 4 Alcalá de Guadaira A3 Poligono Calonge, N12/a Sevilla A4 P.I. Armilla, A-45 Granada

Productos pid pdesc ppeso pprecio P1 Televisor M1 27 56000 P2 Televisor M2 30 78000 P3 Televisor M3 35 97000 P10 Mini TK67 12 112000 P11 Mini TK68 10 142000

SELECT AE.aid, acant FROM AExistencias AE, Productos P WHERE AE.pid = P.pid AND pdesc = ‘Televisor M2’;

AE.aid acant A2 1234 A4 956

3.2 EXISTS La función EXISTS sirve para comprobar si el resultado de una consulta anidada contiene tuplas. Rescribiendo la expresión anterior: a) Códigos de los almacenes que tienen existencias del producto ‘Televisor M2’ y cantidad

que tienen en stock. SELECT aid, acant FROM AExistencias AE WHERE EXISTS ( SELECT *

FROM Productos P WHERE P.pid = AE.pid AND pdesc = ‘Televisor M2’ ) ;

b) Códigos de los almacenes que no tienen existencias de productos. SELECT aid FROM Almacenes A WHERE NOT EXISTS ( SELECT * FROM Aexistencias AE

WHERE AE.aid = A.aid ) ;

3.3 IN El operador de comparación IN permite comparar un valor individual v (generalmente un nombre de atributo) con un conjunto de valores V (generalmente una consulta anidada). Devuelve TRUE si v es uno de los elementos de V.


SQL

Pág. 7 de 21

Es posible rescribirla la consulta anterior utilizando el operador de comparación IN. a) Códigos de los almacenes que tienen existencias del producto ‘Televisor M2’ y cantidad

que tienen en stock. SELECT aid, acant FROM AExistencias WHERE pid IN ( SELECT pid

FROM Productos WHERE pdesc = ‘Televisor M2’ ) ;

También es posible utilizar IN con un conjunto explícito de valores: b) Código y peso de los productos cuyo peso sea 10, 12 o 27 SELECT ppid, ppeso FROM Productos WHERE ppeso IN (10, 12, 27) ;

ppid ppeso P1 27 P10 12 P11 10

3.4 ANY, ALL Permiten comparar un valor individual v (nombre de atributo) con un conjunto de valores V (consulta anidada). El operador =ANY devuelve TRUE si el valor de v es igual a algún valor del conjunto V. Es equivalente a IN. a) Códigos de los almacenes que tienen existencias del producto ‘Televisor M2’ y cantidad

que tienen en stock. SELECT aid, acant FROM AExistencias WHERE pid =ANY ( SELECT pid

FROM Productos WHERE pdesc = ‘Televisor M2’ ) ;

El operador =ALL devuelve TRUE si el valor de v es igual a todos los valores del conjunto V. Otros operadores que se pueden utilizar con ANY y con ALL son >, >=, <, <= y <>. El operador >ALL devuelve TRUE si el valor de v es mayor que todos los valores del conjunto V. b) Descripción de los productos de precio superior a todos los productos que tiene el

almacen ‘A2’. SELECT pdesc FROM Productos WHERE pprecio > ALL ( SELECT pprecio

FROM Productos P, Aexistencias AE WHERE P.pid = AE.pid AND aid = ‘A2’ ) ;


SQL

Pág. 8 de 21

3.5 BETWEEN c) Código y peso de los productos cuyo peso esté entre 10 y 27.

SELECT ppid, ppeso FROM Productos WHERE ppeso

BETWEEN 10 AND 27;

ppid ppeso P1 27 P10 12 P11 10

3.6 LIMITACIÓN DE LA LISTA DE RESULTADOS Para limitar los resultados de una consulta se pueden utilizar las palabras clave DISTINCT y TOP. DISTINCT. Elimina las tuplas repetidas del resultado de una consulta. a) Código y localidad de los almacenes que tienen algún producto en existencia. AExistencias aid pid acant A2 P1 156 A2 P2 1234 A2 P3 69 A2 P10 120 A2 P11 345 A3 P3 5000 A4 P1 200 A4 P2 956 A4 P3 134 A4 P10 120 A4 P11 542

Almacenes aid Adir aloc A2 C/. Baja, 4 Alcalá de Guadaira A3 Poligono Calonge, N12/a Sevilla A4 P.I. Armilla, A-45 Granada

SELECT DISTINCT A.aid, aloc FROM AExistencias AE, Almacenes A WHERE AE.aid = A.aid;

aid Aloc A2 Alcalá de Guadaira A3 Sevilla A4 Granada

TOP2. Limita el número de filas. SELECT TOP N <lista de atributos> limita el número de filas a mostrar a N. b) En la consulta anterior obtener sólo las dos primeras filas. SELECT DISTINCT TOP 2 A.aid, aloc FROM AExistencias AE, Almacenes A WHERE AE.aid = A.aid;

aid Aloc A2 Alcalá de Guadaira A3 Sevilla

2 TOP no es estándar. No se puede utilizar en WinRDBi


SQL

Pág. 9 de 21

3.7 SUBCADENAS (LIKE) Para comparar cadenas de caracteres se utiliza el operador de comparación LIKE. Las cadenas parciales se especifican mediante los caracteres reservados % y -. a) Códigos de piezas cuya descripción empieza por ‘Televisor’ Productos Pid pdesc ppeso pprecio P1 Televisor M1 27 56000 P2 Televisor M2 30 78000 P3 Televisor M3 35 97000 P10 Mini TK67 12 112000 P11 Mini TK68 10 142000

SELECT pid FROM Productos WHERE pdesc LIKE ‘Televisor%’;

pid P1 P2 P3

b) Código de productos que en la descripción incluyen ‘TK’ seguido por un carácter y

termina en ‘8’. SELECT pid FROM Productos WHERE pdesc LIKE ‘%TK_8’;

pid P11

3.8 ORDENACIÓN (ORDER BY) a) Código de almacenes y cantidad de cada producto que tienen en stock, ordenado por

almacén y dentro de cada almacén por cantidad de mayor a menor. Considerando únicamente los productos cuyas cantidades en stock en cada almacén estén entre 200 y 2000

AExistencias aid pid acant A2 P1 156 A2 P2 1234 A2 P3 69 A2 P10 120 A2 P11 345 A3 P3 5000 A4 P1 200 A4 P2 956 A4 P3 134 A4 P10 120 A4 P11 542

SELECT aid, pid, acant FROM AExistencias WHERE acant BETWEEN 200 AND 2000 ORDER BY aid, acant DESC;

aid pid acant A2 P2 1234 A2 P11 345 A4 P2 956 A4 P11 542 A4 P1 200


SQL

Pág. 10 de 21

4 Consultas avanzadas

4.1 JOIN NATURAL y OUTER JOIN a) Código de almacén, código y descripción del producto y cantidad en stock.

AExistencias aid pid acant A2 P1 156 A2 P2 1234 A2 P3 69 A2 P10 120 A2 P11 345 A3 P3 5000 A4 P1 200 A4 P2 956 A4 P3 134 A4 P10 120 A4 P11 542

Productos pid pdesc ppeso pprecio P1 Televisor M1 27 56000 P2 Televisor M2 30 78000 P3 Televisor M3 35 97000 P10 Mini TK67 12 112000 P11 Mini TK68 10 142000

SELECT aid, AE.pid, pdesc, acant FROM AExistencias AE, Productos P WHERE AE.pid = P.pid; Se puede especificar primero la reunión de las relaciones AExistencias y Productos y seleccionar luego los atributos y tuplas deseadas. La consulta quedaría: SELECT aid, AE.pid, pdesc, acant FROM ( AExistencias AS AE JOIN Productos AS P ON AE.pid = P.pid ); (JOIN es equivalente a INNER JOIN) El resultado será: Aid AE.pid pdesc acant A2 P1 Televisor M1 156 A2 P2 Televisor M2 1234 A2 P3 Televisor M3 69 A2 P10 Mini TK67 120 A2 P11 Mini TK68 345 A3 P3 Televisor M3 5000 A4 P1 Televisor M1 200 A4 P2 Televisor M2 956 A4 P3 Televisor M3 134 A4 P10 Mini TK67 120 A4 P11 Mini TK68 542

⇒ Al incluir el producto nuevo P20 en la tabla Productos:

Productos pid Pdesc ppeso pprecio P1 Televisor M1 27 56000 P2 Televisor M2 30 78000 P3 Televisor M3 35 97000 P10 Mini TK67 12 112000 P11 Mini TK68 10 142000 P20 Equipo Nuevo 10 100


SQL

Pág. 11 de 21

La consulta: SELECT aid, AE.pid, pdesc, acant FROM ( AExistencias AS AE JOIN Productos AS P ON AE.pid = P.pid ); Devuelve el mismo resultado anterior. No se visualiza la tupla nueva ya que no tiene correspondencia en la tabla AExistencias. Para que aparezca dicha tupla se utiliza el join externo por la derecha. SELECT aid, AE.pid, pdesc, acant FROM ( AExistencias AS AE RIGHT JOIN Productos AS P ON AE.pid = P.pid ); El resultado será:

aid AE.pid pdesc acant A2 P1 Televisor M1 156 A2 P2 Televisor M2 1234 A2 P3 Televisor M3 69 A2 P10 Mini TK67 120 A2 P11 Mini TK68 345 A3 P3 Televisor M3 5000 A4 P1 Televisor M1 200 A4 P2 Televisor M2 956 A4 P3 Televisor M3 134 A4 P10 Mini TK67 120 A4 P11 Mini TK68 542 Equipo Nuevo

(RIGHT JOIN es equivalente a RIGHT OUTER JOIN) De igual forma para obtener las tuplas de AExistencias que no tengan correspondencias en Productos se utilizara el LEFT JOIN (LEFT JOIN es equivalente a LEFT OUTER JOIN)

4.2 FUNCIONES AGREGADAS COUNT devuelve el número de filas o valores especificados en una consulta. SUM, MAX, MIN, AVG se aplican a un conjunto o multiconjunto de valores numéricos y devuelven respectivamente la suma, el valor máximo, el mínimo y el promedio de dicho valores. Estas funciones se pueden usar con la cláusula SELECT o con la cláusula HAVING. a) Numero de productos que existen. pid pdesc ppeso pprecio P1 Televisor M1 27 56000 P2 Televisor M2 30 78000 P3 Televisor M3 35 97000 P10 Mini TK67 12 112000 P11 Mini TK68 10 142000

SELECT COUNT (*) FROM Productos ;

COUNT (*) 5


SQL

Pág. 12 de 21

b) Calcular la suma de las cantidades, la cantidad máxima, la mínima, la media y contar todos los productos que existen en stock.

aid pid Acant A2 P1 156 A2 P2 1234 A2 P3 69 A2 P10 120 A2 P11 345 A3 P3 5000 A4 P1 200 A4 P2 956 A4 P3 134 A4 P10 120 A4 P11 542

SELECT SUM(acant), MAX(acant), MIN(acant), AVG(acant), COUNT(*) FROM AExistencias ; SUM(acant) MAX(acant) MIN(acant) AVG(acant) COUNT(*)

8876 5000 69 872 11

c) Contar los productos de los que haya existencia en algún almacén. SELECT COUNT (DISTINCT pid) FROM AExistencias ;

COUNT (*) 5

4.3 GROUP BY Cuando se quiera aplicar las funciones agregadas a subgrupos de tuplas de una relación agruparemos las tuplas que tienen el mismo valor para ciertos atributos. Los llamaremos atributos de agrupación y podremos aplicar las funciones a cada uno de dichos grupos. Para especificar los atributos de agrupación se utiliza la cláusula GROUP BY. Los atributos de agrupación pueden aparecer en la cláusula SELECT. a) Calcular para cada almacén el número de productos en stock y la cantidad total. aid pid acant A2 P1 156 A2 P2 1234 A2 P3 69 A2 P10 120 A2 P11 345 A3 P3 5000 A4 P1 200 A4 P2 956 A4 P3 134 A4 P10 120 A4 P11 542

SELECT aid, COUNT(*), SUM(acant) FROM AExistencias GROUP BY aid;

aid COUNT(*) SUM(acant) A2 5 1924 A3 1 5000 A4 5 1952


SQL

Pág. 13 de 21

HAVING HAVING especifica una condición sobre el grupo de tuplas asociado a cada valor de los atributos de agrupación (clases de equivalencia). Sólo los grupos que cumplan la condición entrarán en el resultado de la consulta. b) Para las tiendas que hayan hecho más de un pedido al mismo almacén calcular la

cantidad total pedida. Pedidos pdid tid aid pid cant fecha PD10 T1 A2 P1 100 10/12/03 PD20 T1 A2 P2 150 12/12/03 PD30 T2 A2 P10 50 14/12/03 PD40 T2 A4 P11 70 11/12/03 PD50 T4 A2 P10 80 10/12/03 PD60 T4 A4 P11 25 13/12/03 PD70 T4 A2 P11 40 14/12/03

SELECT tid, aid, SUM(acant) FROM Pedidos GROUP BY aid, tid HAVING COUNT(*) > 1;

tid aid SUM(acant)

T1 A2 250 T4 A2 120

4.4 EJEMPLO a) Almacén con mayor número de productos. • Utilizando ALL SELECT AE.aid, Sum(AE.acant) FROM AE GROUP BY AE.aid HAVING Sum(AE.acant) >= ALL (SELECT Sum(AE.acant)

FROM AE GROUP BY AE.aid);

• Utilizando TOP SELECT AE.aid, Sum(AE.acant) FROM AE GROUP BY AE.aid HAVING Sum(AE.acant) = ( SELECT TOP 1 Sum(AE.acant) FROM AE GROUP BY AE.aid ORDER BY 1 DESC); • Mediante SELECT anidados SELECT AE.aid, sum(AE.acant) FROM AE GROUP BY AE.aid HAVING sum(acant) = ( SELECT Max(total) FROM ( SELECT Sum(Sx.acant) as total FROM AE GROUP BY AE.aid ) );


SQL

Pág. 14 de 21

5 Actualización de datos

5.1 INSERT Sirve para añadir tuplas a la BD

INSERT INTO Productos VALUES (P20, Cadena A100, 20,200);

Se pueden añadir múltiples filas utilizando la claúsula SELECT.

INSERT INTO ProductoPedidos (Pid, Nombre, Precio) SELECT Pid, Pdesc, Pprecio FROM Productos WHERE pprecio >30;

5.2 DELETE Elimina tuplas de una relación. La eliminación puede propagarse a tuplas de otras relaciones si tal acción está especificada en las restricciones de integridad referencial.

DELETE FROM Productos WHERE pprecio >30;

5.3 UPDATE Modifica los valores de los atributos.

UPDATE Productos SET pprecio = 200 WHERE pid = ‘P1’; UPDATE Productos SET pprecio = pprecio * 1.2 WHERE pid IN (SELECT pid FROM pedidos) ;

6 Vistas Una vista es una estructura tabular derivada de otras tablas. Una vista no se materializa en SQL; se genera en el momento de su ejecución.

CREATE VIEW Producto_pedido AS SELECT PD.pdid, PD.pid, P.pdesc, PD.cantidad FROM productos P, pedidos PD WHERE P.pid = PD.pid;


SQL

Pág. 15 de 21

7 Sintaxis SQL-2

7.1 Introducción Se presenta un resumen de la sintaxis de SQL según el estándar ISO 9075 (SQL-92),dividido en:

- Lenguaje de Definición de Datos (LDD),

- Lenguaje de Manipulación de Datos (LMD), y

- Lenguaje de Administración de Datos (LAD).

La nomenclatura utilizada es una extensión de la Forma Normal de Backus (BNF) siendo:

< > representa los símbolos no terminales del lenguaje

::= es el operador de definición

[ ] indica elementos opcionales

{} agrupa elementos en una fórmula

| indica una alternativa

... indica repetición:

7.2 Lenguaje de Definición de Datos (DDL) <definición de esquema >::=

CREATE SCHEMA <cláusula de nombre de esquema>

[ <elemento de esquema> ... ]

<cláusula de nombre de esquema> ::=

<nombre de esquema>

| AUTHORIZATION <id. de autorización de usuario>

|<nombre de esquema> AUTHORIZATION <id. de autorización de usuario>

<elemento de esquema> ::=

<definición de dominio>

| <definición de tabla>

| <definición de vista>

| <definición de aserción>

<definición de dominio> ::=

CREATE DOMAIN <nombre de dominio> [ AS ] <tipo de datos>

[ <cláusula de defecto> ]

[ <restricción de dominio> ]

<cláusula de defecto> ::=

DEFAULT <opción por defecto>

<opción por defecto> ::=

<literal>

|<función de valor tiempo/fecha>

| USER

| SYSTEM

| USER

| NULL

<restricción de dominio> ::=

[ <definición de nombre de restricción> ]

< definición de restricción de verificación>

[ <atributos de restricción> ]

<definición de nombre de restricción> ::=

CONSTRAINT <nombre de restricción>

<definición de restricción de verificación> ::=

CHECK <parent. izq.> <condición de búsqueda> <parent. dcho.>

<atributos de restricción> ::=

<tiempo de verificación de restricción> [ [NOT] DEFERRABLE ]

| [ [NOT] DEFERRABLE ] <tiempo de verificación de restricción>


SQL

Pág. 16 de 21

<tiempo de verificación de restricción> ::=

INITIALLY DEFERRED

| INITIALLY INMEDIATE

<definición de tabla> ::=

CREATE [ {GLOBAL|LOCAL} TEMPORARY ] TABLE <nombre de tabla>

<lista de elementos de tabla>

<lista de elementos de tabla> ::=

<paréntesis izq.> <elemento de tabla>

[{<coma> <elemento de tabla>} ... ] <paréntesisdcho.>

<elemento de tabla> ::=

<definición de columna>

| <definición de restricción de tabla>

<definición de columna> ::=

<nombre de columna> { <tipo de datos> | <nombre de dominio>}

[ <claúsula de defecto> ]

[ <definición de restricción de columna> .... ]

<definición de restricción de columna> ::=

[ <definición de nombre de restricción> ]

<restricción de columna>


<restricción de columna> ::=

NOT NULL

| <especificación de unicidad>

| <especificación de referencia>

| <definición de restricción de verificación>

<definición de restricción de tabla> ::=

[ <nombre de definición de restricción> ]

<restricción de tabla>


<restricción de tabla> ::=

<definición de restricción de unicidad>

| <definición de restricción referencial>

| <definición de restricción de verificación>

<definición de restricción de unicidad> ::=

<especificación de unicidad>

<parent. izq.> <lista de columnas únicas> <parent. dcho.>

<especificación de unicidad> ::=

UNIQUE | PRIMARY KEY

<lista de columnas únicas> ::= <lista de nombre de columnas>

<definición de restricción referencial> ::=

FOREIGN KEY <parent. izq.> <columnas que ref.> <parent. dcho.>

<especificación de la referencia>

<especificación de la referencia> ::=

REFERENCES <columnas y tabla referenciadas>

[ <acción referencial disparada> ]

<columnas que ref.> ::= <lista de columnas de referencia>

<columnas y tabla referenciadas> ::=

<nombre de tabla> [ <parent. izq.> <lista de columnas de referencia> <parent. dcho.> ]

<lista de columnas de referencia> ::= <lista de nombres de columnas>

<acción referencial disparada> ::=

<regla de modificación> [ <regla de borrado> ]

| <regla de borrado> [regla de modificación]

<regla de modificación> ::= ON UPDATE <acción referencial>

<regla de borrado> ::= ON DELETE <acción referencial>


SQL

Pág. 17 de 21

<acción referencial> ::=

CASCADE

| SET NULL

| SET DEFAULT

<definición de vista> ::=

CREATE VIEW <nombre de tabla>

[ <parent. izq.> <lista de columnas de vista> <parent. dcho.>]

AS <expresión de consulta>

[ WITH CHECK OPTION ]

<lista de columnas de vista> ::= <lista de nombres de columnas>

<definición de aserción> ::=

CREATE ASSERTION <nombre de restricción>

<verificación de aserción> [ <atributos de restricción> ]

<verificación de aserción> ::=

CHECK <parent. izq.> <condición de búsqueda> <parent. dcho.>

7.3 Lenguaje de Manipulación de Datos (DML) <expresión de consulta>::=

<expresión de consulta de no combinación>

| <tabla combinada>

<expresión de consulta de no combinación> ::=

<término de consulta de no combinación>

| <expresión de consulta> UNION [ALL]

[ <especificación de correspondencia> ] <término de consulta>

| <expresión de consulta> EXCEPT [ALL]

[ <especificación de correspondencia> ] <término de consulta>

<término de consulta> ::=

<término de consulta de no combinación>

| <tabla combinada>

<término de consulta de no combinación> ::=

<primario de consulta de no combinación>

|<términodeconsulta> INTERSECT [ALL]

[ <especificación de correspondencia> ] <primario de consulta>

<primario de consulta> ::=

<primario de consulta de no combinación>

| <tabla combinada>

<primario de consulta de no combinación> ::=

<tabla simple>

| <parent. izq.> <expresión de combinación de no consulta> <parent. dcho.>

<tabla simple> ::=

<especificación de consulta>

| <constructor de valor de tabla>

| <tabla explícita>

<tabla explícita> ::= TABLE <nombre de tabla>

<especificación de correspondencia> ::=

CORRESPONDING [ BY <parent. izq.> <lista de columnas que corresponden><parent. dcho.> ]

<lista de columnas que corresponden> ::= <lista de columnas>

<constructor de valor de tabla> ::=

VALUES <lista de constructores de valores de tabla>

<lista de constructores de valores de tabla> ::=

<constructor de valor de fila> [ { <coma> <constructor de valor de fila> ... }

<constructor de valor de fila> ::=

<elemento constructor de valor de fila>

| <parent. izq.> <lista de constructores de valor de fila> <parent. dcho.>


SQL

Pág. 18 de 21

| <subconsulta de fila>

<lista de constructores de valor de fila> ::=

<elemento constructor de valor de fila>

[ {<coma> <elemento constructor de valor de fila>} ... ]

<elemento constructor de valor de fila> ::=

<expresión de valor>

| <especificación de nulos>

| DEFAULT

<especificación de nulos> ::= NULL

<subconsulta de fila> ::= <subconsulta>

<subconsulta> ::= <parent. izq.> <expresión de consulta> <parent. dcho.>

<especificación de consulta> ::=

SELECT [<cuantificador de conjunto>] <lista de consulta> <expresión de tabla>

<lista de consulta> ::=

<asterisco>

| <sublista de consulta> [{<coma> <sublista de consulta>} ...]

<sublista de consulta> ::=

<columna derivada>

| <calificador> <punto> <asterisco>

<columna derivada> ::= <expresión de valor> [<cláusula as>]

<cláusula as> ::= [AS] <nombre de columna>

<cuantificador de conjunto> ::= DISTINCT | ALL

<expresión de tabla> ::=

<cláusula from>

[ <cláusula where> ]

[ <cláusula group by> ]

[ <cláusula having>]

<cláusula from> ::= FROM <referencia a tabla> [ { <coma> <referencia a tabla> } ... ]

<referencia a tabla> ::=

<nombre de tabla> [ [AS] <nombre de correlación>

[<parent. izq.> <lista de columnas derivadas> <parent. dcho.]]

| <tabla derivada> [AS] <nombre de correlación>

[<parent. izq.> <lista de columnas derivadas> <parent. dcho.]

| <tabla combinada>

<tabla derivada> ::= <subconsulta de tabla>

<lista de columnas derivadas> ::= <lista de nombres de columnas>

<lista de nombres de columnas> ::=

<nombre de columna> [ { <coma> <nombre de columna> } ... ]

<nombre de correlación> ::= <identificador>

<calificador> ::=

<nombre de tabla>

| <nombre de correlación>

<tabla combinada> ::=

<combinación cruzada>

| <combinación calificada>

| <parent. izq.> <tabla combinada> <parent. dcho.>

<combinación cruzada> ::=

<referencia a tabla> CROSS JOIN <referencia a tabla>

<combinación calificada> ::=

<referencia a tabla> [NATURAL] [<tipo de combinación>] JOIN <referencia a tabla>

[<especificación de combinación>]

<especificación de combinación> ::=

<condición de combinación>

| <combinación de columnas nominadas>


SQL

Pág. 19 de 21

<condición de combinación> ::= ON <condición de búsqueda>

<combinación de columnas nominadas> ::=

USING <parent. izq.> <lista de columnas de combinación> <parent. dcho.>

<tipo de combinación> ::=

INNER

| <tipo de combinación externa> [OUTER]

| UNION

<tipo de combinación externa> ::=

LEFT

| RIGHT

| FULL

<lista de columnas de combinación> ::= <lista de nombres de columnas>

<cláusula where> ::= WHERE <condición de búsqueda>

<cláusula group by> ::=

GROUP BY <lista de referencias a columna de agrupamiento>

<lista de referencias a columna de agrupamiento> ::=

<referencia a columna de agrupamiento>[{<coma><referencia a columnas de agrupamiento>}...]

<referencia a columna de agrupamiento> ::=

<referencia a columnas>

<referencias a columnas> ::=

[ <calificador> <punto> ] <nombre de columnna>

<cláusula having> ::= HAVING <condición de búsqueda>

<condición de búsqueda> ::=

<término booleano>

| <condición de búsqueda> OR <término booleano>

<término booleano> ::=

<factor booleano>

| <factor booleano> AND <factor booleano>

<factor booleano> ::=

[ NOT ] <test booleano>

<test booleano> ::=

<primario booleano> [ IS [ NOT ] <valor lógico> ]

<valor lógico> ::=

TRUE

| FALSE

| UNKNOWN

<primario booleano> ::=

<predicado>

| <parent. izq.> <condición de búsqueda> <parent. dcho.>

<predicado> ::=

<predicado de comparación>

| <predicado entre>

| <predicado en>

| <predicado parece>

| <predicado de nulidad>

| <predicado de comparación cuantificada>

| <predicado existe>

| <predicado de unicidad>

| <predicado de concordancia>

| <predicado de solapamiento>

<predicado de comparación> ::=

<constructor de valor de fila> <operación de comparación> <constructor de valor de fila>

<predicado entre> ::=

<constructor de valor de fila> ::= [ NOT ] BETWEEN


SQL

Pág. 20 de 21

<constructor de valor de fila> AND <constructor de valor de fila>

<predicado en> ::=

<constructor de valor de fila>

[ NOT ] IN <valor de predicado en>

<valor de predicado en> ::=

<subconsulta de tabla>

| <parent. izq.> <lista de valores en> <parent. dcho.>

<lista de valores en> ::=

<expresión de valor> { <coma> <expresión de valor> } ...

<predicado parece> ::=

valor de concordancia> [ NOT ] LIKE <patrón>

<valor de concordancia> ::= <expresión de valores caracter>

<patrón> ::= <expresión de valores caracter>

<predicado de nulidad> ::=

constructor de valor de fila> IS [ NOT ] NULL

<predicado de comparación cuantificada> ::=

constructor de valor de fila> <operación de comparación>

<cuantificador> <subconsulta de tabla>

<cuantificador> ::= <todos> | <algunos>

<todos> ::= ALL

<algunos> ::= SOME | ANY

<predicado existe> ::= EXISTS <subconsulta de tabla>

<predicado de unicidad> ::= UNIQUE <subconsulta de tabla>

<predicado de concordancia> ::=

<constructor de valor de fila>MATCH[ UNIQUE ][ PARTIAL | FULL]<subconsulta de tabla>

<predicado de solapamiento> ::=

<constructor de valor de fila 1> OVERLAPS <constructor de valor de fila 2>

<constructor de valor de fila 1> ::= <constructor de valor de fila>

<constructor de valor de fila 2> ::= <constructor de valor de fila>

Otras sentencias de manipulación de datos son las siguientes: <sentencia de borrado: con búsqueda> ::=

DELETE FROM <nombre de tabla>

[WHERE <condición de búsqueda>]

<sentencia de inserción> ::=

INSERT INTO <nombre de tabla>

<fuente y columnas de inserción>

<fuente y columnas de inserción> ::=

[ <parent. izq.> <lista de columnas de inserción> <parent. dcho.>] <expresión de consulta>

| DEFAULT VALUES

<lista de columnas de inserción> ::=

<lista de nombres de columnas>

<sentencia de modificación: con búsqueda> ::=

UPDATE <nombre de tabla>

SET <lista de cláusula de conjunto>

[WHERE <condición de búsqueda>]

<lista de cláusula de conjunto> ::=

<cláusula de conjunto> [ {<coma> <cláusula de conjunto>}...]

<cláusula de conjunto> ::=

<nombre de columna> <operador igual> <fuente de modificación>

<fuente de modificación> ::=

<expresión de valor>

| <especificación de nulos>

| DEFAULT


SQL

Pág. 21 de 21

Lenguaje de Administración de Datos <sentencia de concesión> ::=

GRANT <privilegios> ON <nombre de objeto>

TO <concedido> [{<coma> <concedido> } ... ]

[WITH GRANT OPTION]

<nombre de objeto> ::=

[ TABLE ] <nombre de tabla>

| DOMAIN <nombre de dominio>

<sentencia de revocación> ::=

REVOKE [GRANT OPTION FOR ] <privilegios>

ON <nombre de objeto>

FROM <concedido> [ { <coma> <concedido> } ... ] <comportamiento al borrar>

<privilegios> ::=

ALL PRIVILEGES

| <lista de acciones>

<lista de acciones> ::= <acción> [ { <coma> <acción> } ... ]

<acción> ::=

SELECT

| DELETE

| INSERT [ <parent. izq.> <lista de nombres de columnas> <parent. dcho.> ]

| UPDATE [ <parent. izq.> <lista de nombres de columnas> <parent. dcho.> ]

| REFERENCES[ <parent.izq.> <lista de nombresdecolumnas> <parent. dcho.> ]

| USAGE

<concedido> ::=

PUBLIC

| <id. de autorización de usuario>

Anotaciones: 1.- Relativas al <tipo de datos>

a) En SQL-92, además de los tipos de datos del SQL-89 (INTEGER, SMALLINT,CHARACTER, DECIMAL, NUMERIC, REAL, FLOAT y DOUBLE PRECISION) también se admiten los siguientes: CHARACTER

VARYING, DATE, TIME, BIT, TIMESTAMP,INTERVAL y BIT VARYING.

b) Los tipos BIT y BIT VARYING contienen bits pero no son interpretados por el SGBD; INTERVAL expresa la diferencia entre fechas u horas; y TIMESTAMP contiene año, mes, día, hora, minutos, segundos y,

opcionalmente, fracciones de segundo.

2.- Relativas a <expresión de valor>

a) Una <expresión de valor> es cualquier expresión que dé como resultado un valor numérico,carácter, hora, fecha o intervalo. Puede ser tan simple como un dígito o tan complejo como una subconsulta.

3.- Relativas a la <definición de restricción referencial>

a) Si <columnas y tabla referenciada> especifica una <lista de columnas de referencia>, ésta debe ser idéntica a una <lista de columnas únicas> en una <definición de restricción de unicidad> de la tabla referenciada. Se

puede establecer una restricción referencial con conjuntos de columnas únicas sin que sean necesariamente la

clave primaria. En caso de no especificar la <lista de columnas referencia> se entenderá que referencia a la

clave primaria.

b) En caso de no especificar la <acción referencial disparada> se considera que ésta es restringida. c) Las propuestas del estándar son más completas, incluyendo otros aspectos de las restricciones de integridad referencial como el tipo de concordancia (si todos los valores de la columnas que referencian pueden ser nulos

o no nulos o ambas cosas) y el modo de restricción (diferida, si se verifica al finalizar la transacción o

inmediata, si se efectúa al finalizar cada sentencia).

4.- Relativas a la <operación de comparación>.Las operaciones de comparación son las usuales: =, >, <, >=, <=, <> .

5.- Relativas a la dinámica. Existen además operaciones relacionadas con manejo de cursores.

Software

consultas en sql server