Introducción a Transact SQL

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 proporciona SQL 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.

¿Que vamos a necesitar?

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

Programación con Transact SQL

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, estas son:

 Funciones
 Procedimientos almacenados
 Triggers
 Cursores
 Scripts

Pero además Transact SQL nos permite realizar programas sobre las siguientes herramientas
de SQL Server:

 Service Broker

Tipos de datos en Transact SQL

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.

Tipos de datos numéricos.

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.

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

Tipos de datos de caracter.

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
específicas.

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.

Tipos de datos binarios.

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.

Varbinary(max).Igual que varbinary, pero puede almacenar 231-1 bytes

Tipo de datos XML.

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.

DECLARE @myxml XML

set @myxml = (SELECT @@SERVERNAME NOMBRE FOR XML RAW, TYPE)

print cast(@myxml as varchar(max))

Obtendremos la siguiente salida: <row nombre="SVR01"/>

Otros tipos de datos.

UniqueIdentifier. Se utiliza para identificadores únicos. Para generar identificadores únicos

debemos utilizar la función NEWID().

DECLARE @myuniqueid UNIQUEIDENTIFIER

set @myuniqueid = NEWID()

print cast(@myuniqueid as varchar(36))

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.

Tipos de datos personalizados.

Transact SQL permite la creación de tipos de datos personalizados, a trevés de la

instrucción CREATE TYPE. Personalmente, desaconsejo el uso de tipos de datos
personalizados.

CREATE TYPE MD5 FROM CHAR(32) NULL

GO
DECLARE @miMD5 MD5
set @miMD5 = '0000000000000000000000000000000A'
print @miMD5

Variables en Transact SQL

Declarar variables en Transact SQL

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 clavedeclare, seguido del identificador y tipo de datos de la
variable.

-- Esto es un comentario de linea simple

