Académique Documents
Professionnel Documents
Culture Documents
SQL es un lenguaje de consulta para los sistemas de bases de datos relaciónales, pero que no posee la
potencia de los lenguajes de programación.
Para abordar el presente tutorial con mínimo de garantias es necesario conocer previamente SQL.
Transact SQL es el lenguaje de programación que proporciona SQL Server para ampliar SQL con los
elementos caracteristicos de los lenguajes de programación: variables, sentencias de control de flujo, bucles ...
Cuando se desea realizar una aplicación completa para el manejo de una base de datos relacional, resulta
necesario utilizar alguna herramienta que soporte la capacidad de consulta del SQL y la versatilidad de los
lenguajes de programación tradicionales. Transact SQL es el lenguaje de programación que proporcionaSQL
Server para extender el SQL estándar con otro tipo de instrucciones.
Transact SQL existe desde las primeras versiones de SQL Server, si bien a lo largo de este tutorial
nos centraremos en la versión SQL Server 2005.
Para poder seguir este tutorial correctamente necesitaremos tener los siguientes elementos:
Un servidor SQL Server 2005. Podemos descargar gratuitamente la versión SQL Server Express desde el
siguiente enlace.SQL Server 2005 Express.
Herramientas cliente de SQL Server. Recomendamos:
o Microsoft SQL Server Management Studio
o Toad para SQL Server
La instalación y configuración de SQL Server está fuera del alcance de este tutorial. Si bien podemos
acceder a una guía básica de instalación desde este enlace.
Introducción
SQL es un lenguaje de consulta para los sistemas de bases de datos relaciónales, pero que no posee la
potencia de los lenguajes de programación. No permite el uso de variables, estructuras de control de flujo,
bucles ... y demás elementos caracteristicos de la programación. No es de extrañar, SQL es un lenguaje de
consulta, no un lenguaje de programación.
Sin embargo, SQL es la herramienta ideal para trabajar con bases de datos. Cuando se desea realizar una
aplicación completa para el manejo de una base de datos relacional, resulta necesario utilizar alguna
herramienta que soporte la capacidad de consulta del SQL y la versatilidad de los lenguajes de programación
tradicionales. Transact SQL es el lenguaje de programación que proporciona Microsoft SQL Server para
extender el SQL estándar con otro tipo de instrucciones y elementos propios de los lenguajes de
programación .
Con Transact SQL vamos a poder programar las unidades de programa de la base de datos SQL Server,
están son:
Procedimientos almacenados
Funciones
Triggers
Scripts
Pero además Transact SQL nos permite realizar programas sobre las siguientes herramientas de SQL Server:
Service Broker
Como introducción vamos a ver algunos elementos y conceptos básicos del lenguaje.
/*
Este es un comentario con varias líneas.
Conjunto de Lineas.
*/
declare @nombre varchar(50)-- declare declara una variable
-- @nombre es el identificador de la
-- variable de tipo varchar
set @nombre = 'www.devjoker.com' -- El signo = es un operador
-- www.devjoker.com es un literal
print @Nombre -- Imprime por pantalla el valor de @nombre.
-- No diferencia mayúsculas ni minúsculas
Scripts y lotes.
Un script está compuesto por uno o varios lotes. Un lote delimita el alcance de las variables y sentencias del
script. Dentro de un mismo script se diferencian los diferentes lotes a través de las instrucción GO.
En ocasiones es necesario separar las sentencias en varios lotes, porque Transact SQL no permite la
ejecución de ciertos comandos en el mismo lote, si bien normalmente también se utilizan los lotes para realizar
separaciones lógicas dentro del script.
Cuando definimos una tabla, variable o constante debemos asignar un tipo de dato que indica los posibles
valores. El tipo de datos define el formato de almacenamiento, espacio que de disco-memoria que va a ocupar
un campo o variable, restricciones y rango de valores validos.
Transact SQL proporciona una variedad predefinida de tipos de datos . Casi todos los tipos de datos
manejados por Transact SQL son similares a los soportados por SQL.
SQL Server dispone de varios tipos de datos númericos. Cuanto mayor sea el número que puedan
almacenar mayor será en consecuencia el espacio utilizado para almacenarlo. Como regla general se
recomienda usar el tipo de dato mínimo posible. Todos los dato numéricos admiten el valor NULL.
Bit. Una columna o variable de tipo bit puede almacenar el rango de valores de 1 a 0.
Tinyint. Una columna o variable de tipo tinyint puede almacenar el rango de valores de 0 a 255.
SmallInt. Una columna o variable de tipo smallint puede almacenar el rango de valores -32768 a 32767.
Int. Una columna o variable de tipo int puede almacenar el rango de valores -231 a 231-1 .
BigInt. Una columna o variable de tipo bigint puede almacenar el rango de valores -263 a 263-1 .
Decimal(p,s). Una columna de tipo decimal puede almacenar datos númericos decimales sin redondear.
Donde p es la precision (número total del dígitos) y s la escala (número de valores decimales)
Float. Una columna de datos float puede almacenar el rango de valores -1,79x-10308 a 1,79x-10308, , si la
definimos con el valor máxmo de precisión. La precisión puede variar entre 1 y 53.
Real. Sinónimo de float(24). Puede almacenar el rango de valores -3,4x-1038 a 3,4x-1038,
Money. Almacena valores númericos monetarios de -263 a 263-1, con una precisión de hasta diexz milesimas
de la unidad monetaria.
SmallMoney. Almacena valores númericos monetarios de -214.748,3647 a 214.748,3647, con una precisión
de hasta diez milesimas de la unidad monetaria.
Todos los tipos de datos enteros pueden marcarse con la propiedad identity para hacerlos autonuméricos.
Char(n). Almacena n caracteres en formato ASCII, un byte por cada letra. Cuando almacenamos datos en el
tipo char, siempre se utilizan los n caracteres indicados, incluso si la entrada de datos es inferior. Por ejemplo,
si en un char(5), guardamos el valor 'A', se almacena 'A ', ocupando los cinco bytes.
Varchar(n).Almacena n caracteres en formato ASCII, un byte por cada letra. Cuando almacenamos datos en
el tipo varchar, unicamente se utilizan los caracteres necesarios,Por ejemplo, si en un varchar(255),
guardamos el valor 'A', se almacena 'A', ocupando solo un byte bytes.
Varchar(max). Igual que varchar, pero al declararse como max puede almacenar 231-1 bytes.
Nchar(n).Almacena n caracteres en formato UNICODE, dos bytes por cada letra. Es recomendable utilizar
este tipo de datos cuando los valores que vayamos a almacenar puedan pertenecer a diferente idomas.
Nvarchar(n).Almacena n caracteres en formato UNICODE, dos bytes por cada letra. Es recomendable utilizar
este tipo de datos cuando los valores que vayamos a almacenar puedan pertenecer a diferente idomas.
Nvarchar(max).Igual que varchar, pero al declararse como max puede almacenar 231-1 bytes.
Tipos de datos de fecha.
Datetime. Almacena fechas con una precision de milisegundo. Debe usarse para fechas muy especificas.
SmallDatetime. Almacena fechas con una precision de minuto, por lo que ocupa la mitad de espacio de que
el tipo datetime, para tablas que puedan llegar a tener muchos datos es un factor a tener muy en cuenta.
TimeStamp.Se utiliza para marcar un registro con la fecha de inserción - actualización. El tipo timestamp se
actualiza automáticamente cada vez que insertamos o modificamos los datos.
Binary. Se utiliza para almacenar datos binarios de longitud fija, con una longitud máxima de 8000 bytes.
Varbinary. Se utiliza para almacenar datos binarios de longitud variable, con una longitud máxima de 8000
bytes..Es muy similar a binary, salvo que varbinary utiliza menos espacio en disco.
XML.Una de las grandes mejoras que incorpora SQL Server 2005 es el soporte nativo para XML. Como
podemos deducir, este tipo de datos se utiliza para almacenar XML.
UniqueIdentifier. Se utiliza para identificadores únicos. Para generar identificadores únicos debemos utilizar
la función NEWID().
Sql_Variant.Permite almacenar valores de diferentes tipos de datos. No puede almacena varchar(max), xml,
timestamp y tipos de datos definidos por el usuario.
Una variable es un valor identificado por un nombre (identificador) sobre el que podemos realizar
modificaciones.
En Transact SQL los identificadores de variables deben comenzar por el caracter @, es decir, el nombre
de una variable debe comenzar por @. Para declarar variables en Transact SQL debemos utilizar la palabra
clave declare, seguido del identificador y tipo de datos de la variable.
/*
Este es un comentario con varias líneas.
Conjunto de Lineas.
*/
declare @nombre varchar(50)-- declare declara una variable
-- @nombre es el identificador de la
-- variable de tipo varchar
set @nombre = 'www.devjoker.com' -- El signo = es un operador
-- www.devjoker.com es un literal
print @Nombre -- Imprime por pantalla el valor de @nombre.
-- No diferencia mayúsculas ni minúsculas
El siguiente ejemplo muestra como asignar una variable utilizando la instrucción SET.
DECLARE @nombre VARCHAR(100)
FROM CLIENTES
WHERE ID = 1)
PRINT @nombre
El siguiente ejemplo muestra como asignar variables utilizando una sentencia SELECT.
@apellido1 VARCHAR(100),
@apellido2 VARCHAR(100)
SELECT @nombre=nombre ,
@apellido1=Apellido1,
@apellido2=Apellido2
FROM CLIENTES
WHERE ID = 1
PRINT @nombre
PRINT @apellido1
PRINT @apellido2
Un punto a tener en cuenta cuando asignamos variables de este modo, es que si la consulta SELECT
devuelve más de un registro, las variables quedarán asignadas con los valores de la última fila devuelta.
@apellido1 VARCHAR(100),
@apellido2 VARCHAR(100)
FOR
FROM CLIENTES
OPEN CDATOS
WHILE (@@FETCH_STATUS = 0)
BEGIN
PRINT @nombre
PRINT @apellido1
PRINT @apellido2
END
CLOSE CDATOS
DEALLOCATE CDATOS
Veremos los cursores con más detalle más adelante en este tutorial.
Operador de asignación =
Operadores aritméticos + (suma)
- (resta)
* (multiplicación)
/ (división)
** (exponente)
% (modulo)
Operadores relacionales = (igual a)
o de comparación <> (distinto de)
!= (distinto de)
< (menor que)
> (mayor que)
>= (mayor o igual a)
<= (menor o igual a)
!> (no mayor a)
!< (no menor a)
Operadores lógicos AND (y lógico)
NOT (negacion)
OR (o lógico)
& (AND a nivel de bit)
| (OR a nivel de bit)
^ (OR exclusivo a nivel de bit)
Operador de +
concatenación
ALL (Devuelve TRUE si el conjunto completo de comparaciones es
TRUE)
ANY(Devuelve TRUE si cualquier elemento del conjunto de
comparaciones es TRUE)
BETWEEN (Devuelve TRUE si el operando está dentro del intervalo)
Otros EXISTS (TRUE si una subconsulta contiene filas)
IN (TRUE si el operando está en la lista)
LIKE (TRUE si el operando coincide con un patron)
NOT (Invierte el valor de cualquier operador booleano)
SOME(Devuelve TRUE si alguna de las comparaciones de un conjunto
es TRUE)
Estructura condicional IF
La estuctura condicional IF permite evaluar una expresion booleana (resultado SI - NO), y ejecutar las
operaciones contenidas en el bloque formado por BEGIN END.
IF (<expresion>)
BEGIN
...
END
ELSE IF (<expresion>)
BEGIN
...
END
ELSE
BEGIN
...
END
IF @diminutivo = 'DJK'
BEGIN
PRINT 'www.devjoker.com'
END
ELSE
BEGIN
PRINT 'Otra Web (peor!)'
END
ELSE
BEGIN
INSERT INTO PAISES
(CO_PAIS, DESCRIPCION) VALUES
(@coPais, @descripcion)
END
La estructura condicional CASE permite evaluar una expresion y devolver un valor u otro.
Ejemplo de CASE.
CASE
WHEN <expresion> = <valor_expresion> THEN <valor_devuelto>
WHEN <expresion> = <valor_expresion> THEN <valor_devuelto>
ELSE <valor_devuelto> -- Valor por defecto
END
Bucle WHILE
WHILE <expresion>
BEGIN
...
END
Estructura GOTO
La sentencia goto nos permite desviar el flujo de ejecución hacia una etiqueta. Fué muy utilizada en
versiones anteriores de SQL Server conjuntamente con la variable de sistema @@ERROR para el control de
errores.
Actualmente, se desaconseja el uso GOTO, recomendandose el uso de TRY - CATCH para la gestion de
errores.
A partIr de la versión 2005, SQL Server proporciona el control de errores a través de las
instrucciónesTRY y CATCH.
Estas nuevas instrucciones suponen un gran paso adelante en el control de errores en SQL Server, un
tanto precario en las versiones anteriores.
BEGIN TRY
...
END TRY
BEGIN CATCH
...
END CATCH
BEGIN TRY
@dividendo int,
@resultado int
SET @divisor = 0
Las funciones especiales de error,están disponibles únicamente en el bloque CATCH para la obtención de
información detallada del error.
Son:
BEGIN TRY
@dividendo int,
@resultado int
SET @divisor = 0
Lógicamente, podemos utilizar estas funciones para almacenar esta información en una tabla de la base de
datos y registrar todos los errores que se produzcan.
IF @@ERROR = 0
BEGIN
PRINT 'No hay error'
END
ELSE
BEGIN
PRINT 'Hay error'
END
El uso de @@ERROR para controlar errores puede provocar multitud de problemas. Uno de los más
habituales es sin duda, incluir una nueva sentencia Transact SQL entre la línea que provoco el error y la que
lo controla. Esa nueva instrucción restaura el valor de @@ERROR y no controlaremos el error.
En ocasiones es necesario provocar voluntariamente un error, por ejemplo nos puede interesas que se
genere un error cuando los datos incumplen una regla de negocio.
Podemos provocar un error en tiempo de ejecución a través de la función RAISERROR.
SET @tipo = 1
SET @clasificacion = 3
IF (@tipo = 1 AND @clasificacion = 3)
BEGIN
RAISERROR ('El tipo no puede valer uno y la clasificacion 3',
16, -- Severidad
1 -- Estado
)
END
La función RAISERROR recibe tres parámetros, el mensaje del error (o código de error predefinido), la
severidad y el estado.
La severidad indica el grado de criticidad del error. Admite valores de 0 al 25, pero solo podemos
asignar valores del 0 al 18. Los errores el 20 al 25 son considerados fatales por el sistema, y cerraran la
conexion que ejecuta el comando RAISERROR. Para asignar valores del 19 al 25 necesitares ser miembros
de la función de SQL Server sysadmin.
El estado es un valor para permitir que el programador identifique el mismo error desde diferentes partes
del código. Admite valores entre 1 y 127, permite tratar .
La sentencia SELECT
La sentencia SELECT nos permite consultar los datos almacenados en una tabla de la base de datos.
El siguiente ejemplo muestra una consulta sencilla que obtiene el código y la "familia" de una tabla llamada
familias (representaría familias de productos por ejemplo).
SELECT CO_FAMILIA, FAMILIA
FROM FAMILIAS
El uso del asterisco indica que queremos que la consulta devuelva todos los campos que existen en la tabla.
SELECT *
FROM FAMILIAS
Ahora vamos a realizar una consulta obteniendo además de los datos de familias, los datos de las categorias
y los productos.
SELECT *
FROM FAMILIAS
ON CATEGORIAS.CO_FAMILIA = FAMILIAS.CO_FAMILIA
ON PRODUCTOS.CO_CATEGORIA = CATEGORIAS.CO_CATEGORIA
La combinación se realiza a través de la clausula INNER JOIN, que es una clasula exclusiva, es decir las
familias que no tengan categorias y productos asociados no se devolveran.
Si queremos realizar la consulta para que no sea exclusiva, tenemos que utilizar LEFT JOIN. El uso de la
palabra reservada OUTER es opcional.
SELECT *
FROM FAMILIAS
ON CATEGORIAS.CO_FAMILIA = FAMILIAS.CO_FAMILIA
ON PRODUCTOS.CO_CATEGORIA = CATEGORIAS.CO_CATEGORIA
Los registros que no tengan datos relacionados en una consulta LEFT JOIN devolveran en valor null en los
campos que correspondan a las tablas en las que no tienen dato.
También podemos forzar un producto cartesiano (todos con todos) a través de CROSS JOIN.
La cláusula WHERE
La cláusula WHERE es la instrucción que nos permite filtrar el resultado de una sentencia SELECT.
FROM FAMILIAS
WHERE CO_FAMILIA = 1
SELECT *
FROM FAMILIAS
WHERE CO_FAMILIA = 1
OR CO_FAMILIA = 2
SELECT *
FROM FAMILIAS
WHERE CO_FAMILIA IN ( 1 , 2)
La clausula WHERE se puede utilizar conjuntamente con INNER JOIN, LEFT JOIN ...
SELECT FAMILIAS.CO_FAMILIA,
FAMILIAS.FAMILIA
FROM FAMILIAS
ON CATEGORIAS.CO_FAMILIA = FAMILIAS.CO_FAMILIA
Siempre que incluyamos un valor alfanumerico para un campo en la condición WHERE este debe ir entre
comillas simples:
SELECT *
FROM FAMILIAS
SELECT *
FROM FAMILIAS
Podemos limitar el número de registros que devuelve la consulta a través de la clausula TOP. La
clausulaTOP admite como parámetros un valor numérico entero o un porcentaje (sólo a partir de la version
2005)
FROM FAMILIAS
FROM FAMILIAS
La cláusula ORDER BY
Podemos especificar el orden en el que serán devueltos los datos a través de la cláusula ORDER BY.
FROM FAMILIAS
También podemos indicar el índice del campo en la lista de selección en lugar de su nombre :
FROM FAMILIAS
Consultas agregadas
La cláusula GROUP BY
La clausula GROUP BY combina los registros devueltos por una consulta SELECT obteniendo uno o varios
valores agregados(suma, valor mínimo y máximo ...).
Para cada registro se puede crear un valor agregado si se incluye una función SQL agregada, como por
ejemplo Sum o Count, en la instrucción SELECT. Su sintaxis es:
SELECT [ALL | DISTINCT ] [TOP <n> [WITH TIES]]
<nombre_campo> [{,<nombre_campo>}]
[{,<funcion_agregado>}]
FROM <nombre_tabla>|<nombre_vista>
[{,<nombre_tabla>|<nombre_vista>}]
[WHERE <condicion> [{ AND|OR <condicion>}]]
[GROUP BY <nombre_campo> [{,<nombre_campo >}]]
[HAVING <condicion>[{ AND|OR <condicion>}]]
[ORDER BY <nombre_campo>|<indice_campo> [ASC | DESC]
[{,<nombre_campo>|<indice_campo> [ASC | DESC ]}]]
Si se utiliza GROUP BY pero no existe una función SQL agregada en la instrucción SELECT se obtiene el
mismo resultado que con una consulta SELECT DISTINCT. Los valores Null en los campos GROUP BY se
agrupan y no se omiten. No obstante, los valores Null no se evalúan en ninguna de las funciones SQL
agregadas.
Todos los campos de la lista de campos de SELECT deben incluirse en la cláusula GROUP BY o como
argumentos de una función SQL agregada.
El siguiente ejemplo realiza una "cuenta" de los datos que hay en la tabla PRODUCTOS.
SELECT COUNT(*)
FROM PRODUCTOS
Este otro ejemplo, muestra la suma del PRECIO de cada uno de los productos que componen un pedido,
para calcular el total del pedido agrupados por los datos del cliente.
SELECT CLIENTES.NOMBRE,
CLIENTES.APELLIDO1,
CLIENTES.APELLIDO2,
FROM DETALLE_PEDIDO
ON DETALLE_PEDIDO.CO_PEDIDO = PEDIDOS.CO_PEDIDO
GROUP BY CLIENTES.NOMBRE,
CLIENTES.APELLIDO1,
CLIENTES.APELLIDO2
Siempre que incluyamos una clausula WHERE en una consulta agregada esta se aplica antes de calcular el
valor agregado. Es decir, si sumamos el valor de las ventas por producto, la suma se calcula despues de haber
aplicado el filtro impuesto por la clausula WHERE.
SELECT CLIENTES.NOMBRE,
CLIENTES.APELLIDO1,
CLIENTES.APELLIDO2,
FROM DETALLE_PEDIDO
ON DETALLE_PEDIDO.CO_PEDIDO = PEDIDOS.CO_PEDIDO
ON PEDIDOS.CO_CLIENTE = CLIENTES.CO_CLIENTE
GROUP BY CLIENTES.NOMBRE,
CLIENTES.APELLIDO1,
CLIENTES.APELLIDO2
La cláusula HAVING
Es posible que necesitemos calcular un agregado, pero que no necesitemos obtener todos los datos, solo
los que cumplan una condición del agregado. Por ejemplo, podemos calcular el valor de las ventas por
producto, pero que solo queramos ver los datos de los producto que hayan vendido más o menos de una
determinada cantidad. En estos casos debemos utilizar la clausula HAVING.
Una vez que GROUP BY ha combinado los registros, HAVING muestra cualquier registro agrupado por la
cláusula GROUP BY que satisfaga las condiciones de la cláusula HAVING. Se utiliza la cláusula WHEREpara
excluir aquellas filas que no desea agrupar, y la cláusula HAVING para filtrar los registros una vez
agrupados.
HAVING es similar a WHERE, determina qué registros se seleccionan pero despues de calcular el
agregado. Una vez que los registros se han agrupado utilizando GROUP BY, HAVING determina cuales de
ellos se van a mostrar. HAVING permite el uso de funciones agregadas.
SELECT CLIENTES.NOMBRE,
CLIENTES.APELLIDO1,
CLIENTES.APELLIDO2,
FROM DETALLE_PEDIDO
ON DETALLE_PEDIDO.CO_PEDIDO = PEDIDOS.CO_PEDIDO
ON PEDIDOS.CO_CLIENTE = CLIENTES.CO_CLIENTE
GROUP BY CLIENTES.NOMBRE,
CLIENTES.APELLIDO1,
CLIENTES.APELLIDO2
Funciones agregadas.
Transact SQL pone a nuestra disposición multiples funciones agregadas, las más comunes son:
MAX
MIN
COUNT
SUM
AVG
AVG
AVG(<expr>)
En donde expr representa el campo que contiene los datos numéricos para los que se desea calcular la
media o una expresión que realiza un cálculo utilizando los datos de dicho campo. La media calculada por Avg
es la media aritmética (la suma de los valores dividido por el número de valores). La función Avg no incluye
ningún campo Null en el cálculo.
SELECT CLIENTES.NOMBRE,
CLIENTES.APELLIDO1,
CLIENTES.APELLIDO2,
FROM DETALLE_PEDIDO
ON DETALLE_PEDIDO.CO_PEDIDO = PEDIDOS.CO_PEDIDO
ON PEDIDOS.CO_CLIENTE = CLIENTES.CO_CLIENTE
GROUP BY CLIENTES.NOMBRE,
CLIENTES.APELLIDO1,
CLIENTES.APELLIDO2
Count
COUNT(<expr>)
En donde expr contiene el nombre del campo que desea contar. Los operandos de expr pueden incluir el
nombre de un campo de una tabla, una constante o una función (la cual puede ser intrínseca o definida por el
usuario pero no otras de las funciones agregadas de SQL). Puede contar cualquier tipo de datos incluso texto.
Aunque expr puede realizar un cálculo sobre un campo, Count simplemente cuenta el número de registros
sin tener en cuenta qué valores se almacenan en los registros. La función Count no cuenta los registros que
tienen campos null a menos que expr sea el carácter comodín asterisco (*). Si utiliza un asterisco, Count
calcula el número total de registros, incluyendo aquellos que contienen campos null. Count(*) es
considerablemente más rápida que Count(Campo).
SELECT COUNT(*)
FROM PEDIDOS
FROM PEDIDOS
ON PEDIDOS.CO_CLIENTE = CLIENTES.CO_CLIENTE
GROUP BY CLIENTES.NOMBRE
Max, Min
MIN(<expr>)
MAX(<expr>)
En donde expr es el campo sobre el que se desea realizar el cálculo. Expr pueden incluir el nombre de un
campo de una tabla, una constante o una función (la cual puede ser intrínseca o definida por el usuario pero
no otras de las funciones agregadas de SQL).
SELECT CLIENTES.NOMBRE,
MIN(PEDIDOS.FX_ALTA),
MAX(PEDIDOS.FX_ALTA)
FROM PEDIDOS
ON PEDIDOS.CO_CLIENTE = CLIENTES.CO_CLIENTE
GROUP BY CLIENTES.NOMBRE
Sum
Devuelve la suma del conjunto de valores contenido en un campo especifico de una consulta. Su sintaxis
es:
SUM(<expr>)
En donde expr respresenta el nombre del campo que contiene los datos que desean sumarse o una
expresión que realiza un cálculo utilizando los datos de dichos campos. Los operandos de expr pueden incluir
el nombre de un campo de una tabla, una constante o una función (la cual puede ser intrínseca o definida por
el usuario pero no otras de las funciones agregadas de SQL).
SELECT CLIENTES.NOMBRE,
SUM(PEDIDOS.TOTAL_PEDIDO)
FROM PEDIDOS
ON PEDIDOS.CO_CLIENTE = CLIENTES.CO_CLIENTE
GROUP BY CLIENTES.NOMBRE
Podemos utilizar SELECT TOP con consultas agregadas como con cualquier otra instruccion Transact
SQL.
En estos casos, la clausula TOP se aplica despues de calcular el agregado, devolviendo las N filas indicadas.
En este escenario es posible que queramos obtener los N valores que satisfagan una condicion. Por
ejemplo, queremos si queremos obtener los tres primeros clientes con mayores pedidos, usariamos una
consulta parecida a esta:
SELECT TOP 3
CLIENTES.NOMBRE,
SUM(DETALLE_PEDIDO.PRECIO)
FROM DETALLE_PEDIDO
ON DETALLE_PEDIDO.CO_PEDIDO = PEDIDOS.CO_PEDIDO
ON PEDIDOS.CO_CLIENTE = CLIENTES.CO_CLIENTE
GROUP BY CLIENTES.NOMBRE
ORDER BY 2 -- SUM(DETALLE_PEDIDO.PRECIO_UNIDAD)
Sin embargo, puede darse el caso, de que el cuarto cliente devuelto por la consulta tenga un valor
agragado identico al tercero, (es decir, estan empatados). El uso de TOP 3 discriminaría el cuarto registro.
Para evitar este comportamiento, y que la consulta devuelva también al cuarto cliente utilizamos la
clausulaWITH TIES.
FROM DETALLE_PEDIDO
ON DETALLE_PEDIDO.CO_PEDIDO = PEDIDOS.CO_PEDIDO
ON PEDIDOS.CO_CLIENTE = CLIENTES.CO_CLIENTE
GROUP BY CLIENTES.NOMBRE
ORDER BY 2 -- SUM(DETALLE_PEDIDO.PRECIO_UNIDAD)
A partir de la version 2000 SQL Server incluye la clausula FOR XML para la consultas. Sin embargo, es a
partir de la versión 2005 cuando se integra XML como tipo de dato nativo.
Cuando especificamos la clausula FOR XML el resultado de la consulta es devuelto en formato XML.
La clausula FOR XML admite los siguientes modos que representan el formato en el que el XML
es devuelto:
XML AUTO, el modo AUTO emplea los campos en la declaración SELECT para formar una
jerarquía simple XML.
XML RAW, el modo RAW genera elementos únicos, los cuales se denominan row, por cada fila
retornada.
EXPLICIT, el modo EXPLICIT requiere un formato específico que puede ser mapeado en casi
cualquier forma XML, y al mismo tiempo ser formulado por una sola consulta SQL.
Adicionalmente, disponemos de dos opciones más TYPE y ELEMENTS que determinan el formato
del XML resultante. Los vemos con ejemplos.
FROM FAMILIAS
ORDER BY FAMILIA
FROM FAMILIAS
<CO_FAMILIA>1</CO_FAMILIA>
<FAMILIA>FAMILIA 1</FAMILIA>
</FAMILIAS>
<FAMILIAS>
<CO_FAMILIA>2</CO_FAMILIA>
<FAMILIA>FAMILIA 2</FAMILIA>
</FAMILIAS>
<FAMILIAS>
<CO_FAMILIA>3</CO_FAMILIA>
<FAMILIA>FAMILIA 3</FAMILIA>
</FAMILIAS>
<FAMILIAS>
<CO_FAMILIA>4</CO_FAMILIA>
<FAMILIA>FAMILIA 4</FAMILIA>
</FAMILIAS>
FROM FAMILIAS
ORDER BY FAMILIA
<row>
<CO_FAMILIA>1</CO_FAMILIA>
<FAMILIA>FAMILIA 1</FAMILIA>
</row>
<row>
<CO_FAMILIA>2</CO_FAMILIA>
<FAMILIA>FAMILIA 2</FAMILIA>
</row>
<row>
<CO_FAMILIA>3</CO_FAMILIA>
<FAMILIA>FAMILIA 3</FAMILIA>
</row>
<row>
<CO_FAMILIA>4</CO_FAMILIA>
<FAMILIA>FAMILIA 4</FAMILIA>
</row>
FROM FAMILIAS
ORDER BY FAMILIA
FROM FAMILIAS
ORDER BY FAMILIA
<FamiliasDeProductos>
<CO_FAMILIA>1</CO_FAMILIA>
<FAMILIA>FAMILIA 1</FAMILIA>
</FamiliasDeProductos>
<FamiliasDeProductos>
<CO_FAMILIA>2</CO_FAMILIA>
<FAMILIA>FAMILIA 2</FAMILIA>
</FamiliasDeProductos>
<FamiliasDeProductos>
<CO_FAMILIA>3</CO_FAMILIA>
<FAMILIA>FAMILIA 3</FAMILIA>
</FamiliasDeProductos>
<FamiliasDeProductos>
<CO_FAMILIA>4</CO_FAMILIA>
<FAMILIA>FAMILIA 4</FAMILIA>
</FamiliasDeProductos>
SELECT
1 AS TAG, -- La primera columna debe tener el alias TAG
-- <NombreNodo>!<nodo>!<atributo>
CO_FAMILIA as "FamiliaDeProductos!1!CODIGO_FAMILIA",
FAMILIA as "FamiliaDeProductos!1!DESCRIPCION"
FROM FAMILIAS
ORDER BY FAMILIA
Dado que XML es un tipo nativo de XML podemos definir tablas con campos de tipo XML, variables ...
GO
UNION
UNION devuelve la suma de dos o más conjuntos de resultados. El conjunto obtenido como resultado
deUNION tiene la misma estructura que los conjuntos originales.
FROM EMPLEADOS
UNION
FROM CLIENTES
Cuando realizamos una consulta con UNION internamente se realiza una operacion DISTINCT sobre el
conjunto de resultados final. Si queremos obtener todos los valores debemos utiliza UNION ALL.
FROM EMPLEADOS
UNION ALL
FROM CLIENTES
EXCEPT
EXCEPT devuelve la diferencia (resta) de dos o más conjuntos de resultados. El conjunto obtenido como
resultado de EXCEPT tiene la misma estructura que los conjuntos originales.
FROM EMPLEADOS
EXCEPT
FROM CLIENTES
El uso de EXCEPT, como norma general, es mucho más rápido que utilizar condiciones NOT
IN oEXISTS en la clausula WHERE.
INTERSECT
Devuelve la intersección entre dos o más conjuntos de resultados en uno. El conjunto obtenido como
resultado de INTERSECT tiene la misma estructura que los conjuntos originales.
FROM EMPLEADOS
INTERSECT
FROM CLIENTES
Para realizar la insercción individual de filas SQL posee la instrucción INSERT INTO.La insercción individual
de filas es la que más comunmente utilizaremos. Su sintaxis es la siguiente:
VALUES
(10, getdate(),getdate()+30, 1)
También es posible insertar en una tabla el resultado de una consulta SELECT. De este modo se insertarán
tantas filas como haya devuelto la consulta SELECT.
(PRECIO,
FX_INICIO,
FX_FIN,
CO_PRODUCTO)
SELECT PRECIO_UNIDAD,
getdate(),
getdate() + 30,
CO_PRODUCTO
FROM DETALLE_PEDIDO
También podemos forzar a que la insercción se realice con los datos por defecto establecidos para la tabla
(o null si no tienen valores por defecto).
En SQL Sever podemos marcar un campo de una tabla como autonumérico (identity), cuando insertamos
un registro en dicha tabla el valor del campo se genera automaticamente. Para recuperar el valor generado
disponemos de varios métodos:
Utilizar la funcion @@identity, que devuelve el último valor identidad insertado por la
transaccion:
VALUES
(10, getdate(),getdate()+30, 1)
PRINT @Codigo
El uso de @@Identity no siempre es válido, ya que al devolver el úlitmo valor identidad insertado por la
transacción, no nos garantiza que el valor haya sido insertado en la tabla que nos interesa (por ejemplo la
tabla podría tener un trigger que insertara datos en otra tabla con campos identidad).
VALUES
(10, getdate(),getdate()+30, 1)
PRINT @Codigo
Clausula OUTPUT
A partir de la version de SQL Server 2005 disponemos de la clausula OUTPUT para recuperar los valores
que hemos insertado. Al igual que en un trigger disponemos de las tablas lógicas INSERTED yDELETED.
Las columnas con prefijo DELETED reflejan el valor antes de que se complete la
instrucción UPDATE oDELETE. Es decir, son una copia de los datos "antes" del cambio.
Las columnas con prefijo INSERTED reflejan el valor después de que se complete la
instrucciónUPDATE o INSERT, pero antes de que se ejecuten los desencadenadores. Es decir, son una copia
de los datos "despues" del cambio.
( CO_PRECIO int,
PRECIO decimal,
FX_INICIO datetime,
FX_FIN datetime,
CO_PRODUCTO int
VALUES
(10, getdate(),getdate()+30, 1)
Update
Para la actualización de datos Transact SQL dispone de la sentencia UPDATE. La sentencia UPDATE
permite la actualización de uno o varios registros de una única tabla. La sintaxis de la sentencia UPDATE es la
siguiente
UPDATE <nombre_tabla>
SET <campo1> = <valor1>
{[,<campo2> = <valor2>,...,<campoN> = <valorN>]}
[ WHERE <condicion>];
UPDATE CLIENTES
SET
NOMBRE = 'Devjoker',
APELLIDO1 = 'Herrarte',
APELLIDO2 = 'Sánchez'
WHERE CO_CLIENTE = 10
Un aspecto a tener en cuenta, sobre todo si has trabajado con ORACLE, es que SQL graba los cambios
inmediatamente sin necesidad de hacer COMMIT. Por supuesto podemos gestionar nosostros las
transacciones pero es algo que hay que hacer de forma explicita con la instruccion BEGIN TRAN y que se
verá en capitulos posteriores de este tutorial.
En ocasiones queremos actaualizar los datos de una tabla con los datos de otra (muy común para
desnormalizar un modelo de datos).
Habitualmente, usamos subconsultas para este proposito, pero Transact SQL permite la utilización de la
sentencia UPDATE INNER JOIN.
UPDATE CLIENTES
SET
NOMBRE = FICHERO_CLIENTES.NOMBRE,
APELLIDO1 = FICHERO_CLIENTES.APELLIDO1,
APELLIDO2 = FICHERO_CLIENTES.APELLIDO2
FROM CLIENTES
ON FICHERO_CLIENTES.CO_CLIENTE = CLIENTES.CO_CLIENTE
Clausula OUTPUT
A partir de la version de SQL Server 2005 disponemos de la clausula OUTPUT para recuperar los valores
que hemos insertado. Al igual que en un trigger disponemos de las tablas lógicas INSERTED yDELETED.
Las columnas con prefijo DELETED reflejan el valor antes de que se complete la
instrucción UPDATE oDELETE. Es decir, son una copia de los datos "antes" del cambio.
( CO_CLIENTE int ,
NOMBRE varchar(100),
APELLIDO1 varchar(100),
APELLIDO2 varchar(100)
UPDATE CLIENTES
SET
NOMBRE = 'Devjoker',
APELLIDO1 = 'Herrarte',
APELLIDO2 = 'Sánchez'
( CO_CLIENTE int ,
NOMBRE varchar(100),
APELLIDO1 varchar(100),
APELLIDO2 varchar(100)
UPDATE CLIENTES
SET
NOMBRE = 'Devjoker',
APELLIDO1 = 'Herrarte',
APELLIDO2 = 'Sánchez'
Delete
Para ejecutar los ejemplos de este capitulo debemos ejecutar el siguiente script, que crea la tabla "DATOS"
y carga registros en ella.
CREATE TABLE DATOS
dato varchar(100),
fx_alta datetime,
GO
DECLARE @i int,
@dato varchar(100)
set @i = 0
BEGIN
SET @i = @i +1
END
GO
DELETE
FROM DATOS
Lógicamente podemos especicar que registros queremos borrar a través de la clausula WHERE.
DELETE
FROM DATOS
WHERE Id=12
Cuando borramos datos de una tabla, podemos obtener el número de filas que han sido afectadas por la
instrucción a través de la variable @@RowCount.
DELETE
FROM DATOS
WHERE Id=17
SELECT @@ROWCOUNT
Clausula OUTPUT
A partir de la version de SQL Server 2005 disponemos de la clausula OUTPUT para recuperar los valores
que hemos insertado. Al igual que en un trigger disponemos de las tablas lógicas INSERTED yDELETED.
Las columnas con prefijo DELETED reflejan el valor antes de que se complete la
instrucción UPDATE oDELETE. Es decir, son una copia de los datos "antes" del cambio.
Id int,
dato varchar(100),
fx_alta datetime
DELETE
FROM DATOS
WHERE Id=17
Truncate Table
Para borrar datos de forma masiva disponemos de la instrucción TRUNCATE TABLE, que borra todos los
datos de una tabla.
Cuando trabajamos con TRUNCATE TABLE debemos tener en cuenta las siguientes consideraciones:
Concepto de transaccion
Una transacción es un conjunto de operaciones Transact SQL que se ejecutan como un único bloque, es
decir, si falla una operación Transact SQL fallan todas. Si una transacción tiene éxito, todas las
modificaciones de los datos realizadas durante la transacción se confirman y se convierten en una parte
permanente de la base de datos. Si una transacción encuentra errores y debe cancelarse o revertirse, se
borran todas las modificaciones de los datos.
El ejemplo clásico de transacción es una transferencia bancaria, en la que quitamos saldo a una cuenta y lo
añadimos en otra. Si no somo capaces de abonar el dinero en la cuenta de destino, no debemos quitarlo de la
cuenta de origen.
SQL Server funciona por defecto con Transacciones de confirmación automática , es decir, cada
instrucción individual es una transacción y se confirma automáticamente.
Sobre el ejemplo anterior de la transferencia bancaria, un script debería realizar algo parecido a los
siguiente:
@CuentaOrigen VARCHAR(12),
@CuentaDestino VARCHAR(12)
*/
SET @importe = 50
UPDATE CUENTAS
/* Registramos el movimiento */
SELECT
UPDATE CUENTAS
/* Registramos el movimiento */
SELECT
FROM CUENTAS
Esta forma de actuar seria erronea, ya que cada instrucción se ejecutaria y confirmaría
de forma independiente, por lo que un error dejaría los datos erroneos en la base de
datos ( ¡y ese es el peor error que nos podemos encontrar! )
Para agrupar varias sentencias Transact SQL en una única transacción, disponemos de los siguientes
métodos:
Transacciones explícitas
Cada transacción se inicia explícitamente con la instrucción BEGIN TRANSACTION y se
termina explícitamente con una instrucción COMMIT o ROLLBACK.
Transacciones implícitas
Se inicia automátivamente una nueva transacción cuando se ejecuta una
instrucción que realiza modificaciones en los datos, pero cada transacción se completa
explícitamente con una instrucciónCOMMIT o ROLLBACK.
SET IMPLICIT_TRANSACTIONS ON
@CuentaOrigen VARCHAR(12),
@CuentaDestino VARCHAR(12)
*/
SET @importe = 50
BEGIN TRY
UPDATE CUENTAS
/* Registramos el movimiento */
SELECT
FROM CUENTAS
UPDATE CUENTAS
/* Registramos el movimiento */
SELECT
FROM CUENTAS
END TRY
BEGIN CATCH
END CATCH
SET IMPLICIT_TRANSACTIONS ON
@CuentaOrigen VARCHAR(12),
@CuentaDestino VARCHAR(12)
*/
SET @importe = 50
BEGIN TRY
UPDATE CUENTAS
/* Registramos el movimiento */
SELECT
FROM CUENTAS
UPDATE CUENTAS
/* Registramos el movimiento */
SELECT
FROM CUENTAS
/* Confirmamos la transaccion*/
END TRY
BEGIN CATCH
END CATCH
La transacción sigue activa hasta que emita una instrucción COMMIT o ROLLBACK. Una vez que la
primera transacción se ha confirmado o revertido, se inicia automáticamente una nueva transacción la
siguiente vez que la conexión ejecuta una instruccion para modificar datos.
La conexión continúa generando transacciones implícitas hasta que se desactiva el modo de transacciones
implícitas.
SET IMPLICIT_TRANSACTIONS ON
BEGIN TRY
PRINT @@TRANCOUNT
COMMIT
END TRY
BEGIN CATCH
ROLLBACK
PRINT 'Error'
END CATCH
Otro punto a tener en cuenta cuando trabajamos con transacciones son los bloqueos y el nivel de
aislamiento. Podemos aprender más sobre bloqueos y nivel de aislamiento en este articulo.
Transacciones anidadas.
Podemos anidar varias transacciones. Cuando anidamos varias transacciones la instrucción COMMIT
afectará a la última transacción abierta, pero ROLLBACK afectará a todas las transacciones abiertas.
Un hecho a tener en cuenta, es que, si hacemos ROLLBACK de la transacción superior se desharan también
los cambios de todas las transacciones internas, aunque hayamos realizado COMMIT de ellas.
BEGIN TRAN
UPDATE EMPLEADOS
WHERE ID=101
BEGIN TRAN
UPDATE EMPLEADOS
WHERE ID=101
-- Este COMMIT solo afecta a la segunda transaccion.
COMMIT
ROLLBACK
Una consideración a tener en cuanta cuando trabajamos con transacciones anidadas es la posibilidad de
utilizar puntos de guardado o SAVEPOINTs.
Los puntos de recuperación (SavePoints) permiten manejar las transacciones por pasos, pudiendo hacer
rollbacks hasta un punto marcado por el savepoint y no por toda la transacción.
BEGIN TRAN
UPDATE EMPLEADOS
WHERE ID=101
UPDATE EMPLEADOS
WHERE ID=101
WHERE ID=101
ROLLBACK TRANSACTION P1
-- Confirmamos la transaccion
COMMIT
En Transact SQL los procedimientos almacenados pueden devolver valores (numerico entero) o conjuntos
de resultados.
AS
AS
@apellido1 varchar(100),
@apellido2 varchar(100),
@nifCif varchar(20),
@fxNaciento datetime
AS
Para la ejecutar un procedimiento almacenado debemos utilizar la sentencia EXEC. Cuando la ejecución del
procedimiento almacenado es la primera instrucción del lote, podemos omitir el uso de EXEC.
Siempre es deseable que las instrucciones del procedure esten dentro de un bloque TRY CATCH y
controlados por una transacción.
@apellido2 varchar(100),
@nifCif varchar(20),
@fxNaciento datetime
AS
BEGIN TRY
BEGIN TRAN
COMMIT
END TRY
BEGIN CATCH
ROLLBACK
PRINT ERROR_MESSAGE()
END CATCH
AS
BEGIN
END
PRINT @saldo
AS
BEGIN
BEGIN
RETURN 1
END
ELSE
RETURN 0
END
PRINT @rv
Otra caracteristica muy interesante de los procedimientos almacenados en Transact SQL es que pueden
devolver uno o varios conjuntos de resultados.
AS
BEGIN
SELECT @numCuenta,
SALDO_ANTERIOR,
SALDO_POSTERIOR,
IMPORTE,
FXMOVIMIENTO
FROM MOVIMIENTOS
END
Funciones escalares.
Funciones en línea.
Funciones en línea de multiples sentencias
Funciones escalares
Las funciones escalares devuelven un único valor de cualquier tipo de los datos tal como int,
money, varchar, real, etc.
-- Lista de parámetros
)
-- Tipo de datos que devuelve la función.
AS
BEGIN
...
END
@NumCuenta VARCHAR(20),
@Multiplicador DECIMAL(10,2)
RETURNS DECIMAL(10,2)
AS
BEGIN
@Return DECIMAL(10,2)
FROM CUENTAS
RETURN @Return
END
Pueden ser utilizadas en cualquier sentencia Transact SQL. Un aspecto a tener en cuenta, es que
para utilizar una función escalar debemos identificar el nombre de la función con el propietario de
la misma.
El siguiente ejemplo muestra como utilizar la función anteriormente creada en una sentencia
Transact SQL. Un aspecto muy a tener en cuenta es que la función ejecutará sus sentencias
SELECT una vez por cada fila del conjunto de resultados devuelto por la consulta SELECT principal.
SELECT IDCUENTA,
NUMCUENTA,
SALDO,
FXALTA,
-- Ejecucion de la funcion:
FROM CUENTAS
El siguiente ejemplo muestra como utilizar una función escalar en un script Transact SQL.
@Resultado DECIMAL(10,2)
PRINT @Resultado
Las funciones escalares son muy similares a procedimientos almacenados con parámetros de salida, pero
estas pueden ser utilizadas en consultas de seleccion y en la clausula where de las mismas.
Funciones en linea
Las funciones en linea son las funciones que devuelven un conjunto de resultados correspondientes a la
eecución de una sentencia SELECT.
-- Lista de parámetros
RETURNS TABLE
AS
RETURN
@NumCuenta VARCHAR(20)
RETURNS TABLE
AS
RETURN
SELECT MOVIMIENTOS.*
FROM MOVIMIENTOS
)
No podemos utilizar la clausula ORDER BY en la sentencia de una función el línea.
Las funciones en linea pueden utilizarse dentro de joins o querys como si fueran una tabla normal.
SELECT *
FROM CUENTAS
Las funciones en línea de multiples sentencias son similares a las funciones en línea excepto que el
conjunto de resultados que devuelven puede estar compuesto por la ejecución de varios consultas SELECT.
Este tipo de función se usa en situaciones donde se requiere una mayor lógica de proceso.
-- Lista de parámetros
RETURNS
AS
BEGIN
RETURN
END
* de estas cuentas
*/
NumCuenta varchar(20),
Saldo decimal(10,2),
Saldo_anterior decimal(10,2),
Saldo_posterior decimal(10,2),
Importe_Movimiento decimal(10,2),
FxMovimiento datetime
AS
BEGIN
@numcuenta varchar(20),
@saldo decimal(10,2)
FROM CUENTAS
OPEN CDATOS
-- Recorremos el cursor
WHILE (@@FETCH_STATUS = 0)
BEGIN
(NumCuenta, Saldo)
VALUES
(@numcuenta, @saldo)
(Saldo_anterior, Saldo_posterior,
Importe_Movimiento, FxMovimiento )
SELECT TOP 3
SALDO_ANTERIOR, SALDO_POSTERIOR,
IMPORTE, FXMOVIMIENTO
FROM MOVIMIENTOS
END
CLOSE CDATOS;
DEALLOCATE CDATOS;
RETURN
END
Cast y Convert
Convierten una expresión de un tipo de datos en otro de forma explícita. CAST y CONVERTproporcionan
funciones similares.
Donde:
SELECT @fecha
@fechaFormateada varchar(20)
-- Convertimos ahora una fecha a varchar y la formateamos
-- 3 => dd/mm/aa
SELECT @fechaFormateada
@dato2 int
SELECT @dato2
Isnull
Evalua una expresion de entrado y si esta es NULL, reemplaza NULL con el valor de reemplazo especificado.
El valor de reemplazo debe ser del mismo tipo de datos que la expresion a evaluar.
@datoVarchar varchar(100)
COALESCE
Devuelve la primera expresión distinta de NULL entre sus argumentos. Un aspecto a tener en cuenta es que
todos los argumentos deben ser del mismo tipo.
@dato3 int,
@dato4 int,
@dato5 int
-- Devuelve 100
SELECT COALESCE(@dato1,@dato2,@dato3,@dato4,@dato5)
GetDate y GetUTCDate
GetDate devuelve la fecha y hora actuales del sistema en el formato interno estándar de SQL Server 2005
para los valores datetime.
GetUTCDate devuelve el valor datetime que representa la hora UTC (hora universal coordinada u hora
del meridiano de Greenwich) actual.
@fechaUTC datetime
Trigger DML, se ejecutan cuando un usuario intenta modificar datos mediante un evento de lenguaje de
manipulación de datos (DML). Los eventos DML son instrucciones INSERT, UPDATE o DELETE de una tabla o
vista.
Trigger DDL, se ejecutan en respuesta a una variedad de eventos de lenguaje de definición de datos (DDL).
Estos eventos corresponden principalmente a instrucciones CREATE, ALTER y DROP de Transact-SQL, y a
determinados procedimientos almacenados del sistema que ejecutan operaciones de tipo DDL.
Trigger DML.
Los trigger DML se ejecutan cuando un usuario intenta modificar datos mediante un evento de lenguaje de
manipulación de datos (DML). Los eventos DML son instrucciones INSERT, UPDATE o DELETE de una tabla o
vista.
AS
BEGIN
END
La primera tabla (inserted) solo está disponible en las operaciones INSERT y UPDATE y en ella están los
valores resultantes despues de la inserción o actualización. Es decir, los datos insertados. Inserted estará
vacia en una operación DELETE.
En la segunda (deleted), disponible en las operaciones UPDATE y DELETE, están los valores anteriores a la
ejecución de la actualización o borrado. Es decir, los datos que serán borrados. Deleted estará vacia en una
operacion INSERT.
¿No existe una tabla UPDATED? No, hacer una actualización es lo mismo que borrar (deleted) e insertar
los nuevos (inserted). La sentencia UPDATE es la única en la que inserted y deleted tienen datos
simultaneamente.
El siguiente ejemplo, graba un historico de saldos cada vez que se modifica un saldo de la tabla cuentas.
ON CUENTAS
AFTER UPDATE
AS
BEGIN
FROM INSERTED
END
WHERE IDCUENTA = 1
Una consideración a tener en cuenta es que el trigger se ejecutará aunque la instruccion DML (UPDATE,
INSERT o DELETE ) no haya afectado a ninguna fila. En este caso inserted y deleted devolveran un conjunto
de datos vacio.
ON CUENTAS
AFTER UPDATE
AS
BEGIN
BEGIN
FROM INSERTED
END
END
Los trigger están dentro de la transacción original (Insert, Delete o Update) por lo cual si dentro de nuestro
trigger hacemos un RollBack Tran, no solo estaremos echando atrás nuestro trigger sino también toda la
transacción; en otras palabras si en un trigger ponemos un RollBack Tran, la transacción de Insert, Delete o
Update volverá toda hacia atrás.
ON CUENTAS
AFTER UPDATE
AS
BEGIN
FROM INSERTED
ROLLBACK
END
GO
-- activa el trigger TR_CUENTAS
GO
GO
Trigger DDL
Los trigger DDL se ejecutan en respuesta a una variedad de eventos de lenguaje de definición de datos
(DDL). Estos eventos corresponden principalmente a instrucciones CREATE, ALTER y DROP de Transact-SQL, y
a determinados procedimientos almacenados del sistema que ejecutan operaciones de tipo DDL.
ON DATABASE
AS
BEGIN
...
END
La siguiente instrucción impide que se ejecuten sentencias DROP TABLE y ALTER TABLE en la base de
datos.
BEGIN
ROLLBACK TRANSACTION
END
FOR
<sentencia_sql>
OPEN <nombre_cursor>
BEGIN
...
-- Cierra el cursor
CLOSE <nombre_cursor>
DEALLOCATE <nombre_cursor>
@Nombre varchar(255),
@Apellido1 varchar(255),
@Apellido2 varchar(255),
@NifCif varchar(20),
@FxNacimiento datetime
FROM CLIENTES
OPEN cClientes
WHILE (@@FETCH_STATUS = 0 )
BEGIN
END
CLOSE cClientes
DEALLOCATE cClientes
Cuando trabajamos con cursores, la funcion @@FETCH_STATUS nos indica el estado de la última
instrucción FETCH emitida, los valores posibles son:
Valor
Descripción
devuelto
0 La instrucción FETCH se ejecutó correctamente.
La instrucción FETCH no se ejecutó correctamente o la fila estaba más allá del conjunto
-1
de resultados.
-2 Falta la fila recuperada.
En la apertura del cursor, podemos especificar los siguientes parámetros:
[ LOCAL | GLOBAL ]
[ FORWARD_ONLY | SCROLL ]
[ TYPE_WARNING ]
FOR <sentencia_sql>
LOCAL
Especifica que el ámbito del cursor es local para el proceso por lotes, procedimiento
almacenado o desencadenador en que se creó el cursor.
FROM CLIENTES
GLOBAL
Especifica que el ámbito del cursor es global para la conexión. Puede hacerse referencia al
nombre del cursor en cualquier procedimiento almacenado o proceso por lotes que se
ejecute en la conexión.
FROM CLIENTES
Si no se especifica GLOBAL ni LOCAL, el valor predeterminado se controla mediante la configuración de la
opción de base de datos default to local cursor.
FORWARD_ONLY
Especifica que el cursor sólo se puede desplazar de la primera a la última fila. FETCH
NEXT es la única opción de recuperación admitida.
FROM CLIENTES
SCROLL
Especifica que están disponibles todas las opciones de recuperación (FIRST, LAST, PRIOR,
NEXT, RELATIVE, ABSOLUTE). Si no se especifica SCROLL en una instrucción DECLARE
CURSOR la única opción de recuperación que se admite es NEXT. No es posible especificar
SCROLL si se incluye también FAST_FORWARD.
Si se incluye la opción SCROLL, la forma en la realizamos la lectura del cursor varia,
debiendo utilizar la siguiente sintaxis: FETCH [ NEXT | PRIOR | FIRST | LAST | RELATIVE |
ABSOLUTE ] FROM < INTO
@Nombre varchar(255),
@Apellido1 varchar(255),
@Apellido2 varchar(255),
@NifCif varchar(20),
@FxNacimiento datetime
-- Declaración del cursor
FROM CLIENTES
OPEN cClientes
WHILE (@@FETCH_STATUS = 0 )
BEGIN
INTO @id,@Nombre,@Apellido1,@Apellido2,@NifCif,@FxNacimiento
END
CLOSE cClientes
-- Liberar los recursos
DEALLOCATE cClientes
STATIC
Define un cursor que hace una copia temporal de los datos que va a utilizar. Todas las
solicitudes que se realizan al cursor se responden desde esta tabla temporal de tempdb;
por tanto, las modificaciones realizadas en las tablas base no se reflejan en los datos
devueltos por las operaciones de recuperación realizadas en el cursor y además este
cursor no admite modificaciones.
FROM CLIENTES
KEYSET
Especifica que la pertenencia y el orden de las filas del cursor se fijan cuando se abre el
cursor. El conjunto de claves que identifica las filas de forma única está integrado en la
tabla denominada keyset de tempdb.
FROM CLIENTES
DYNAMIC
Define un cursor que, al desplazarse por él, refleja en su conjunto de resultados todos los
cambios realizados en los datos de las filas. Los valores de los datos, el orden y la
pertenencia de las filas pueden cambiar en cada operación de recuperación. La opción de
recuperación ABSOLUTE no se puede utilizar en los cursores dinámicos.
DECLARE cClientes CURSOR DYNAMIC FOR
FROM CLIENTES
FAST_FORWARD
Especifica un cursor FORWARD_ONLY, READ_ONLY con las optimizaciones de rendimiento
habilitadas. No se puede especificar FAST_FORWARD si se especifica también SCROLL o
FOR_UPDATE.
FROM CLIENTES
En SQL Server 2000, las opciones de cursor FAST_FORWARD y FORWARD_ONLY se excluyen mutuamente.
Si se especifican ambas, se genera un error. En SQL Server 2005, las dos palabras clave se pueden utilizar en
la misma instrucción DECLARE CURSOR.
READ_ONLY
Evita que se efectúen actualizaciones a través de este cursor. No es posible hacer
referencia al cursor en una cláusula WHERE CURRENT OF de una instrucción UPDATE o
DELETE. Esta opción reemplaza la capacidad de actualizar el cursor.
FROM CLIENTES
SCROLL_LOCKS
Especifica que se garantiza que las actualizaciones o eliminaciones posicionadas realizadas
a través del cursor serán correctas. Microsoft SQL Server bloquea las filas cuando se leen
en el cursor para garantizar que estarán disponibles para futuras modificaciones. No es
posible especificar SCROLL_LOCKS si se especifica también FAST_FORWARD o STATIC.
FROM CLIENTES
OPTIMISTIC
Especifica que las actualizaciones o eliminaciones posicionadas realizadas a través del
cursor no se realizarán correctamente si la fila se ha actualizado después de ser leída en el
cursor. SQL Server no bloquea las filas al leerlas en el cursor. En su lugar, utiliza
comparaciones de valores de columna timestamp o un valor de suma de comprobación si
la tabla no tiene columnas timestamp, para determinar si la fila se ha modificado después
de leerla en el cursor. Si la fila se ha modificado, el intento de actualización o eliminación
posicionada genera un error. No es posible especificar OPTIMISTIC si se especifica
también FAST_FORWARD.
FROM CLIENTES
TYPE_WARNING
Especifica que se envía un mensaje de advertencia al cliente si el cursor se convierte
implícitamente del tipo solicitado a otro.
FROM CLIENTES
Podemos especificar multiples parámetros en la apertura de cursor, pero unicamente un parámetro de cada
grupo. Por ejemplo:
FROM CLIENTES
Para actualizar los datos de un cursor debemos especificar FOR UPDATE despues de la sentencia SELECT en
la declaración del cursor, y WHERE CURRENT OF <nombre_cursor> en la sentencia UPDATE tal y
como muestra el siguiente ejemplo.
@Nombre varchar(255),
@Apellido1 varchar(255),
@Apellido2 varchar(255),
@NifCif varchar(20),
@FxNacimiento datetime
FROM CLIENTES
FOR UPDATE
OPEN cClientes
FETCH cClientes
INTO @id, @Nombre, @Apellido1, @Apellido2, @NifCif, @FxNacimiento
WHILE (@@FETCH_STATUS = 0 )
BEGIN
UPDATE Clientes
FETCH cClientes
INTO @id, @Nombre, @Apellido1, @Apellido2,
@NifCif, @FxNacimiento
END
CLOSE cClientes
DEALLOCATE cClientes
Desde aquí recomendamos la utilización de sp_executesql si bien vamos a mostrar la forma de trabajar
con ambos métodos.
La instrucción EXECUTE
La instrucción EXECUTE - o simplemente EXEC - permite ejecutar una cadena de caracteres que representa
una sentencia SQL. La cadena de caracteres debe ser de tipo nvarchar .
El siguiente ejemplo muestra como ejecutar una cadena de caracteres con la instrucción EXEC.
COD_PAIS,
NOMBRE_PAIS,
ACTIVO,
FX_ALTA
FROM
PAISES'
EXEC (@sql)
También con SQL dinamico podemos ejecutar sentencias de tipo DDL (Data Definition Languaje), como
CREATE TABLE.
EXEC (@sql)
EXEC (@sql)
El principal incoveniente de trabajar con la instrucción EXEC es que no permite el uso de parametros
abriendo la puerta a potenciales ataques de Sql Injections -
http://www.devjoker.com/contenidos/Articulos/45/Seguridad-en-Internet--SQL-Injections.aspx
Para solventar el problema debemos trabajar siempre con sq_executesql, que permite el uso de
parametros y con el que obtendremos un mejor rendimiento de nuestras consultas.
Para ejecutar sql dinamico, se recomienda utilizar el procedimiento almacenado sp_executesql, en lugar
de una instrucción EXECUTE.
COD_PAIS,
NOMBRE_PAIS,
ACTIVO,
FX_ALTA
FROM
PAISES'
@paramDefinition nvarchar(255),
@paramValue char(3)
COD_PAIS,
NOMBRE_PAIS,
ACTIVO,
FX_ALTA
FROM
PAISES