Documenti di Didattica
Documenti di Professioni
Documenti di Cultura
SQL es un lenguaje de consulta para los sistemas de bases de datos relacinales, pero que no posee la potencia de los lenguajes de programacin. Para abordar el presente tutorial con mnimo de garantias es necesario conocer previamente SQL.
Podemos acceder a un completo tutorial de SQL desde AQUI.
Transact SQL es el lenguaje de programacin que proporciona SQL Server para ampliar SQL con los elementos caracteristicos de los lenguajes de programacin: variables, sentencias de control de flujo, bucles ... Cuando se desea realizar una aplicacin 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 programacin tradicionales. Transact SQL es el lenguaje de programacin que proporcionaSQL Server para extender el SQL estndar 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 versin SQL Server 2005.
Pero adems Transact SQL nos permite realizar programas sobre las siguientes herramientas de SQL Server:
y
Service Broker
o o y y
Transact SQL no es CASE-SENSITIVE, es decir, no diferencia maysculas de minsculas como otros lenguajes de programacin como C o Java. Un comentario es una aclaracin que el programador incluye en el cdigo. Son soportados 2 estilos de comentarios, el de lnea simple y de multilnea, para lo cual son empleados ciertos caracters especiales como son: -- Para un comentario de linea simple /* ... */ Para un comentario de varias lineas Un literal es un valor fijo de tipo numrico, caracter, cadena o lgico no representado por un identificador (es un valor explcito). 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.
Veamos algunos ejemplos:
-- Esto es un comentario de linea simple /* Este es un comentario con varias lneas. 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 maysculas ni minsculas
Scripts y lotes.
Un script de Transact SQL es un conjunto de sentencias de Transact SQL en formato de texto plano que se ejecutan en un servidor de SQL Server. 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 travs de las instruccin GO.
-- Este es el primer lote del script SELECT * FROM COMENTARIOS GO -- GO es el separador de lotes -- Este es el segundo lote del script SELECT getdate() -- getdate() es una funcin integrada que devuelve -- la fecha
En ocasiones es necesario separar las sentencias en varios lotes, porque Transact SQL no permite la ejecucin de ciertos comandos en el mismo lote, si bien normalmente tambin se utilizan los lotes para realizar separaciones lgicas dentro del script.
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 mxmo de precisin. La precisin puede variar entre 1 y 53. Real. Sinnimo de float(24). Puede almacenar el rango de valores -3,4x-1038 a 3,4x-1038, Money. Almacena valores nmericos monetarios de -263 a 263-1, con una precisin de hasta diexz milesimas de la unidad monetaria. SmallMoney. Almacena valores nmericos monetarios de -214.748,3647 a 214.748,3647, con una precisin de hasta diez milesimas de la unidad monetaria. Todos los tipos de datos enteros pueden marcarse con la propiedad identity para hacerlos autonumricos.
DECLARE @bit bit, @tinyint tinyint, @smallint smallint, @int int, @bigint bigint, @decimal decimal(10,3), -- 10 digitos, 7 enteros y -- 3 decimales @real real, @double float(53), @money money set @bit = 1 print @bit set @tinyint = 255 print @tinyint set @smallint = 32767 print @smallint set @int = 642325 print @int set @decimal = 56565.234 -- Punto como separador decimal print @decimal set @money = 12.34 print @money
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.
DECLARE @myxml XML set @myxml = (SELECT @@SERVERNAME NOMBRE FOR XML RAW, TYPE) print cast(@myxml as varchar(max))
<row nombre="SVR01"/>
Obtendremos la siguiente salida: 46141D79-102C-4C29-A620-792EA0208637 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.
CREATE TYPE MD5 FROM CHAR(32) NULL GO DECLARE @miMD5 MD5 set @miMD5 = '0000000000000000000000000000000A' print @miMD5
-- Esto es un comentario de linea simple /* Este es un comentario con varias lneas. 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 maysculas ni minsculas
A travs de la instrunccin set. Utilizando una sentencia SELECT. Realizando un FETCH de un cursor.
El siguiente ejemplo muestra como asignar una variable utilizando la instruccin SET.
El siguiente ejemplo muestra como asignar variables utilizando una sentencia SELECT.
Un punto a tener en cuenta cuando asignamos variables de este modo, es que si la consulta SELECT devuelve ms de un registro, las variables quedarn asignadas con los valores de la ltima fila devuelta. Por litmo veamos como asignar variables a travs de un cursor.
FOR
SELECT nombre , Apellido1, Apellido2 FROM CLIENTES
WHILE (@@FETCH_STATUS = 0)
BEGIN
PRINT @nombre PRINT @apellido1 PRINT @apellido2 FETCH CDATOS INTO @nombre, @apellido1, @apellido2
END
= + (suma) - (resta) * (multiplicacin) / (divisin) ** (exponente) % (modulo) = (igual a) <> (distinto de) != (distinto de) < (menor que) > (mayor que) >= (mayor o igual a) <= (menor o igual a) !> (no mayor a) !< (no menor a)
AND (y lgico) NOT (negacion) OR (o lgico) & (AND a nivel de bit) | (OR a nivel de bit) ^ (OR exclusivo a nivel de bit) +
Operadores lgicos
Operador de concatenacin
ALL (Devuelve
Otros
TRUE) ANY(Devuelve TRUE si cualquier elemento del conjunto de comparaciones es TRUE) BETWEEN (Devuelve TRUE si el operando est dentro del intervalo) 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)
IF (<expresion>) BEGIN ... END ELSE IF (<expresion>) BEGIN ... END ELSE BEGIN ... END
DECLARE @Web varchar(100), @diminutivo varchar(3) SET @diminutivo = 'DJK' @diminutivo = 'DJK' BEGIN PRINT 'www.devjoker.com' END ELSE BEGIN PRINT 'Otra Web (peor!)' END IF
DECLARE @coPais int, @descripcion varchar(255) set @coPais = 5 set @descripcion = 'Espaa' IF EXISTS(SELECT * FROM PAISES WHERE CO_PAIS = @coPais) BEGIN UPDATE PAISES SET DESCRIPCION = @descripcion WHERE CO_PAIS = @coPais END ELSE BEGIN INSERT INTO PAISES (CO_PAIS, DESCRIPCION) VALUES (@coPais, @descripcion) END
CASE <expresion> WHEN <valor_expresion> THEN <valor_devuelto> WHEN <valor_expresion> THEN <valor_devuelto> ELSE <valor_devuelto> -- Valor por defecto END
Ejemplo de CASE.
DECLARE @Web varchar(100), @diminutivo varchar(3) SET @diminutivo = 'DJK' SET @Web = (CASE @diminutivo WHEN 'DJK' THEN 'www.devjoker.com' WHEN 'ALM' THEN 'www.aleamedia.com' ELSE 'www.devjoker.com' END) PRINT @Web
CASE WHEN <expresion> = <valor_expresion> THEN <valor_devuelto> WHEN <expresion> = <valor_expresion> THEN <valor_devuelto> ELSE <valor_devuelto> -- Valor por defecto END
DECLARE @Web varchar(100), @diminutivo varchar(3) SET @diminutivo = 'DJK' SET @Web = (CASE WHEN @diminutivo = 'DJK' THEN 'www.devjoker.com' WHEN @diminutivo = 'ALM' THEN 'www.aleamedia.com' ELSE 'www.devjoker.com' END) PRINT @Web
DECLARE @Web varchar(100), @diminutivo varchar(3) SET @diminutivo = 'DJK' SET @Web = (CASE WHEN @diminutivo = 'DJK' THEN (SELECT web FROM WEBS WHERE id=1) WHEN @diminutivo = 'ALM' THEN (SELECT web FROM WEBS WHERE id=2) ELSE 'www.devjoker.com' END) PRINT @Web
Bucle WHILE
El bucle WHILE se repite mientras expresion se evalue como verdadero. Es el nico tipo de bucle del que dispone Transact SQL.
DECLARE @contador int SET @contador = 0 WHILE (@contador < 100) BEGIN SET @contador = @contador + 1 PRINT 'Iteracion del bucle ' + cast(@contador AS varchar) END
DECLARE @contador int SET @contador = 0 WHILE (@contador < 100) BEGIN SET @contador = @contador + 1 IF (@contador % 2 = 0) CONTINUE PRINT 'Iteracion del bucle ' + cast(@contador AS varchar) END
DECLARE @contador int SET @contador = 0 WHILE (1 = 1) BEGIN SET @contador = @contador + 1 IF (@contador % 50 = 0) BREAK PRINT 'Iteracion del bucle ' + cast(@contador AS varchar) END
DECLARE @coRecibo int WHILE EXISTS (SELECT * FROM RECIBOS WHERE PENDIENTE = 'S')-- Ojo, la subconsulta se ejecuta -- una vez por cada iteracion -- del bucle! BEGIN SET @coRecibo = (SELECT TOP 1 CO_RECIBO FROM RECIBOS WHERE PENDIENTE = 'S') UPDATE RECIBOS SET PENDIENTE = 'N'
Estructura GOTO
La sentencia goto nos permite desviar el flujo de ejecucin 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.
DECLARE @divisor int, @dividendo int, @resultado int SET @dividendo = 100 SET @divisor = 0 SET @resultado = @dividendo/@divisor IF @@ERROR > 0 GOTO error PRINT 'No hay error' RETURN error: PRINT 'Se ha producido una division por cero'
BEGIN TRY ... END TRY BEGIN CATCH ... END CATCH
BEGIN TRY DECLARE @divisor int , @dividendo int, @resultado int SET @dividendo = 100 SET @divisor = 0 -- Esta linea provoca un error de division por 0 SET @resultado = @dividendo/@divisor PRINT 'No hay error' END TRY BEGIN CATCH PRINT 'Se ha producido un error' END CATCH
ERROR_NUMBER(), devuelve el nmero de error. ERROR_SEVERITY(), devuelve la severidad del error. ERROR_STATE(), devuelve el estado del error. ERROR_PROCEDURE(), devuelve el nombre del procedimiento almacenado que ha provocado el error. ERROR_LINE(), devuelve el nmero de lnea en el que se ha producido el error. ERROR_MESSAGE(), devuelve el mensaje de error. Son extremadamente tiles para realizar una auditora de errores.
BEGIN TRY DECLARE @divisor int , @dividendo int, @resultado int SET @dividendo = 100
SET @divisor = 0 -- Esta linea provoca un error de division por 0 SET @resultado = @dividendo/@divisor PRINT 'No hay error' END TRY BEGIN CATCH PRINT ERROR_NUMBER() PRINT ERROR_SEVERITY() PRINT ERROR_STATE() PRINT ERROR_PROCEDURE() PRINT ERROR_LINE() PRINT ERROR_MESSAGE() END CATCH
Lgicamente, podemos utilizar estas funciones para almacenar esta informacin en una tabla de la base de datos y registrar todos los errores que se produzcan.
DECLARE @divisor int , @dividendo int , @resultado int SET @dividendo = 100 SET @divisor = 0 -- Esta linea provoca un error de division por 0 SET @resultado = @dividendo/@divisor 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 ms habituales es sin duda, incluir una nueva sentencia Transact SQL entre la lnea que provoco el error y la que lo controla. Esa nueva instruccin restaura el valor de @@ERROR y no controlaremos el error. El siguiente ejemplo ilustra esta situacin:
DECLARE @divisor int , @dividendo int , @resultado int SET @dividendo = 100 SET @divisor = 0 -- Esta linea provoca un error de division por 0 SET @resultado = @dividendo/@divisor PRINT 'Controlando el error ...' -- Esta linea estable @@ERROR a cero IF @@ERROR = 0 BEGIN -- Se ejecuta esta parte! PRINT 'No hay error' END ELSE BEGIN PRINT 'Hay error' END
DECLARE @tipo int, @clasificacion int 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 funcin RAISERROR recibe tres parmetros, el mensaje del error (o cdigo 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 funcin de SQL Server sysadmin. El estado es un valor para permitir que el programador identifique el mismo error desde diferentes partes del cdigo. Admite valores entre 1 y 127, permite tratar .
SELECT [ALL | DISTINCT ][ TOP expression [ PERCENT ] [ WITH TIES ] ] <nombre_campos> FROM <nombre_tabla> [ INNER | LEFT [OUTER]| RIGHT [OUTER] | CROSS] [JOIN ] <nombre_tabla> ON <condicion_join>[ AND|OR <condicion>] [WHERE <condicion> [ AND|OR <condicion>]] [GROUP BY <nombre_campos>] [HAVING <condicion>[ AND|OR <condicion>]] [ORDER BY <nombre_campo> [ASC | DESC] El siguiente ejemplo muestra una consulta sencilla que obtiene el cdigo y la "familia" de una tabla llamada familias (representara familias de productos por ejemplo).
El uso del asterisco indica que queremos que la consulta devuelva todos los campos que existen en la tabla.
Ahora vamos a realizar una consulta obteniendo adems de los datos de familias, los datos de las categorias y los productos.
SELECT *
FROM FAMILIAS INNER JOIN CATEGORIAS ON CATEGORIAS.CO_FAMILIA = FAMILIAS.CO_FAMILIA INNER JOIN PRODUCTOS ON PRODUCTOS.CO_CATEGORIA = CATEGORIAS.CO_CATEGORIA
La combinacin se realiza a travs 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 LEFT OUTER JOIN CATEGORIAS ON CATEGORIAS.CO_FAMILIA = FAMILIAS.CO_FAMILIA LEFT OUTER JOIN PRODUCTOS 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. Tambin podemos forzar un producto cartesiano (todos con todos) a travs de CROSS JOIN.
La clusula WHERE
La clusula WHERE es la instruccin que nos permite filtrar el resultado de una sentencia SELECT.
La clausula WHERE se puede utilizar conjuntamente con INNER JOIN, LEFT JOIN ...
SELECT FAMILIAS.CO_FAMILIA, FAMILIAS.FAMILIA FROM FAMILIAS INNER JOIN CATEGORIAS ON CATEGORIAS.CO_FAMILIA = FAMILIAS.CO_FAMILIA WHERE FAMILIAS.CO_FAMILIA > 1
Siempre que incluyamos un valor alfanumerico para un campo en la condicin WHERE este debe ir entre comillas simples:
Para consultar campos alfanumericos, es decir, campos de texto podemos utilizar el operador LIKEconjuntamente con comodines.
% , representa cualquier cadena de texto de cero o ms caracteres de cualquier longitud. _ , representa un caracter. [a-d], representa cualquier caracter del intervalo a-d. [abcd], representa cualquier caracter del grupo abcd. [^a-d], representa cualquier caracter diferente del intervalo a-d. [^abcd], representa cualquier caracter distinto del grupo abcd.
Tambin podemos obtener los valores distintos utilizando DISTINCT.
SELECT DISTINCT FAMILIA -- Devuelve los distintos valores de FAMILIA FROM FAMILIAS
Podemos limitar el nmero de registros que devuelve la consulta a travs de la clausula TOP. La clausulaTOP admite como parmetros un valor numrico entero o un porcentaje (slo a partir de la version 2005)
SELECT TOP 10 * -- Devuelve 10 registros FROM FAMILIAS SELECT TOP 50 PERCENT * -- Devuelve el 50% de los registros
FROM FAMILIAS
La clusula ORDER BY
Podemos especificar el orden en el que sern devueltos los datos a travs de la clusula ORDER BY.
Tambin podemos indicar el ndice del campo en la lista de seleccin en lugar de su nombre :
SELECT CO_FAMILIA, FAMILIA FROM FAMILIAS ORDER BY 2 DESC -- Ordena por FAMILIA
Consultas agregadas
La clusula GROUP BY
La clausula GROUP BY combina los registros devueltos por una consulta SELECT obteniendo uno o varios valores agregados(suma, valor mnimo y mximo ...). Para cada registro se puede crear un valor agregado si se incluye una funcin SQL agregada, como por ejemplo Sum o Count, en la instruccin 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 funcin SQL agregada en la instruccin 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 evalan en ninguna de las funciones SQL agregadas. Todos los campos de la lista de campos de SELECT deben incluirse en la clusula GROUP BY o como argumentos de una funcin SQL agregada. El siguiente ejemplo realiza una "cuenta" de los datos que hay en la tabla 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, SUM(PRECIO) -- Total del pedido FROM DETALLE_PEDIDO INNER JOIN PEDIDOS ON DETALLE_PEDIDO.CO_PEDIDO = PEDIDOS.CO_PEDIDO INNER JOIN CLIENTES ON PEDIDOS.CO_CLIENTE = CLIENTES.CO_CLIENTE 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, SUM(PRECIO) -- Total del pedido FROM DETALLE_PEDIDO INNER JOIN PEDIDOS ON DETALLE_PEDIDO.CO_PEDIDO = PEDIDOS.CO_PEDIDO INNER JOIN CLIENTES ON PEDIDOS.CO_CLIENTE = CLIENTES.CO_CLIENTE
La clusula HAVING
Es posible que necesitemos calcular un agregado, pero que no necesitemos obtener todos los datos, solo los que cumplan una condicin 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 ms 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 clusula GROUP BY que satisfaga las condiciones de la clusula HAVING. Se utiliza la clusula WHEREpara excluir aquellas filas que no desea agrupar, y la clusula 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.
CLIENTES.APELLIDO2, SUM(PRECIO) -- Total del pedido FROM DETALLE_PEDIDO INNER JOIN PEDIDOS ON DETALLE_PEDIDO.CO_PEDIDO = PEDIDOS.CO_PEDIDO INNER JOIN CLIENTES ON PEDIDOS.CO_CLIENTE = CLIENTES.CO_CLIENTE
Funciones agregadas.
Transact SQL pone a nuestra disposicin multiples funciones agregadas, las ms comunes son:
y y y y y
AVG
Calcula la media aritmtica de un conjunto de valores contenidos en un campo especificado de una consulta. Su sintaxis es la siguiente
AVG(<expr>)
En donde expr representa el campo que contiene los datos numricos para los que se desea calcular la media o una expresin que realiza un clculo utilizando los datos de dicho campo. La media
calculada por Avg es la media aritmtica (la suma de los valores dividido por el nmero de valores). La funcin Avg no incluye ningn campo Null en el clculo.
SELECT CLIENTES.NOMBRE, CLIENTES.APELLIDO1, CLIENTES.APELLIDO2, AVG(PRECIO) -- Promedio del pedido FROM DETALLE_PEDIDO INNER JOIN PEDIDOS ON DETALLE_PEDIDO.CO_PEDIDO = PEDIDOS.CO_PEDIDO INNER JOIN CLIENTES ON PEDIDOS.CO_CLIENTE = CLIENTES.CO_CLIENTE GROUP BY CLIENTES.NOMBRE, CLIENTES.APELLIDO1, CLIENTES.APELLIDO2
Count
Calcula el nmero de registros devueltos por una consulta. Su sintaxis es la siguiente:
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 funcin (la cual puede ser intrnseca 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 clculo sobre un campo, Count simplemente cuenta el nmero de registros sin tener en cuenta qu valores se almacenan en los registros. La funcin Count no cuenta los registros que tienen campos null a menos que expr sea el carcter comodn asterisco (*). Si utiliza un asterisco, Count calcula el nmero total de registros, incluyendo aquellos que contienen campos null. Count(*) es considerablemente ms rpida que Count(Campo).
SELECT COUNT(*) FROM PEDIDOS SELECT CLIENTES.NOMBRE, COUNT(*) FROM PEDIDOS INNER JOIN CLIENTES ON PEDIDOS.CO_CLIENTE = CLIENTES.CO_CLIENTE GROUP BY CLIENTES.NOMBRE
Max, Min
Devuelven el mnimo o el mximo de un conjunto de valores contenidos en un campo especifico de una consulta. Su sintaxis es:
MIN(<expr>) MAX(<expr>)
En donde expr es el campo sobre el que se desea realizar el clculo. Expr pueden incluir el nombre de un campo de una tabla, una constante o una funcin (la cual puede ser intrnseca 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 INNER JOIN CLIENTES 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 expresin que realiza un clculo utilizando los datos de dichos campos. Los operandos de expr pueden incluir el nombre de un campo de una tabla, una constante o una funcin (la cual puede ser intrnseca o definida por el usuario pero no otras de las funciones agregadas de SQL).
SELECT CLIENTES.NOMBRE, SUM(PEDIDOS.TOTAL_PEDIDO) FROM PEDIDOS INNER JOIN CLIENTES ON PEDIDOS.CO_CLIENTE = CLIENTES.CO_CLIENTE GROUP BY CLIENTES.NOMBRE
SELECT TOP 3
CLIENTES.NOMBRE, SUM(DETALLE_PEDIDO.PRECIO)
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 discriminara el cuarto registro. Para evitar este comportamiento, y que la consulta devuelva tambin al cuarto cliente utilizamos la clausulaWITH TIES.
SELECT TOP 3 WITH TIES CLIENTES.NOMBRE, SUM(DETALLE_PEDIDO.PRECIO) FROM DETALLE_PEDIDO INNER JOIN PEDIDOS ON DETALLE_PEDIDO.CO_PEDIDO = PEDIDOS.CO_PEDIDO INNER JOIN CLIENTES ON PEDIDOS.CO_CLIENTE = CLIENTES.CO_CLIENTE GROUP BY CLIENTES.NOMBRE ORDER BY 2 -- SUM(DETALLE_PEDIDO.PRECIO_UNIDAD)
UNION, disponible en todas las versiones de SQL Server. EXCEPT, nuevo en SQL Server 2005. INTERSECT, nuevo en SQL Server 2005. Para utilizar operaciones de conjuntos debemos cumplir una serie de normas.
y y
Las consultas a unir deben tener el mismo nmero campos, y adems los campos deben ser del mismo tipo. Slo puede haber una nica clausula ORDER BY al final de la sentencia SELECT.
UNION
UNION devuelve la suma de dos o ms conjuntos de resultados. El conjunto obtenido como resultado deUNION tiene la misma estructura que los conjuntos originales. El siguiente ejemplo muestra el uso de UNION
SELECT Nombre, Apellido1 , Apellido2, NifCif, FxNacimiento FROM EMPLEADOS UNION SELECT Nombre, Apellido1 , Apellido2, NifCif, FxNacimiento 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.
SELECT Nombre, Apellido1 , Apellido2, NifCif, FxNacimiento FROM EMPLEADOS UNION ALL SELECT Nombre, Apellido1 , Apellido2, NifCif, FxNacimiento FROM CLIENTES
EXCEPT
EXCEPT devuelve la diferencia (resta) de dos o ms conjuntos de resultados. El conjunto obtenido como resultado de EXCEPT tiene la misma estructura que los conjuntos originales. El siguiente ejemplo muestra el uso de EXCEPT
EXCEPT
SELECT Nombre, Apellido1 , Apellido2, NifCif, FxNacimiento FROM CLIENTES
El uso de EXCEPT, como norma general, es mucho ms rpido que utilizar condiciones NOT IN oEXISTS en la clausula WHERE.
INTERSECT
Devuelve la interseccin entre dos o ms conjuntos de resultados en uno. El conjunto obtenido como resultado de INTERSECT tiene la misma estructura que los conjuntos originales. El siguiente ejemplo muestra el uso de INTERSECT
INTERSECT
SELECT Nombre, Apellido1 , Apellido2, NifCif, FxNacimiento FROM CLIENTES
VALUES
(10, getdate(),getdate()+30, 1)
INSERT INTO PRECIOS (PRECIO, FX_INICIO, FX_FIN, CO_PRODUCTO) SELECT PRECIO_UNIDAD, getdate(),
En SQL Sever podemos marcar un campo de una tabla como autonumrico (identity), cuando insertamos un registro en dicha tabla el valor del campo se genera automaticamente. Para recuperar el valor generado disponemos de varios mtodos:
y
Utilizar la funcion @@identity, que devuelve el ltimo valor identidad insertado por la transaccion:
DECLARE @Codigo int
VALUES
(10, getdate(),getdate()+30, 1)
PRINT @Codigo
El uso de @@Identity no siempre es vlido, ya que al devolver el litmo valor identidad insertado por la transaccin, no nos garantiza que el valor haya sido insertado en la tabla que nos interesa (por ejemplo la tabla podra tener un trigger que insertara datos en otra tabla con campos identidad).
VALUES
(10, getdate(),getdate()+30, 1)
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 lgicas INSERTED yDELETED. Las columnas con prefijo DELETED reflejan el valor antes de que se complete la instruccin UPDATE oDELETE. Es decir, son una copia de los datos "antes" del cambio. DELETED no se puede utilizar con la clusula OUTPUT en la instruccin INSERT. Las columnas con prefijo INSERTED reflejan el valor despus de que se complete la instruccinUPDATE o INSERT, pero antes de que se ejecuten los desencadenadores. Es decir, son una copia de los datos "despues" del cambio. INSERTED no se puede utilizar con la clusula OUTPUT en la instruccin DELETE.
DECLARE @FILAS_INSERTADAS TABLE ( CO_PRECIO int, PRECIO decimal, FX_INICIO datetime, FX_FIN datetime,
CO_PRODUCTO int
)
INSERT INTO PRECIOS (PRECIO, FX_INICIO, FX_FIN, CO_PRODUCTO) OUTPUT INSERTED.* INTO @FILAS_INSERTADAS
VALUES
(10, getdate(),getdate()+30, 1)
UPDATE CLIENTES
SET
NOMBRE = 'Devjoker', APELLIDO1 = 'Herrarte',
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.
UPDATE CLIENTES
SET
NOMBRE = FICHERO_CLIENTES.NOMBRE, APELLIDO1 = FICHERO_CLIENTES.APELLIDO1, APELLIDO2 = FICHERO_CLIENTES.APELLIDO2 FROM CLIENTES INNER JOIN FICHERO_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 lgicas INSERTED yDELETED. Las columnas con prefijo DELETED reflejan el valor antes de que se complete la instruccin UPDATE oDELETE. Es decir, son una copia de los datos "antes" del cambio. DELETED no se puede utilizar con la clusula OUTPUT en la instruccin INSERT.
DECLARE @FILAS_ACTUALIZADAS TABLE ( CO_CLIENTE int , NOMBRE varchar(100), APELLIDO1 varchar(100), APELLIDO2 varchar(100) )
UPDATE CLIENTES
SET
NOMBRE = 'Devjoker', APELLIDO1 = 'Herrarte', APELLIDO2 = 'Snchez' OUTPUT DELETED.* INTO @FILAS_ACTUALIZADAS WHERE CO_CLIENTE IN (10, 11, 12)
Las columnas con prefijo INSERTED reflejan el valor despus de que se complete la instruccinUPDATE o INSERT, pero antes de que se ejecuten los desencadenadores. Es decir, son una copia de los datos "despues" del cambio. INSERTED no se puede utilizar con la clusula OUTPUT en la instruccin DELETE.
DECLARE @FILAS_ACTUALIZADAS TABLE ( CO_CLIENTE int , NOMBRE varchar(100), APELLIDO1 varchar(100), APELLIDO2 varchar(100) )
UPDATE CLIENTES
SET
NOMBRE = 'Devjoker', APELLIDO1 = 'Herrarte', APELLIDO2 = 'Snchez' OUTPUT INSERTED.* INTO @FILAS_ACTUALIZADAS WHERE CO_CLIENTE IN (10, 11, 12)
(
Id int identity not null, dato varchar(100), fx_alta datetime, constraint PK_DATOS PRIMARY KEY (Id) )
GO
BEGIN
SET @i = @i +1 set @dato = 'Dato:' + cast(@i as varchar) INSERT INTO DATOS (dato, fx_alta) VALUES (@dato, getdate())
END
GO
Para borrar los registros de la tabla "DATOS" ejecutaremos la siguiente instruccin. Notese que no se especifica ninguna condicin WHERE por lo que se borran todos los datos de la tabla.
Lgicamente podemos especicar que registros queremos borrar a travs de la clausula WHERE.
DELETE
Cuando borramos datos de una tabla, podemos obtener el nmero de filas que han sido afectadas por la instruccin a travs de la variable @@RowCount. El siguiente ejemplo ilustra el uso de @@RowCount.
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 lgicas INSERTED yDELETED. Las columnas con prefijo DELETED reflejan el valor antes de que se complete la instruccin UPDATE oDELETE. Es decir, son una copia de los datos "antes" del cambio. DELETED no se puede utilizar con la clusula OUTPUT en la instruccin INSERT.
Truncate Table
Para borrar datos de forma masiva disponemos de la instruccin TRUNCATE TABLE, que borra todos los datos de una tabla.
Cuando trabajamos con TRUNCATE TABLE debemos tener en cuenta las siguientes consideraciones:
y y
TRUNCATE TABLE no admite la clausula WHERE. No podemos ejecutar TRUNCATE TABLE sobre tablas que sean "padres" en foreign keys.
/* Descontamos el importe de la cuenta origen */ UPDATE CUENTAS SET SALDO = SALDO - @importe WHERE NUMCUENTA = @CuentaOrigen
/* Registramos el movimiento */
INSERT INTO MOVIMIENTOS (IDCUENTA, SALDO_ANTERIOR, SALDO_POSTERIOR, IMPORTE, FXMOVIMIENTO) SELECT IDCUENTA, SALDO + @importe, SALDO, @importe, getdate() FROM CUENTAS WHERE NUMCUENTA = @CuentaOrigen
/* Registramos el movimiento */
INSERT INTO MOVIMIENTOS (IDCUENTA, SALDO_ANTERIOR, SALDO_POSTERIOR, IMPORTE, FXMOVIMIENTO) SELECT IDCUENTA, SALDO - @importe, SALDO, @importe, getdate() FROM CUENTAS WHERE NUMCUENTA = @CuentaDestino
Esta forma de actuar seria erronea, ya que cada instruccin se ejecutaria y confirmara de forma independiente, por lo que un error dejara los datos erroneos en la base de datos ( y ese es el peor error que nos podemos encontrar! )
Transacciones implicitas y explicitas
Para agrupar varias sentencias Transact SQL en una nica transaccin, disponemos de los siguientes mtodos:
y
Transacciones explcitas Cada transaccin se inicia explcitamente con la instruccin BEGIN TRANSACTION y se termina explcitamente con una instruccin COMMIT o ROLLBACK. Transacciones implcitas Se inicia automtivamente una nueva transaccin cuando se ejecuta una instruccin que realiza modificaciones en los datos, pero cada transaccin se completa explcitamente con una instruccinCOMMIT o ROLLBACK.
Para activar-desactivar el modo de transacciones implicitas debemos ejecutar la siguiente instruccin.
Cuando la opcin ANSI_DEFAULTS est establecida en ON, IMPLICIT_TRANSACTIONS tambin se establece en ON. El siguiente ejemplo muestra el script anterior haciendo uso de transacciones explicitas.
BEGIN TRANSACTION -- O solo BEGIN TRAN BEGIN TRY /* Descontamos el importe de la cuenta origen */ UPDATE CUENTAS SET SALDO = SALDO - @importe WHERE NUMCUENTA = @CuentaOrigen
/* Registramos el movimiento */
INSERT INTO MOVIMIENTOS (IDCUENTA, SALDO_ANTERIOR, SALDO_POSTERIOR, IMPORTE, FXMOVIMIENTO) SELECT IDCUENTA, SALDO + @importe, SALDO, @importe, getdate() FROM CUENTAS WHERE NUMCUENTA = @CuentaOrigen
/* Incrementamos el importe de la cuenta destino */ UPDATE CUENTAS SET SALDO = SALDO + @importe WHERE NUMCUENTA = @CuentaDestino
/* Registramos el movimiento */ INSERT INTO MOVIMIENTOS (IDCUENTA, SALDO_ANTERIOR, SALDO_POSTERIOR, IMPORTE, FXMOVIMIENTO) SELECT IDCUENTA, SALDO - @importe, SALDO, @importe, getdate() FROM CUENTAS WHERE NUMCUENTA = @CuentaDestino
END TRY
BEGIN CATCH /* Hay un error, deshacemos los cambios*/ ROLLBACK TRANSACTION -- O solo ROLLBACK PRINT 'Se ha producido un error!' END CATCH
SET IMPLICIT_TRANSACTIONS ON
/* Registramos el movimiento */ INSERT INTO MOVIMIENTOS (IDCUENTA, SALDO_ANTERIOR, SALDO_POSTERIOR, IMPORTE, FXMOVIMIENTO) SELECT IDCUENTA, SALDO + @importe, SALDO, @importe, getdate() FROM CUENTAS WHERE NUMCUENTA = @CuentaOrigen
/* Incrementamos el importe de la cuenta destino */ UPDATE CUENTAS SET SALDO = SALDO + @importe WHERE NUMCUENTA = @CuentaDestino
/* Registramos el movimiento */ INSERT INTO MOVIMIENTOS (IDCUENTA, SALDO_ANTERIOR, SALDO_POSTERIOR, IMPORTE, FXMOVIMIENTO) SELECT IDCUENTA, SALDO - @importe, SALDO, @importe, getdate() FROM CUENTAS WHERE NUMCUENTA = @CuentaDestino
/* Confirmamos la transaccion*/ COMMIT TRANSACTION -- O solo COMMIT END TRY BEGIN CATCH /* Hay un error, deshacemos los cambios*/ ROLLBACK TRANSACTION -- O solo ROLLBACK PRINT 'Se ha producido un error!' END CATCH
La transaccin sigue activa hasta que emita una instruccin COMMIT o ROLLBACK. Una vez que la primera transaccin se ha confirmado o revertido, se inicia automticamente una nueva transaccin la siguiente vez que la conexin ejecuta una instruccion para modificar datos. La conexin contina generando transacciones implcitas hasta que se desactiva el modo de transacciones implcitas. Podemos verificar el nmero de transacciones activas a travs de @@TRANCOUNT.
SET IMPLICIT_TRANSACTIONS ON BEGIN TRY UPDATE CUENTAS SET FXALTA = FXALTA - 1 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 ms sobre bloqueos y nivel de aislamiento en este articulo.
Transacciones anidadas.
Podemos anidar varias transacciones. Cuando anidamos varias transacciones la instruccin COMMIT afectar a la ltima transaccin abierta, pero ROLLBACK afectar a todas las transacciones abiertas. Un hecho a tener en cuenta, es que, si hacemos ROLLBACK de la transaccin superior se desharan tambin los cambios de todas las transacciones internas, aunque hayamos realizado COMMIT de ellas.
BEGIN TRAN
BEGIN TRAN
Una consideracin a tener en cuanta cuando trabajamos con transacciones anidadas es la posibilidad de utilizar puntos de guardado o SAVEPOINTs.
BEGIN TRAN
-- Confirmamos la transaccion
COMMIT
AS -- Sentencias del procedure Para modificar un procedimiento almacenado debemos emplear la sentencia ALTER PROCEDURE.
El siguiente ejemplo muestra un procedimiento almacenado, denominado spu_addCliente que inserta un registro en la tabla "CLIENTES".
@apellido2 varchar(100), @nifCif varchar(20), @fxNaciento datetime AS INSERT INTO CLIENTES (nombre, apellido1, apellido2, nifcif, fxnacimiento) VALUES (@nombre, @apellido1, @apellido2, @nifCif, @fxNaciento)
Para la ejecutar un procedimiento almacenado debemos utilizar la sentencia EXEC. Cuando la ejecucin del procedimiento almacenado es la primera instruccin del lote, podemos omitir el uso de EXEC. El siguiente ejemplo muestra la ejecucin del procedimiento almacenado anterior.
DECLARE @fecha_nacimiento datetime set @fecha_nacimiento = convert(datetime, '13/05/1975', 103) EXEC spu_addCliente 'Pedro', 'Herrarte', 'Sanchez', '00000002323', @fecha_nacimiento
Siempre es deseable que las instrucciones del procedure esten dentro de un bloque TRY CATCH y controlados por una transaccin.
ALTER PROCEDURE spu_addCliente @nombre varchar(100), @apellido1 varchar(100), @apellido2 varchar(100), @nifCif varchar(20), @fxNaciento datetime AS BEGIN TRY
BEGIN TRAN INSERT INTO CLIENTES (nombre, apellido1, apellido2, nifcif, fxnacimiento) VALUES (@nombre, @apellido1, @apellido2, @nifCif, @fxNaciento) COMMIT END TRY BEGIN CATCH ROLLBACK PRINT ERROR_MESSAGE() END CATCH
Si queremos que los parmetros de un procedimiento almacenado sean de entrada-salida debemos especificarlo a travs de la palabra clave OUTPUT , tanto en la definicin del procedure como en la ejecucin. El siguiente ejemplo muestra la definicin de un procedure con parmetros de salida.
AS BEGIN
SELECT @saldo = SALDO FROM CUENTAS WHERE NUMCUENTA = @numCuenta
END
DECLARE @saldo decimal(10,2) EXEC spu_ObtenerSaldoCuenta '200700000001', @saldo output PRINT @saldo
Un procedimiento almacenado puede devolver valores numericos enteros a travs de la instruccin RETURN. Normalmente debemos utilizar los valores de retorno para determinar si la ejecucin del procedimiento ha sido correcta o no. Si queremos obtener valores se recomienda utilizar parmetros de salida o funciones escalares (se vern mas adelante en este tutorial). El siguiente ejemplo muestra un procedimiento almacenado que devuelve valores.
AS BEGIN
IF (SELECT SALDO FROM CUENTAS WHERE NUMCUENTA = @numCuenta) < 0 BEGIN RETURN 1 END ELSE RETURN 0
END El siguiente ejemplo muestra como ejecutar el procedure y obtener el valor devuelto.
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 INNER JOIN CUENTAS ON MOVIMIENTOS.IDCUENTA = CUENTAS.IDCUENTA WHERE NUMCUENTA = @numCuenta ORDER BY FXMOVIMIENTO DESC
Funciones escalares
Las funciones escalares devuelven un nico valor de cualquier tipo de los datos tal como int, money, varchar, real, etc. La sintaxis para una funcin escalar es la siguiente:
(
-- Lista de parmetros <@Param1, sysname, @p1> <Data_Type_For_Param1, , int>, ... ) -- Tipo de datos que devuelve la funcin. RETURNS <Function_Data_Type, ,int>
AS BEGIN ...
END
(
@NumCuenta VARCHAR(20),
@Multiplicador DECIMAL(10,2)
)
RETURNS DECIMAL(10,2)
AS
BEGIN DECLARE @Saldo DECIMAL(10,2), @Return DECIMAL(10,2)
RETURN @Return
END
Pueden ser utilizadas en cualquier sentencia Transact SQL. Un aspecto a tener en cuenta, es que para utilizar una funcin escalar debemos identificar el nombre de la funcin con el propietario de la misma. El siguiente ejemplo muestra como utilizar la funcin anteriormente creada en una sentencia Transact SQL. Un aspecto muy a tener en cuenta es que la funcin ejecutar sus sentencias SELECT una vez por cada fila del conjunto de resultados devuelto por la consulta SELECT principal.
-- Ejecucion de la funcion:
El siguiente ejemplo muestra como utilizar una funcin escalar en un script Transact SQL.
PRINT @Resultado
Las funciones escalares son muy similares a procedimientos almacenados con parmetros de salida, pero estas pueden ser utilizadas en consultas de seleccion y en la clausula where de las mismas. Las funciones no pueden ejecutar sentencias INSERT o UPDATE.
Funciones en linea
Las funciones en linea son las funciones que devuelven un conjunto de resultados correspondientes a la eecucin de una sentencia SELECT. La sintaxis para una funcin de tabla en linea es la siguiente:
CREATE FUNCTION <Inline_Function_Name, sysname, FunctionName> ( -- Lista de parmetros <@param1, sysname, @p1> <Data_Type_For_Param1, , int>,... ) RETURNS TABLE
AS
RETURN
(
-- Sentencia Transact SQL )
(
@NumCuenta VARCHAR(20) ) RETURNS TABLE AS RETURN
(
SELECT MOVIMIENTOS.* FROM MOVIMIENTOS INNER JOIN CUENTAS ON MOVIMIENTOS.IDCUENTA = CUENTAS.IDCUENTA WHERE CUENTAS.NUMCUENTA = @NumCuenta )
No podemos utilizar la clausula ORDER BY en la sentencia de una funcin el lnea. Las funciones en linea pueden utilizarse dentro de joins o querys como si fueran una tabla normal.
SELECT * FROM CUENTAS INNER JOIN CUENTAS_CLIENTE ON CUENTAS_CLIENTE.IDCUENTA = CUENTAS.IDCUENTA INNER JOIN CLIENTES ON CLIENTES.id = CUENTAS_CLIENTE.IDCLIENTE INNER JOIN fn_MovimientosCuenta('200700000001') A ON A.IDCUENTA= CUENTAS.IDCUENTA
(
-- Lista de parmetros <@param1, sysname, @p1> <data_type_for_param1, , int>, ... ) RETURNS -- variable de tipo tabla y su estructura <@Table_Variable_Name, sysname, @Table_Var> TABLE ( <Column_1, sysname, c1> <Data_Type_For_Column1, , int>, <Column_2, sysname, c2> <Data_Type_For_Column2, , int> )
AS BEGIN
-- Sentencias que cargan de datos la tabla declarada RETURN
END El siguiente ejemplo muestra el uso de una funcion de tabla de multi sentencias.
/* Esta funcion busca la tres cuentas con mayor saldo * y obtiene los tres ltimos movimientos de cada una * de estas cuentas */
CREATE FUNCTION fn_CuentaMovimietos() RETURNS @datos TABLE ( -- Estructura de la tabla que devuelve la funcion. 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
-- Variables necesarias para la lgica de la funcion. DECLARE @idcuenta int, @numcuenta varchar(20), @saldo decimal(10,2)
-- Cursor con las 3 cuentas de mayor saldo DECLARE CDATOS CURSOR FOR SELECT TOP 3 IDCUENTA, NUMCUENTA, SALDO FROM CUENTAS ORDER BY SALDO DESC
-- Recorremos el cursor WHILE (@@FETCH_STATUS = 0) BEGIN -- Insertamos la cuenta en la variable de salida INSERT INTO @datos (NumCuenta, Saldo) VALUES (@numcuenta, @saldo) -- Insertamos los tres ltimos movimientos de la cuenta INSERT INTO @datos (Saldo_anterior, Saldo_posterior, Importe_Movimiento, FxMovimiento )
SELECT TOP 3 SALDO_ANTERIOR, SALDO_POSTERIOR, IMPORTE, FXMOVIMIENTO FROM MOVIMIENTOS WHERE IDCUENTA = @idcuenta ORDER BY FXMOVIMIENTO DESC -- Vamos a la siguiente cuenta FETCH CDATOS INTO @idcuenta, @numcuenta, @saldo END
RETURN
Cast y Convert
Convierten una expresin de un tipo de datos en otro de forma explcita. CAST y CONVERTproporcionan funciones similares. CONVERT ( data_type [ ( length ) ] , expression [ , style ] ) Donde:
y y y
data_type, es el tipo de destino al que queremos convertir la expresion expresion, la expresion que queremos convertir style, parametro opcional que especifica el formato que tiene expresion. Por ejemplo, si queremos convertir un varchar a datetime, aqui debemos especificar el formato de la fecha (el tipo varchar).
-- Convertimos un valor varchar a datetime -- El 103 indica el formato en el que esta escrita la fecha -- 103 => dd/mm/aa
SET @fecha = CONVERT(datetime, '19/03/2008',103)
SELECT @fecha
SELECT @fechaFormateada
SELECT @dato2
1 2 3 4 5 6 7 8 10 11 12 14 -
0 o 100 (1, 2) 101 102 103 104 105 106 (1) 107 (1) 108 9 o 109 (1, 2) 110 111 112 13 o 113 (1, 2) 114 20 o 120 (2) 21 o 121 (2)
Valor predeterminado EE.UU. ANSI Britnico/Francs Alemn Italiano Valor predeterminado + milisegundos EE.UU. JAPN ISO Europeo predeterminado + milisegundos ODBC cannico ODBC cannico (con
mes dd aaaa hh:mia.m. (o p. m.) mm/dd/aaaa aa.mm.dd dd/mm/aa dd.mm.aa dd-mm-aa dd mes aa Mes dd, aa hh:mi:ss mes dd aaaa hh:mi:ss:mmma.m. (o p. m.) mm-dd-aa aa/mm/dd aammdd dd mes aaaa hh:mi:ss:mmm(24h) hh:mi:ss:mmm(24h) aaaa-mm-dd hh:mi:ss(24h) aaaa-mm-dd hh:mi:ss.mmm(24h)
aaaa-mm-ddThh:mi:ss.mmm (sin espacios) aaaa-mm-ddThh:mi:ss.mmmZ (sin espacios) dd mes aaaa hh:mi:ss:mmma.m. dd/mm/aa hh:mi:ss:mmma.m.
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. ISNULL ( expression , replacement_value )
COALESCE
Devuelve la primera expresin distinta de NULL entre sus argumentos. Un aspecto a tener en cuenta es que todos los argumentos deben ser del mismo tipo. COALESCE ( expression [ ,...n ] )
SET @dato1 = null SET @dato2 = NULL SET @dato3 = NULL SET @dato4 = 100 SET @dato5 = 125
-- 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 estndar 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.
Trigger DML, se ejecutan cuando un usuario intenta modificar datos mediante un evento de lenguaje de manipulacin 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 definicin 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 manipulacin de datos (DML). Los eventos DML son instrucciones INSERT, UPDATE o DELETE de una tabla o vista. La sintaxis general de un trigger es la siguiente.
CREATE TRIGGER <Trigger_Name, sysname, Trigger_Name> ON <Table_Name, sysname, Table_Name> AFTER <Data_Modification_Statements, , INSERT,DELETE,UPDATE> AS
BEGIN
-- SET NOCOUNT ON added to prevent extra result sets from -- interfering with SELECT statements. SET NOCOUNT ON; -- Insert statements for trigger here
END Antes de ver un ejemplo es necesario conocer las tablas inserted y deleted. Las instrucciones de triggers DML utilizan dos tablas especiales denominadas inserted y deleted. SQL Server 2005 crea y administra automticamente ambas tablas. La estructura de las
tablas inserted ydeleted es la misma que tiene la tabla que ha desencadenado la ejecucin del trigger. La primera tabla (inserted) solo est disponible en las operaciones INSERT y UPDATE y en ella estn los valores resultantes despues de la insercin o actualizacin. Es decir, los datos insertados. Inserted estar vacia en una operacin DELETE. En la segunda (deleted), disponible en las operaciones UPDATE y DELETE, estn los valores anteriores a la ejecucin de la actualizacin o borrado. Es decir, los datos que sern borrados. Deleted estar vacia en una operacion INSERT. No existe una tabla UPDATED? No, hacer una actualizacin 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. No puede se modificar directamente los datos de estas tablas. El siguiente ejemplo, graba un historico de saldos cada vez que se modifica un saldo de la tabla cuentas.
BEGIN
-- SET NOCOUNT ON impide que se generen mensajes de texto -- con cada instruccin SET NOCOUNT ON; INSERT INTO HCO_SALDOS (IDCUENTA, SALDO, FXSALDO) SELECT IDCUENTA, SALDO, getdate() FROM INSERTED
Una consideracin 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. Podemos especificar a que columnas de la tabla debe afectar el trigger.
BEGIN
-- SET NOCOUNT ON impide que se generen mensajes de texto -- con cada instruccin SET NOCOUNT ON;
IF UPDATE(SALDO) -- Solo si se actualiza SALDO BEGIN INSERT INTO HCO_SALDOS (IDCUENTA, SALDO, FXSALDO) SELECT IDCUENTA, SALDO, getdate() FROM INSERTED END
END
Los trigger estn dentro de la transaccin original (Insert, Delete o Update) por lo cual si dentro de nuestro trigger hacemos un RollBack Tran, no solo estaremos echando atrs nuestro trigger sino tambin toda la transaccin; en otras palabras si en un trigger ponemos un RollBack Tran, la transaccin de Insert, Delete o Update volver toda hacia atrs.
BEGIN
-- SET NOCOUNT ON impide que se generen mensajes de texto -- con cada instruccin SET NOCOUNT ON; INSERT INTO HCO_SALDOS (IDCUENTA, SALDO, FXSALDO) SELECT IDCUENTA, SALDO, getdate() FROM INSERTED
ROLLBACK
END En este caso obtendremos el siguiente mensaje de error: La transaccin termin en el desencadenador. Se anul el lote. Podemos activar y desactivar Triggers a tarvs de las siguientes instrucciones.
GO
Trigger DDL
Los trigger DDL se ejecutan en respuesta a una variedad de eventos de lenguaje de definicin 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. La sintaxis general de un trigger es la siguiente.
CREATE TRIGGER <trigger_name, sysname, table_alter_drop_safety> ON DATABASE FOR <data_definition_statements, , DROP_TABLE, ALTER_TABLE> AS
BEGIN ...
END
La siguiente instruccin impide que se ejecuten sentencias DROP TABLE y ALTER TABLE en la base de datos.
BEGIN
RAISERROR ('No est permitido borrar ni modificar tablas !' , 16, 1) ROLLBACK TRANSACTION
END