/*
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 = 'Oscar Patty' -- El signo = es un operador
-- Oscar Patty es un literal
print @Nombre -- Imprime por pantalla el valor de @nombre.
-- No diferencia mayúsculas ni minúsculas

Asignar variables en Transact SQL

En Transact SQL podemos asignar valores a una variable de varias formas:

 A través de la instrucción SET.

 Utilizando una sentencia SELECT.
 Realizando un FETCH de un cursor.

El siguiente ejemplo muestra como asignar una variable utilizando la instrucción SET.

DECLARE @nombre VARCHAR(100)

-- La consulta debe devolver un único registro

SET @nombre = (SELECT nombre FROM CLIENTES WHERE ID = 1)

PRINT @nombre

El siguiente ejemplo muestra como asignar variables utilizando una sentencia SELECT.

DECLARE @nombre VARCHAR(100),

@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.

Operadores en Transact SQL

La siguiente tabla ilustra los operadores de Transact SQL .

Tipo de operador Operadores

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)

Estructuras de control en Transact SQL

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

Ejemplo de la estructura condicional IF.

DECLARE @Web varchar(100),

@diminutivo varchar(3)

SET @diminutivo = 'DJK'

IF @diminutivo = 'DJK'
BEGIN
PRINT 'www.Oscar.com'
END
ELSE
BEGIN
PRINT 'Otra Web (peor!)'
END

La estructura IF admite el uso de subconsultas:

DECLARE @coPais int,

@descripcion varchar(255)
set @coPais = 5
set @descripcion = 'España'
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

Estructura condicional CASE

La estructura condicional CASE permite evaluar una expresion y devolver un valor u otro.
La sintaxis general de case es:

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 = 'BOL'
SET @Web = (CASE @diminutivo
WHEN 'BOL' THEN 'BOLIVIA'
WHEN 'PER' THEN 'PERU'
ELSE 'www.OscarPatty.com'
END)
PRINT @Web

Otra sintaxis de CASE nos permite evaluar diferentes expresiones:

CASE
WHEN <expresion> = <valor_expresion> THEN <valor_devuelto>
WHEN <expresion> = <valor_expresion> THEN <valor_devuelto>
ELSE <valor_devuelto> -- Valor por defecto

END

El mismo ejemplo aplicando esta sintaxis:

DECLARE @Web varchar(100),

@diminutivo varchar(3)
SET @diminutivo = 'BOL'

SET @Web = (CASE

WHEN @diminutivo = 'BOL' THEN 'BOLIVIA'
WHEN @diminutivo = 'PER' THEN 'PERU'
ELSE 'www.OscarPatty.com'
END)
PRINT @Web

Otro aspecto muy interesante de CASE es que permite el uso de subconsultas.

DECLARE @Web varchar(100),

@diminutivo varchar(3)
 SET @diminutivo = 'ABC'

SET @Web = (CASE

WHEN @diminutivo = 'ABC' THEN (SELECT web
FROM WEBS
WHERE id=1)
WHEN @diminutivo = 'XYZ' THEN (SELECT web
FROM WEBS
WHERE id=2)
ELSE 'www.oscarpatty.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.

WHILE <expresion>
BEGIN
...
END

Un ejemplo del bucle WHILE.

DECLARE @contador int

SET @contador = 0
WHILE (@contador < 100)
BEGIN
SET @contador = @contador + 1

PRINT 'Iteración del bucle ' + cast(@contador AS varchar)

END

Podemos pasar a la siguiente iteración del bucle utilizando CONTINUE.

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

El bucle se dejará de repetir con la instrucción BREAK.

 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

También podemos utilizar el bucle WHILE conuntamente con subconsultas.

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'
WHERE CO_RECIBO = @coRecibo
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.

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'

Control de errores en Transact SQL

 Uso de TRY CATCH

A partIr de la versión 2005, SQL Server proporciona el control de errores a través de las
instrucciónes TRYy CATCH.

Estas nuevas instrucciones suponen un gran paso adelante en el control de errores en SQL
Server, un tanto precario en las versiones anteriores.

La sintaxis de TRY CATCH es la siguiente:

BEGIN TRY
...
END TRY
BEGIN CATCH
...
END CATCH

El siguiente ejemplo ilustra el uso de TRY - 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

Funciones especiales de Error

Las funciones especiales de error,están disponibles únicamente en el bloque CATCH para la

obtención de información detallada del error.

Son:

 ERROR_NUMBER(), devuelve el número 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 número de línea en el que se ha producido el error.
 ERROR_MESSAGE(), devuelve el mensaje de error.

Son extremadamente útiles para realizar una auditoría 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

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.

La variable de sistema @@ERROR

En versiones anteriores a SQL Server 2005, no estaban disponibles las instrucciones TRY
CATCH. En estas versiones se controlaban los errores utilizando la variable global de sistema
@@ERROR, que almacena el número de error producido por la última sentencia Transact
SQL ejecutada.

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 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.

El siguiente ejemplo ilustra esta situación:

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

Generar un error con RAISERROR

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.

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 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 .

Consultar datos en Transact SQL

La sentencia SELECT

La sentencia SELECT nos permite consultar los datos almacenados en una tabla de la base
de datos.

El formato de la sentencia select es:

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 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

INNER JOIN CATEGORIAS

ON CATEGORIAS.CO_FAMILIA = FAMILIAS.CO_FAMILIA

INNER JOIN PRODUCTOS

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

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.

También podemos forzar un producto cartesiano (todos con todos) a través de CROSS
JOIN.

SELECT * FROM FAMILIAS

CROSS JOIN CATEGORIAS

La cláusula WHERE

La cláusula WHERE es la instrucción que nos permite filtrar el resultado de una

sentencia SELECT.

SELECT CO_FAMILIA, FAMILIA

FROM FAMILIAS

WHERE CO_FAMILIA = 1

Por supuesto, podemos especificar varias condiciones para el WHERE:

SELECT *

FROM FAMILIAS

WHERE CO_FAMILIA = 1

OR CO_FAMILIA = 2

Podemos agrupar varias valores para una condicion en la clausula IN:

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

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 condición WHERE este
debe ir entre comillas simples:

SELECT *

FROM FAMILIAS

WHERE FAMILIA = 'FAMILIA 1'

Para consultar campos alfanumericos, es decir, campos de texto podemos utilizar el

operador LIKEconjuntamente con comodines.

SELECT *

FROM FAMILIAS

WHERE FAMILIA LIKE 'FAM%'

Los comodines que podemos utilizar en son los siguientes:

 % , representa cualquier cadena de texto de cero o más 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.

También podemos obtener los valores distintos utilizando DISTINCT.

SELECT DISTINCT FAMILIA -- Devuelve los distintos valores de FAMILIA

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)

SELECT TOP 10 * -- Devuelve 10 registros

FROM FAMILIAS

SELECT TOP 50 PERCENT * -- Devuelve el 50% de los registros

FROM FAMILIAS
 La clausula TOP se puede combinar con WITH TIES en consultas agregadas.

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.

SELECT CO_FAMILIA, FAMILIA

FROM FAMILIAS

ORDER BY FAMILIA DESC

También podemos indicar el índice del campo en la lista de selección en lugar de su

nombre :

SELECT CO_FAMILIA, FAMILIA

FROM FAMILIAS

ORDER BY 2 DESC -- Ordena por FAMILIA

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,

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 clausula WHERE se aplica antes de realizar el calculo

WHERE CLIENTES.NOMBRE != 'UN NOMBRE'

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 WHERE para 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,

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 clausula WHERE se aplica antes de realizar el calculo

WHERE CLIENTES.NOMBRE != 'UN NOMBRE'

GROUP BY CLIENTES.NOMBRE,

CLIENTES.APELLIDO1,

CLIENTES.APELLIDO2

HAVING SUM(PRECIO) > 100

Funciones agregadas.

Transact SQL pone a nuestra disposición multiples funciones agregadas, las más comunes
son:

 MAX
 MIN
 COUNT
 SUM
 AVG

AVG

Calcula la media aritmética 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 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,

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 número 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 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
SELECT CLIENTES.NOMBRE, COUNT(*)

FROM PEDIDOS

INNER JOIN CLIENTES

ON PEDIDOS.CO_CLIENTE = CLIENTES.CO_CLIENTE

GROUP BY CLIENTES.NOMBRE

Max, Min

Devuelven el mínimo o el máximo 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 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

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 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

INNER JOIN CLIENTES

ON PEDIDOS.CO_CLIENTE = CLIENTES.CO_CLIENTE

GROUP BY CLIENTES.NOMBRE

Uso de Select TOP con consultas agregadas.

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

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)

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 clausula WITH 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)

Insertar datos en Transact SQL

Inserción individual de filas.

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:

INSERT INTO <nombre_tabla>

[(<campo1>[,<campo2>,...])]
values
(<valor1>,<valor2>,...);

El siguiente ejemplo muestra la inserción de un registro en la tabla PRECIOS.

INSERT INTO PRECIOS

(PRECIO, FX_INICIO, FX_FIN, CO_PRODUCTO)

VALUES

(10, getdate(),getdate()+30, 1)
 Insertción múltiple de filas.

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.

El siguiente ejemplo muestra la inserción multiple de filas.

INSERT INTO PRECIOS

(PRECIO,

FX_INICIO,

FX_FIN,

CO_PRODUCTO)

SELECT PRECIO_UNIDAD,

getdate(),

getdate() + 30,

CO_PRODUCTO

FROM DETALLE_PEDIDO

Inserción de valores por defecto.

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).

INSERT INTO PRECIOS DEFAULT VALUES

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:

DECLARE @Codigo int

INSERT INTO PRECIOS

 (PRECIO, FX_INICIO, FX_FIN, CO_PRODUCTO)

VALUES

(10, getdate(),getdate()+30, 1)

set @Codigo = @@Identity

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).

 En este tipo de escenarios debemos utilizar la función, SCOPE_IDENTITY.

DECLARE @Codigo int

INSERT INTO PRECIOS

(PRECIO, FX_INICIO, FX_FIN, CO_PRODUCTO)

VALUES

(10, getdate(),getdate()+30, 1)

SET @Codigo = SCOPE_IDENTITY()

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 y DELETED.

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.
 DELETED no se puede utilizar con la cláusula OUTPUT en la instrucción INSERT.

Las columnas con prefijo INSERTED reflejan el valor después de que se complete la
instrucción UPDATE oINSERT, 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 cláusula OUTPUT en la instrucción 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)

SELECT * FROM @FILAS_INSERTADAS

Actualizar datos en Transact SQL

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>];

El siguiente ejemplo muestra el uso de UPDATE.

UPDATE CLIENTES

SET

NOMBRE = 'Oscar',

APELLIDO1 = 'Patty',

APELLIDO2 = 'Yanique'

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.

Update INNER JOIN

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

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
lógicas INSERTED y DELETED.

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.

DELETED no se puede utilizar con la cláusula OUTPUT en la instrucción INSERT.

DECLARE @FILAS_ACTUALIZADAS TABLE

( CO_CLIENTE int ,

NOMBRE varchar(100),

APELLIDO1 varchar(100),

APELLIDO2 varchar(100)

UPDATE CLIENTES

SET

NOMBRE = 'Oscar',

APELLIDO1 = 'Patty',

APELLIDO2 = 'Yanique'

OUTPUT DELETED.* INTO @FILAS_ACTUALIZADAS

WHERE CO_CLIENTE IN (10, 11, 12)

SELECT * FROM @FILAS_ACTUALIZADAS

Las columnas con prefijo INSERTED reflejan el valor después de que se complete la
instrucción UPDATE oINSERT, 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 cláusula OUTPUT en la instrucción DELETE.

DECLARE @FILAS_ACTUALIZADAS TABLE

( CO_CLIENTE int ,

NOMBRE varchar(100),

APELLIDO1 varchar(100),

APELLIDO2 varchar(100)

UPDATE CLIENTES

SET

NOMBRE = ’Oscar’,

APELLIDO1 = 'Patty',

APELLIDO2 = 'Yanique'

OUTPUT INSERTED.* INTO @FILAS_ACTUALIZADAS

WHERE CO_CLIENTE IN (10, 11, 12)

SELECT * FROM @FILAS_ACTUALIZADAS

Borrar datos en Transact SQL

Delete

Para borrar datos de una tabla debemos utilizar la sentencia 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

Id int identity not null,

dato varchar(100),

fx_alta datetime,

constraint PK_DATOS PRIMARY KEY (Id)

GO

DECLARE @i int,

@dato varchar(100)

set @i = 0

WHILE (@i <100)

BEGIN

SET @i = @i +1

set @dato = 'Dato:' + cast(@i as varchar)

INSERT INTO DATOS (dato, fx_alta)

VALUES (@dato, getdate())

END

GO

SELECT * from DATOS

Para borrar los registros de la tabla "DATOS" ejecutaremos la siguiente instrucción. Notese
que no se especifica ninguna condición WHERE por lo que se borran todos los datos de la tabla.

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.

El siguiente ejemplo ilustra el uso de @@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 y DELETED.

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.

DELETED no se puede utilizar con la cláusula OUTPUT en la instrucción INSERT.

DECLARE @FILAS_BORRADAS TABLE

Id int,

dato varchar(100),

fx_alta datetime

)
 DELETE

FROM DATOS

OUTPUT DELETED.* INTO @FILAS_BORRADAS

WHERE Id=17

SELECT * from @FILAS_BORRADAS

Truncate Table

Para borrar datos de forma masiva disponemos de la instrucción TRUNCATE TABLE, que
borra todos los datos de una tabla.

TRUNCATE TABLE DATOS

Cuando trabajamos con TRUNCATE TABLE debemos tener en cuenta las siguientes
consideraciones:

 TRUNCATE TABLE no admite la clausula WHERE.

 No podemos ejecutar TRUNCATE TABLE sobre tablas que sean "padres" en foreign keys.

Transacciones en Transact SQL

Concepto de transacción

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 somos 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:
DECLARE @importe DECIMAL(18,2),

@CuentaOrigen VARCHAR(12),

@CuentaDestino VARCHAR(12)

/* Asignamos el importe de la transferencia

* y las cuentas de origen y destino

*/

SET @importe = 50

SET @CuentaOrigen = '200700000001'

SET @CuentaDestino = '200700000002'

/* 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

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! )

Transacciones implicitas y explicitas

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.

Para activar-desactivar el modo de transacciones implicitas debemos ejecutar la siguiente

instrucción.

--Activamos el modo de transacciones implicitas

SET IMPLICIT_TRANSACTIONS ON

--Desactivamos el modo de transacciones implicitas

SET IMPLICIT_TRANSACTIONS OFF

Cuando la opción ANSI_DEFAULTS está establecida

en ON, IMPLICIT_TRANSACTIONS también se establece en ON.

El siguiente ejemplo muestra el script anterior haciendo uso de transacciones explicitas.

DECLARE @importe DECIMAL(18,2),

@CuentaOrigen VARCHAR(12),

@CuentaDestino VARCHAR(12)

/* Asignamos el importe de la transferencia

* y las cuentas de origen y destino

*/

SET @importe = 50

SET @CuentaOrigen = '200700000002'

SET @CuentaDestino = '200700000001'

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

/* 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

El siguiente ejemplo muestra el mismo script con transacciones implicitas.

SET IMPLICIT_TRANSACTIONS ON

DECLARE @importe DECIMAL(18,2),

@CuentaOrigen VARCHAR(12),

@CuentaDestino VARCHAR(12)

/* Asignamos el importe de la transferencia

* y las cuentas de origen y destino

*/

SET @importe = 50

SET @CuentaOrigen = '200700000002'

SET @CuentaDestino = '200700000001'

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

/* 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 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.

Podemos verificar el número de transacciones activas a través 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 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

SET NOMBRE = 'Oscar'

WHERE ID=101

BEGIN TRAN

UPDATE EMPLEADOS

SET APELLIDO1 = 'Papuchin'

WHERE ID=101

-- Este COMMIT solo afecta a la segunda transaccion.

COMMIT

-- Este ROLLBACK afecta a las dos transacciones.

ROLLBACK

Una consideración a tener en cuanta cuando trabajamos con transacciones anidadas es la

posibilidad de utilizar puntos de guardado o SAVEPOINTs.

Puntos de recuperacion (SavePoint).

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.

El siguiente ejemplo muestra como trabajar con puntos de recuperación.

BEGIN TRAN

UPDATE EMPLEADOS
SET NOMBRE = 'Oscar'

WHERE ID=101

UPDATE EMPLEADOS

SET APELLIDO1 = 'Oscarin'

WHERE ID=101

SAVE TRANSACTION P1 -- Guardamos la transaccion (Savepoint)

UPDATE EMPLEADOS

SET APELLIDO1 = 'Otra cosa!'

WHERE ID=101

-- Este ROLLBACK afecta solo a las instrucciones

-- posteriores al savepoint P1.

ROLLBACK TRANSACTION P1

-- Confirmamos la transaccion

COMMIT