Documentos de Académico
Documentos de Profesional
Documentos de Cultura
T SQL PDF
T SQL PDF
PERSONALIZADO
Transact - SQL
Hand On LAB de Sql Server Managment Studio
Introducción a Transact SQL
Programación con Transact SQL
Fundamentos de Transact SQL
o Primeros pasos con Transact SQL
o Scripts y lotes.
Tipos de datos en Transact SQL
o Tipos de datos numéricos.
o Tipos de datos de caracter.
o Tipos de datos de fecha.
o Tipos de datos binarios.
o Tipo de datos XML.
o Otros tipos de datos.
o Tipos de datos personalizados.
Variables en Transact SQL
o Declarar variables es Transact SQL
o Asignar variables en Transact SQL
Equivalencia de datos de SQL Server y .NET
Operadores en Transact SQL
Estructuras de control en Transact SQL
o Estructura IF
o Estructura CASE
o Bucle WHILE
o Estructura GOTO
Control de errores en Transact SQL
o Uso de TRY CATCH
o Funciones especiales de Error
o La variable de sistema @@ERROR
o Generar un error con RAISERROR
Consultar datos en Transact SQL
o La sentencia SELECT
o La cláusula WHERE
o La cláusula ORDER BY
Consultas agregadas
o La cláusula GROUP BY
o La cláusula HAVING
o AVG
o Count
o Max, Min
o Sum
o Uso de Select TOP con consultas agregadas
Select FOR XML
o Clausula FOR XML.
o Campos y variables XML.
Operaciones con conjuntos.
o UNION
o EXCEPT
o INTERSECT
Insertar datos en Transact SQL
o Inserción individual de filas.
o Insertción múltiple de filas.
o Inserción de valores por defecto.
o Clausula OUTPUT
Actualizar datos en Transact SQL
o Update
o Update INNER JOIN
o Clausula OUTPUT
Borrar datos en Transact SQL
o Delete
o Clausula OUTPUT
o Truncate Table
Transacciones en Transact SQL
o Concepto de transaccion
o Transacciones implicitas y explicitas
o Transacciones anidadas.
o Puntos de recuperacion
Procedimientos almacenados en Transact SQL
Funciones en Transact SQL
o Funciones escalares
o Funciones en linea
o Funciones en línea de multiples sentencias
Funciones integradas de Transact SQL (I)
o Cast y Convert
o Isnull
o COALESCE
o GetDate y GetUTCDate
Triggers en Transact SQL
o Trigger DML
o Trigger DDL
Cursores en Transact SQL
SQL dinámico en Transact SQL
o La instrucción comando EXECUTE
Inicio de session
Interface Gráfica de SQL Server Management Studio
Observar las relaciones que apunta en dirección de (PK=Primary Key) y (FK=Foreign Key) esta
son de gran utilidad para nuestro caso, ya que en el cursos empleamos las uniones JOIN no
servirán como referencia
Ejercicios corridos con las estructuras de la base de datos northwind
SELECT
O.ORDERID,
O.ORDERDATE,
O.FREIGHT,
C.COMPANYNAME,
C.CONTACTNAME,
E.LASTNAME+' '+E.FIRSTNAME AS EMPLEADO,
P.PRODUCTNAME,
X.CATEGORYNAME,
OD.QUANTITY,
OD.UNITPRICE,
(OD.QUANTITY * OD.UNITPRICE) AS TOTAL
FROM ORDERS O
INNER JOIN [ORDER DETAILS] OD
ON O.ORDERID=OD.ORDERID
INNER JOIN CUSTOMERS C
ON O.CUSTOMERID=C.CUSTOMERID
INNER JOIN EMPLOYEES E
ON O.EMPLOYEEID=E.EMPLOYEEID
INNER JOIN PRODUCTS P
ON OD.PRODUCTID=P.PRODUCTID
INNER JOIN CATEGORIES X
ON P.CATEGORYID=X.CATEGORYID
Vista de los resultados
DECLARE @TABLA TABLE(CODIGO VARCHAR(5),EMPRESA VARCHAR(50),MES INT, MONTO
MONEY)
INSERT INTO @TABLA
SELECT C.CUSTOMERID AS CODIGO,
C.COMPANYNAME AS EMPRESA,
MONTH(ORDERDATE) AS MES,
SUM(O.FREIGHT) AS MONTO
FROM ORDERS O INNER JOIN CUSTOMERS C
ON O.CUSTOMERID = C.CUSTOMERID
WHERE YEAR(ORDERDATE)=1997
GROUP BY C.CUSTOMERID,C.COMPANYNAME,MONTH(ORDERDATE);
WITH RES AS (
SELECT * FROM @TABLA
PIVOT(SUM(MONTO) FOR MES IN( [1],[2],[3],[4],[5],[6],[7],[8],[9],[10],[11],[12]) ) AS PVT)
SELECT CODIGO,EMPRESA,
ISNULL([1],0.0) AS [ENE],
ISNULL([2],0.0) AS [FEB],
ISNULL([3],0.0) AS [MAR],
ISNULL([4],0.0) AS [ABR],
ISNULL([5],0.0) AS [MAY],
ISNULL([6],0.0) AS [JUN],
ISNULL([7],0.0) AS [JUL],
ISNULL([8],0.0) AS [AGO],
ISNULL([9],0.0) AS [SET],
ISNULL([10],0.0) AS [OCT],
ISNULL([11],0.0) AS [NOV],
ISNULL([12],0.0) AS [DIC]
FROM RES
ORDER BY EMPRESA
Transact SQL 2005
Este documento describe las nuevas características de T-SQL para SQL Server 2005.
Introducción
Microsoft Sql Server 2005 (Code Name = YUKON) es un producto con muchas novedades
comparándolo con su antecesor SQL 2000. Sin duda que uno de sus mayores cambios ha sido la
inclusión del CLR dentro del motor de base de datos.
Transact SQL (TSQL) es el lenguaje que usamos para escribir: Store Procedures – Triggers –
Querys – Etc.
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.
Transact SQL es el lenguaje de programación que proporciona SQL Server para ampliar SQL
con los elementos característicos 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.
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.
http://www.microsoft.com/downloads/details.aspx?familyid=220549B5-0B07-
4448-8848-DCC397514B41&displaylang=es
http://www.microsoft.com/downloads/details.aspx?familyid=C243A5AE-4BD1-
4E3D-94B8-5A0F62BF7796&displaylang=es
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 característicos de la programación. No es de
extrañar, SQL es un lenguaje de consulta, no un lenguaje de programación.
Sin embargo, SQL es la herramienta ideal para trabajar con bases de datos. Cuando se desea
realizar una aplicación completa para el manejo de una base de datos relacional, resulta necesario
utilizar alguna herramienta que soporte la capacidad de consulta del SQL y la versatilidad de los
lenguajes de programación tradicionales. Transact SQL es el lenguaje de programación que
proporciona Microsoft SQL Server para extender el SQL estándar con otro tipo de instrucciones y
elementos propios de los lenguajes de programación.
Con Transact SQL vamos a poder programar las unidades de programa de la base de datos
SQL Server, están son:
Procedimientos almacenados
Funciones
Triggers
Scripts
Pero además Transact SQL nos permite realizar programas sobre las siguientes herramientas de
SQL Server:
Service Broker
Fundamentos de Transact SQL
Como introducción vamos a ver algunos elementos y conceptos básicos del lenguaje.
/*
Este es un comentario con varias líneas.
Conjunto de Líneas.
*/
declare @nombre varchar(50)-- declare declara una variable
-- @nombre es el identificador de la
-- variable de tipo varchar
set @nombre = 'www.Microsoft.com' -- El signo = es un operador
-- www.Microsoft.com es un literal
print @Nombre -- Imprime por pantalla el valor de @nombre.
-- No diferencia mayúsculas ni minúsculas
Scripts y lotes.
Un script está compuesto por uno o varios lotes. Un lote delimita el alcance de las variables y
sentencias del script. Dentro de un mismo script se diferencian los diferentes lotes a través de las
instrucción GO.
En ocasiones es necesario separar las sentencias en varios lotes, porque Transact SQL no
permite la ejecución de ciertos comandos en el mismo lote, si bien normalmente también se utilizan
los lotes para realizar separaciones lógicas dentro del script.
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.
SQL Server dispone de varios tipos de datos numéricos. 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 numéricos decimales sin
redondear. Donde p es la precisión (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áximo de precisión. La precisión puede variar entre 1 y 53.
Money. Almacena valores numéricos monetarios de -263 a 263-1, con una precisión de hasta diez
milésimas de la unidad monetaria.
Todos los tipos de datos enteros pueden marcarse con la propiedad identity para hacerlos auto
numé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
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(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
diferentes idiomas.
Nvarchar(max).Igual que varchar, pero al declararse como max puede almacenar 231-1 bytes.
Datetime. Almacena fechas con una precisión de milisegundo. Debe usarse para fechas muy
específicas.
SmallDatetime. Almacena fechas con una precisión de minuto, por lo que ocupa la mitad de
espacio de que el tipo datetime, para tablas que puedan llegar a tener muchos datos es un factor a
tener muy en cuenta.
TimeStamp.Se utiliza para marcar un registro con la fecha de inserción - actualización. El tipo
timestamp se actualiza automáticamente cada vez que insertamos o modificamos los datos.
Binary. Se utiliza para almacenar datos binarios de longitud fija, con una longitud máxima de 8000
bytes.
Varbinary. Se utiliza para almacenar datos binarios de longitud variable, con una longitud máxima
de 8000 bytes..Es muy similar a binary, salvo que varbinary utiliza menos espacio en disco.
XML.Una de las grandes mejoras que incorpora SQL Server 2005 es el soporte nativo para XML.
Como podemos deducir, este tipo de datos se utiliza para almacenar XML.
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 carácter @, es decir, el
nombre de una variable debe comenzar por @. Para declarar variables en Transact SQL debemos
utilizar la palabra clave declare, seguido del identificador y tipo de datos de la variable.
/*
Este es un comentario con varias líneas.
Conjunto de Líneas.
*/
declare @nombre varchar(50)-- declare declara una variable
-- @nombre es el identificador de la
-- variable de tipo varchar
set @nombre = 'www.Microsoft.com' -- El signo = es un operador
-- www.Microsoft.com es un literal
print @Nombre -- Imprime por pantalla el valor de @nombre.
-- No diferencia mayúsculas ni minúsculas
El siguiente ejemplo muestra como asignar una variable utilizando la instrucción SET.
FROM CLIENTES
WHERE ID = 1)
PRINT @nombre
El siguiente ejemplo muestra como asignar variables utilizando una sentencia SELECT.
@apellido1 VARCHAR(100),
@apellido2 VARCHAR(100)
SELECT @nombre=nombre ,
@apellido1=Apellido1,
@apellido2=Apellido2
FROM CLIENTES
WHERE ID = 1
PRINT @nombre
PRINT @apellido1
PRINT @apellido2
Un punto a tener en cuenta cuando asignamos variables de este modo, es que si la consulta
SELECT devuelve más de un registro, las variables quedarán asignadas con los valores de la última
fila devuelta.
Por último veamos como asignar variables a través de un cursor.
@apellido1 VARCHAR(100),
@apellido2 VARCHAR(100)
FOR
FROM CLIENTES
OPEN CDATOS
WHILE (@@FETCH_STATUS = 0)
BEGIN
PRINT @nombre
PRINT @apellido1
PRINT @apellido2
END
CLOSE CDATOS
DEALLOCATE CDATOS
Veremos los cursores con más detalle más adelante en este tutorial.
Equivalencia de datos de SQL Server y .NET
La siguiente lista muestra los tipos de datos de SQL Server 2005 y sus equivalentes con CRL,
para el namespace System.Data.SqlTypes y los tipos nativos de CRL .NET FrameWork
Operador de asignación =
Operador de
+
concatenación
La estuctura condicional IF permite evaluar una expresion booleana (resultado SI - NO), y ejecutar las
operaciones contenidas en el bloque formado por BEGIN END.
IF (<expresion>)
BEGIN
...
END
ELSE IF (<expresion>)
BEGIN
...
END
ELSE
BEGIN
...
END
IF @diminutivo = 'DJK'
BEGIN
PRINT 'www.microsoft.com'
END
ELSE
BEGIN
PRINT 'Otra Web (peor!)'
END
La estructura IF admite el uso de subconsultas:
ELSE
BEGIN
INSERT INTO PAISES
(CO_PAIS, DESCRIPCION) VALUES
(@coPais, @descripcion)
END
La estructura condicional CASE permite evaluar una expresion y devolver un valor u otro.
CASE <expresion>
WHEN <valor_expresion> THEN <valor_devuelto>
WHEN <valor_expresion> THEN <valor_devuelto>
ELSE <valor_devuelto> -- Valor por defecto
END
Ejemplo de CASE.
CASE
WHEN <expresion> = <valor_expresion> THEN <valor_devuelto>
WHEN <expresion> = <valor_expresion> THEN <valor_devuelto>
ELSE <valor_devuelto> -- Valor por defecto
END
WHILE <expresion>
BEGIN
...
END
Estructura GOTO
La sentencia goto nos permite desviar el flujo de ejecución hacia una etiqueta. Fué muy utilizada en
versiones anteriores de SQL Server conjuntamente con la variable de sistema @@ERROR para el control
de errores.
Actualmente, se desaconseja el uso GOTO, recomendandose el uso de TRY - CATCH para la gestion de
errores.
IF @@ERROR > 0
GOTO error
A partIr de la versión 2005, SQL Server proporciona el control de errores a través de las
instrucciónes TRY y CATCH.
Estas nuevas instrucciones suponen un gran paso adelante en el control de errores en SQL
Server, un tanto precario en las versiones anteriores.
BEGIN TRY
...
END TRY
BEGIN CATCH
...
END CATCH
BEGIN TRY
@dividendo int,
@resultado int
SET @divisor = 0
Las funciones especiales de error, están disponibles únicamente en el bloque CATCH para la
obtención de información detallada del error.
Son:
BEGIN TRY
@dividendo int,
@resultado int
SET @divisor = 0
Lógicamente, podemos utilizar estas funciones para almacenar esta información en una tabla de
la base de datos y registrar todos los errores que se produzcan.
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.
IF @@ERROR = 0
BEGIN
PRINT 'No hay error'
END
ELSE
BEGIN
PRINT 'Hay error'
END
El uso de @@ERROR para controlar errores puede provocar multitud de problemas. Uno de los
más habituales es sin duda, incluir una nueva sentencia Transact SQL entre la línea que provoco
el error y la que lo controla. Esa nueva instrucción restaura el valor de @@ERROR y
no controlaremos el error.
En ocasiones es necesario provocar voluntariamente un error, por ejemplo nos puede interesas
que se genere un error cuando los datos incumplen una regla de negocio.
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 conexión 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 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).
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 categorías y los productos.
SELECT *
FROM FAMILIAS
ON CATEGORIAS.CO_FAMILIA = FAMILIAS.CO_FAMILIA
ON PRODUCTOS.CO_CATEGORIA = CATEGORIAS.CO_CATEGORIA
La combinación se realiza a través de la cláusula INNER JOIN, que es una clausula exclusiva,
es decir las familias que no tengan categorías y productos asociados no se devolverán.
Si queremos realizar la consulta para que no sea exclusiva, tenemos que utilizar LEFT JOIN. El
uso de la palabra reservada OUTER es opcional.
SELECT *
FROM FAMILIAS
ON CATEGORIAS.CO_FAMILIA = FAMILIAS.CO_FAMILIA
ON PRODUCTOS.CO_CATEGORIA = CATEGORIAS.CO_CATEGORIA
Los registros que no tengan datos relacionados en una consulta LEFT JOIN devolverán en valor
null en los campos que correspondan a las tablas en las que no tienen dato.
También podemos forzar un producto cartesiano (todos con todos) a través de CROSS JOIN.
La cláusula WHERE es la instrucción que nos permite filtrar el resultado de una sentencia
SELECT.
FROM FAMILIAS
WHERE CO_FAMILIA = 1
SELECT *
FROM FAMILIAS
WHERE CO_FAMILIA = 1
OR CO_FAMILIA = 2
SELECT *
FROM FAMILIAS
WHERE CO_FAMILIA IN ( 1 , 2)
La cláusula WHERE se puede utilizar conjuntamente con INNER JOIN, LEFT JOIN ...
SELECT FAMILIAS.CO_FAMILIA,
FAMILIAS.FAMILIA
FROM FAMILIAS
ON CATEGORIAS.CO_FAMILIA = FAMILIAS.CO_FAMILIA
SELECT *
FROM FAMILIAS
Para consultar campos alfanuméricos, es decir, campos de texto podemos utilizar el operador
LIKE conjuntamente con comodines.
SELECT *
FROM FAMILIAS
FROM FAMILIAS
Podemos limitar el número de registros que devuelve la consulta a través de la cláusula TOP. La
cláusula TOP admite como parámetros un valor numérico entero o un porcentaje (sólo a partir de
la versión 2005)
FROM FAMILIAS
FROM FAMILIAS
La cláusula 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.
FROM FAMILIAS
También podemos indicar el índice del campo en la lista de selección en lugar de su nombre :
FROM FAMILIAS
La cláusula 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:
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 agrupado por los datos del cliente.
SELECT CLIENTES.NOMBRE,
CLIENTES.APELLIDO1,
CLIENTES.APELLIDO2,
FROM DETALLE_PEDIDO
ON DETALLE_PEDIDO.CO_PEDIDO = PEDIDOS.CO_PEDIDO
ON PEDIDOS.CO_CLIENTE = CLIENTES.CO_CLIENTE
GROUP BY CLIENTES.NOMBRE,
CLIENTES.APELLIDO1,
CLIENTES.APELLIDO2
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 después de
haber aplicado el filtro impuesto por la cláusula WHERE.
SELECT CLIENTES.NOMBRE,
CLIENTES.APELLIDO1,
CLIENTES.APELLIDO2,
FROM DETALLE_PEDIDO
ON DETALLE_PEDIDO.CO_PEDIDO = PEDIDOS.CO_PEDIDO
ON PEDIDOS.CO_CLIENTE = CLIENTES.CO_CLIENTE
GROUP BY CLIENTES.NOMBRE,
CLIENTES.APELLIDO1,
CLIENTES.APELLIDO2
La cláusula HAVING
Es posible que necesitemos calcular un agregado, pero que no necesitemos obtener todos los datos,
solo los que cumplan una condición del agregado. Por ejemplo, podemos calcular el valor de las ventas por
producto, pero que solo queramos ver los datos de los productos que hayan vendido más o menos de una
determinada cantidad. En estos casos debemos utilizar la cláusula 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 después de calcular el
agregado. Una vez que los registros se han agrupado utilizando GROUP BY, HAVING determina cuáles
de ellos se van a mostrar. HAVING permite el uso de funciones agregadas.
SELECT CLIENTES.NOMBRE,
CLIENTES.APELLIDO1,
CLIENTES.APELLIDO2,
FROM DETALLE_PEDIDO
ON DETALLE_PEDIDO.CO_PEDIDO = PEDIDOS.CO_PEDIDO
ON PEDIDOS.CO_CLIENTE = CLIENTES.CO_CLIENTE
GROUP BY CLIENTES.NOMBRE,
CLIENTES.APELLIDO1,
CLIENTES.APELLIDO2
Transact SQL pone a nuestra disposición múltiples funciones agregadas, las más comunes son:
MAX
MIN
COUNT
SUM
AVG
AVG
AVG(<expr>)
En donde expr representa el campo que contiene los datos numéricos para los que se desea calcular la
media o una expresión que realiza un cálculo utilizando los datos de dicho campo. La media calculada por
Avg es la media aritmética (la suma de los valores dividido por el número de valores). La función Avg no
incluye ningún campo Null en el cálculo.
SELECT CLIENTES.NOMBRE,
CLIENTES.APELLIDO1,
CLIENTES.APELLIDO2,
FROM DETALLE_PEDIDO
ON DETALLE_PEDIDO.CO_PEDIDO = PEDIDOS.CO_PEDIDO
ON PEDIDOS.CO_CLIENTE = CLIENTES.CO_CLIENTE
GROUP BY CLIENTES.NOMBRE,
CLIENTES.APELLIDO1,
CLIENTES.APELLIDO2
Count
COUNT(<expr>)
En donde expr contiene el nombre del campo que desea contar. Los operandos de expr pueden incluir
el nombre de un campo de una tabla, una constante o una función (la cual puede ser intrínseca o definida
por el usuario pero no otras de las funciones agregadas de SQL). Puede contar cualquier tipo de datos
incluso texto.
Aunque expr puede realizar un cálculo sobre un campo, Count simplemente cuenta el número de
registros sin tener en cuenta qué valores se almacenan en los registros. La función Count no cuenta los
registros que tienen campos null a menos que expr sea el carácter comodín asterisco (*). Si utiliza un
asterisco, Count calcula el número total de registros, incluyendo aquellos que contienen campos null.
Count(*) es considerablemente más rápida que Count(Campo).
SELECT COUNT(*)
FROM PEDIDOS
FROM PEDIDOS
ON PEDIDOS.CO_CLIENTE = CLIENTES.CO_CLIENTE
GROUP BY CLIENTES.NOMBRE
Max, Min
MIN(<expr>)
MAX(<expr>)
En donde expr es el campo sobre el que se desea realizar el cálculo. Expr puede incluir el nombre de un
campo de una tabla, una constante o una función (la cual puede ser intrínseca o definida por el usuario
pero no otras de las funciones agregadas de SQL).
SELECT CLIENTES.NOMBRE,
MIN(PEDIDOS.FX_ALTA),
MAX(PEDIDOS.FX_ALTA)
FROM PEDIDOS
ON PEDIDOS.CO_CLIENTE = CLIENTES.CO_CLIENTE
GROUP BY CLIENTES.NOMBRE
Sum
Devuelve la suma del conjunto de valores contenido en un campo especifico de una consulta. Su
sintaxis es:
SUM(<expr>)
En donde expr representa el nombre del campo que contiene los datos que desean sumarse o una
expresión que realiza un cálculo utilizando los datos de dichos campos. Los operandos de expr pueden
incluir el nombre de un campo de una tabla, una constante o una función (la cual puede ser intrínseca o
definida por el usuario pero no otras de las funciones agregadas de SQL).
SELECT CLIENTES.NOMBRE,
SUM(PEDIDOS.TOTAL_PEDIDO)
FROM PEDIDOS
ON PEDIDOS.CO_CLIENTE = CLIENTES.CO_CLIENTE
GROUP BY CLIENTES.NOMBRE
Podemos utilizar SELECT TOP con consultas agregadas como con cualquier otra instrucción Transact
SQL.
En estos casos, la cláusula TOP se aplica después de calcular el agregado, devolviendo las N filas
indicadas.
En este escenario es posible que queramos obtener los N valores que satisfagan una condición. Por
ejemplo, queremos si queremos obtener los tres primeros clientes con mayores pedidos, usaríamos una
consulta parecida a esta:
SELECT TOP 3
CLIENTES.NOMBRE,
SUM(DETALLE_PEDIDO.PRECIO)
FROM DETALLE_PEDIDO
ON DETALLE_PEDIDO.CO_PEDIDO = PEDIDOS.CO_PEDIDO
ON PEDIDOS.CO_CLIENTE = CLIENTES.CO_CLIENTE
GROUP BY CLIENTES.NOMBRE
ORDER BY 2 -- SUM(DETALLE_PEDIDO.PRECIO_UNIDAD)
Sin embargo, puede darse el caso, de que el cuarto cliente devuelto por la consulta tenga un valor
agregado idéntico al tercero, (es decir, están 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
cláusula WITH TIES.
FROM DETALLE_PEDIDO
ON DETALLE_PEDIDO.CO_PEDIDO = PEDIDOS.CO_PEDIDO
ON PEDIDOS.CO_CLIENTE = CLIENTES.CO_CLIENTE
GROUP BY CLIENTES.NOMBRE
ORDER BY 2 -- SUM(DETALLE_PEDIDO.PRECIO_UNIDAD)
Select FOR XML
Cláusula FOR XML.
A partir de la versión 2000 SQL Server incluye la cláusula FOR XML para la consultas. Sin
embargo, es a partir de la versión 2005 cuando se integra XML como tipo de dato nativo.
La cláusula FOR XML admite los siguientes modos que representan el formato en el que el XML
es devuelto:
XML AUTO, el modo AUTO emplea los campos en la declaración SELECT para formar una
jerarquía simple XML.
XML RAW, el modo RAW genera elementos únicos, los cuales se denominan row, por
cada fila retornada.
EXPLICIT, el modo EXPLICIT requiere un formato específico que puede ser mapeado en
casi cualquier forma XML, y al mismo tiempo ser formulado por una sola consulta SQL.
Adicionalmente, disponemos de dos opciones más TYPE y ELEMENTS que determinan el formato
del XML resultante. Los vemos con ejemplos.
FROM FAMILIAS
ORDER BY FAMILIA
FROM FAMILIAS
<FAMILIAS>
<CO_FAMILIA>1</CO_FAMILIA>
<FAMILIA>FAMILIA 1</FAMILIA>
</FAMILIAS>
<FAMILIAS>
<CO_FAMILIA>2</CO_FAMILIA>
<FAMILIA>FAMILIA 2</FAMILIA>
</FAMILIAS>
<FAMILIAS>
<CO_FAMILIA>3</CO_FAMILIA>
<FAMILIA>FAMILIA 3</FAMILIA>
</FAMILIAS>
<FAMILIAS>
<CO_FAMILIA>4</CO_FAMILIA>
<FAMILIA>FAMILIA 4</FAMILIA>
</FAMILIAS>
FROM FAMILIAS
ORDER BY FAMILIA
<row>
<CO_FAMILIA>1</CO_FAMILIA>
<FAMILIA>FAMILIA 1</FAMILIA>
</row>
<row>
<CO_FAMILIA>2</CO_FAMILIA>
<FAMILIA>FAMILIA 2</FAMILIA>
</row>
<row>
<CO_FAMILIA>3</CO_FAMILIA>
<FAMILIA>FAMILIA 3</FAMILIA>
</row>
<row>
<CO_FAMILIA>4</CO_FAMILIA>
<FAMILIA>FAMILIA 4</FAMILIA>
</row>
También es posible especificar el nodo que queremos que muestre:
FROM FAMILIAS
ORDER BY FAMILIA
FROM FAMILIAS
ORDER BY FAMILIA
<FamiliasDeProductos>
<CO_FAMILIA>1</CO_FAMILIA>
<FAMILIA>FAMILIA 1</FAMILIA>
</FamiliasDeProductos>
<FamiliasDeProductos>
<CO_FAMILIA>2</CO_FAMILIA>
<FAMILIA>FAMILIA 2</FAMILIA>
</FamiliasDeProductos>
<FamiliasDeProductos>
<CO_FAMILIA>3</CO_FAMILIA>
<FAMILIA>FAMILIA 3</FAMILIA>
</FamiliasDeProductos>
<FamiliasDeProductos>
<CO_FAMILIA>4</CO_FAMILIA>
<FAMILIA>FAMILIA 4</FAMILIA>
</FamiliasDeProductos>
SELECT
1 AS TAG, -- La primera columna debe tener el alias TAG
-- <NombreNodo>!<nodo>!<atributo>
CO_FAMILIA as "FamiliaDeProductos!1!CODIGO_FAMILIA",
FAMILIA as "FamiliaDeProductos!1!DESCRIPCION"
FROM FAMILIAS
ORDER BY FAMILIA
Dado que XML es un tipo nativo de XML podemos definir tablas con campos de tipo XML,
variables...
GO
Las consultas a unir deben tener el mismo número campos, y además los campos deben
ser del mismo tipo.
Sólo puede haber una única clausula ORDER BY al final de la sentencia SELECT.
UNION
UNION devuelve la suma de dos o más conjuntos de resultados. El conjunto obtenido como
resultado de UNION tiene la misma estructura que los conjuntos originales.
FROM EMPLEADOS
UNION
FROM CLIENTES
Cuando realizamos una consulta con UNION internamente se realiza una operación DISTINCT
sobre el conjunto de resultados final. Si queremos obtener todos los valores debemos utiliza
UNION ALL.
FROM EMPLEADOS
UNION ALL
FROM CLIENTES
EXCEPT
FROM EMPLEADOS
EXCEPT
FROM CLIENTES
El uso de EXCEPT, como norma general, es mucho más rápido que utilizar condiciones NOT IN
o EXISTS en la cláusula WHERE.
INTERSECT
Devuelve la intersección entre dos o más conjuntos de resultados en uno. El conjunto obtenido
como resultado de INTERSECT tiene la misma estructura que los conjuntos originales.
FROM EMPLEADOS
INTERSECT
FROM CLIENTES
Insertar datos en Transact SQL
Inserción individual de filas.
Para realizar la inserción individual de filas SQL posee la instrucción INSERT INTO.La inserción
individual de filas es la que más comúnmente utilizaremos. Su sintaxis es la siguiente:
VALUES
(10, getdate(),getdate()+30, 1)
También es posible insertar en una tabla el resultado de una consulta SELECT. De este modo se
insertarán tantas filas como haya devuelto la consulta SELECT.
(PRECIO,
FX_INICIO,
FX_FIN,
CO_PRODUCTO)
SELECT PRECIO_UNIDAD,
getdate(),
getdate() + 30,
CO_PRODUCTO
FROM DETALLE_PEDIDO
También podemos forzar a que la insercción se realice con los datos por defecto establecidos para la
tabla (o null si no tienen valores por defecto).
En SQL Sever podemos marcar un campo de una tabla como auto numérico (identity), cuando
insertamos un registro en dicha tabla el valor del campo se genera automáticamente. Para recuperar el
valor generado disponemos de varios métodos:
Utilizar la función @@identity, que devuelve el último valor identidad insertado por la transacción:
VALUES
(10, getdate(),getdate()+30, 1)
PRINT @Codigo
El uso de @@Identity no siempre es válido, ya que al devolver el último 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.
VALUES
(10, getdate(),getdate()+30, 1)
PRINT @Codigo
Clausula OUTPUT
A partir de la versión de SQL Server 2005 disponemos de la cláusula 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 o
DELETE. Es decir, son una copia de los datos "antes" del cambio.
Las columnas con prefijo INSERTED reflejan el valor después de que se complete la instrucción
UPDATE o INSERT, pero antes de que se ejecuten los desencadenadores. Es decir, son una copia de los
datos "después" del cambio.
( CO_PRECIO int,
PRECIO decimal,
FX_INICIO datetime,
FX_FIN datetime,
CO_PRODUCTO int
VALUES
(10, getdate(),getdate()+30, 1)
UPDATE <nombre_tabla>
SET <campo1> = <valor1>
{[,<campo2> = <valor2>,...,<campoN> = <valorN>]}
[ WHERE <condicion>];
UPDATE CLIENTES
SET
NOMBRE = 'Microsoft',
APELLIDO1 = 'Herrarte',
APELLIDO2 = 'Sánchez'
WHERE CO_CLIENTE = 10
Un aspecto a tener en cuenta, sobre todo si has trabajado con ORACLE, es que SQL graba los
cambios inmediatamente sin necesidad de hacer COMMIT. Por supuesto podemos gestionar
nosotros las transacciones pero es algo que hay que hacer de forma explícita con la instrucción
BEGIN TRAN y que se verá en capítulos posteriores de este tutorial.
B.
C.
D.
E.
F.
G.
H. Update INNER JOIN
En ocasiones queremos actualizar los datos de una tabla con los datos de otra (muy común para
des normalizar un modelo de datos).
Habitualmente, usamos subconsultas para este propósito, pero Transact SQL permite la
utilización de la sentencia UPDATE INNER JOIN.
UPDATE CLIENTES
SET
NOMBRE = FICHERO_CLIENTES.NOMBRE,
APELLIDO1 = FICHERO_CLIENTES.APELLIDO1,
APELLIDO2 = FICHERO_CLIENTES.APELLIDO2
FROM CLIENTES
ON FICHERO_CLIENTES.CO_CLIENTE = CLIENTES.CO_CLIENTE
I. Clausula OUTPUT
A partir de la versión de SQL Server 2005 disponemos de la cláusula 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 o DELETE. Es decir, son una copia de los datos "antes" del cambio.
( CO_CLIENTE int ,
NOMBRE varchar(100),
APELLIDO1 varchar(100),
APELLIDO2 varchar(100)
UPDATE CLIENTES
SET
NOMBRE = 'Microsoft',
APELLIDO1 = 'Herrarte',
APELLIDO2 = 'Sánchez'
Las columnas con prefijo INSERTED reflejan el valor después de que se complete la instrucción
UPDATE o INSERT, pero antes de que se ejecuten los desencadenadores. Es decir, son una copia
de los datos "después" del cambio.
( CO_CLIENTE int ,
NOMBRE varchar(100),
APELLIDO1 varchar(100),
APELLIDO2 varchar(100)
)
UPDATE CLIENTES
SET
NOMBRE = 'Microsoft',
APELLIDO1 = 'Herrarte',
APELLIDO2 = 'Sánchez'
dato varchar(100),
fx_alta datetime,
GO
DECLARE @i int,
@dato varchar(100)
set @i = 0
BEGIN
SET @i = @i +1
END
GO
Para borrar los registros de la tabla "DATOS" ejecutaremos la siguiente instrucción. Nótese 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 especificar que registros queremos borrar a través de la cláusula WHERE.
DELETE
FROM DATOS
WHERE Id=12
Cuando borramos datos de una tabla, podemos obtener el número de filas que han sido
afectadas por la instrucción a través de la variable @@RowCount.
DELETE
FROM DATOS
WHERE Id=17
SELECT @@ROWCOUNT
Clausula OUTPUT
A partir de la versión de SQL Server 2005 disponemos de la cláusula 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 o DELETE. 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.
Id int,
dato varchar(100),
fx_alta datetime
DELETE
FROM DATOS
WHERE Id=17
Truncate Table
Para borrar datos de forma masiva disponemos de la instrucción TRUNCATE TABLE, que borra
todos los datos de una tabla.
Cuando trabajamos con TRUNCATE TABLE debemos tener en cuenta las siguientes
consideraciones:
Concepto de 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:
@CuentaOrigen VARCHAR(12),
@CuentaDestino VARCHAR(12)
*/
SET @importe = 50
UPDATE CUENTAS
SELECT
FROM CUENTAS
UPDATE CUENTAS
/* Registramos el movimiento */
SELECT
FROM CUENTAS
Esta forma de actuar seria errónea, ya que cada instrucción se ejecutaría y confirmaría de forma
independiente, por lo que un error dejaría los datos erróneos en la base de datos ( ¡y ese es el peor
error que nos podemos encontrar! )
Transacciones implícitas 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áticamente 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ón
COMMIT o ROLLBACK.
SET IMPLICIT_TRANSACTIONS ON
@CuentaOrigen VARCHAR(12),
@CuentaDestino VARCHAR(12)
*/
SET @importe = 50
SET @CuentaOrigen = '200700000002'
BEGIN TRY
UPDATE CUENTAS
/* Registramos el movimiento */
SELECT
FROM CUENTAS
UPDATE CUENTAS
/* Registramos el movimiento */
INSERT INTO MOVIMIENTOS
SELECT
FROM CUENTAS
/* Confirmamos la transaccion*/
END TRY
BEGIN CATCH
END CATCH
SET IMPLICIT_TRANSACTIONS ON
@CuentaOrigen VARCHAR(12),
@CuentaDestino VARCHAR(12)
*/
SET @importe = 50
BEGIN TRY
UPDATE CUENTAS
/* Registramos el movimiento */
SELECT
FROM CUENTAS
/* Registramos el movimiento */
SELECT
FROM CUENTAS
/* Confirmamos la transaccion*/
END TRY
BEGIN CATCH
END CATCH
La transacción sigue activa hasta que emita una instrucción COMMIT o ROLLBACK. Una vez
que la primera transacción se ha confirmado o revertido, se inicia automáticamente una nueva
transacción la siguiente vez que la conexión ejecuta una instrucción para modificar datos.
SET IMPLICIT_TRANSACTIONS ON
BEGIN TRY
PRINT @@TRANCOUNT
COMMIT
END TRY
BEGIN CATCH
ROLLBACK
PRINT 'Error'
END CATCH
Otro punto a tener en cuenta cuando trabajamos con transacciones son los bloqueos y el nivel
de aislamiento. Podemos aprender más sobre bloqueos y nivel de aislamiento en este artículo.
Transacciones anidadas.
BEGIN TRAN
UPDATE EMPLEADOS
WHERE ID=101
BEGIN TRAN
UPDATE EMPLEADOS
WHERE ID=101
COMMIT
ROLLBACK
Los puntos de recuperación (SavePoints) permiten manejar las transacciones por pasos,
pudiendo hacer rollbacks hasta un punto marcado por el savepoint y no por toda la transacción.
BEGIN TRAN
UPDATE EMPLEADOS
WHERE ID=101
UPDATE EMPLEADOS
WHERE ID=101
UPDATE EMPLEADOS
WHERE ID=101
ROLLBACK TRANSACTION P1
-- Confirmamos la transacción
COMMIT
III. Procedimientos almacenados en Transact SQL
Un procedimiento es un programa dentro de la base de datos que ejecuta una acción o conjunto
de acciones específicas.
En Transact SQL los procedimientos almacenados pueden devolver valores (numérico entero) o
conjuntos de resultados.
AS
AS
@apellido1 varchar(100),
@apellido2 varchar(100),
@nifCif varchar(20),
@fxNaciento datetime
AS
Siempre es deseable que las instrucciones del procedure esten dentro de un bloque TRY CATCH
y controlados por una transacción.
@apellido1 varchar(100),
@apellido2 varchar(100),
@nifCif varchar(20),
@fxNaciento datetime
AS
BEGIN TRY
BEGIN TRAN
COMMIT
END TRY
BEGIN CATCH
ROLLBACK
PRINT ERROR_MESSAGE()
END CATCH
AS
BEGIN
FROM CUENTAS
END
PRINT @saldo
Un procedimiento almacenado puede devolver valores numéricos enteros a través de la
instrucción RETURN. Normalmente debemos utilizar los valores de retorno para determinar si la
ejecución del procedimiento ha sido correcta o no. Si queremos obtener valores se recomienda
utilizar parámetros de salida o funciones escalares (se verán más adelante en este tutorial).
AS
BEGIN
BEGIN
RETURN 1
END
ELSE
RETURN 0
END
PRINT @rv
Otra característica muy interesante de los procedimientos almacenados en Transact SQL es
que pueden devolver uno o varios conjuntos de resultados.
AS
BEGIN
SELECT @numCuenta,
SALDO_ANTERIOR,
SALDO_POSTERIOR,
IMPORTE,
FXMOVIMIENTO
FROM MOVIMIENTOS
END
El resultado de la ejecución...
Funciones escalares.
Funciones en línea.
Funciones en línea de multiples sentencias
Funciones escalares
Las funciones escalares devuelven un único valor de cualquier tipo de los datos tal como int, money,
varchar, real, etc.
-- Lista de parámetros
)
-- Tipo de datos que devuelve la función.
AS
BEGIN
...
END
@NumCuenta VARCHAR(20),
@Multiplicador DECIMAL(10,2)
RETURNS DECIMAL(10,2)
AS
BEGIN
@Return DECIMAL(10,2)
FROM CUENTAS
RETURN @Return
END
Pueden ser utilizadas en cualquier sentencia Transact SQL. Un aspecto a tener en cuenta, es que para
utilizar una función escalar debemos identificar el nombre de la función con el propietario de la misma.
El siguiente ejemplo muestra cómo utilizar la función anteriormente creada en una sentencia Transact
SQL. Un aspecto muy a tener en cuenta es que la función ejecutará sus sentencias SELECT una vez por
cada fila del conjunto de resultados devuelto por la consulta SELECT principal.
SELECT IDCUENTA,
NUMCUENTA,
SALDO,
FXALTA,
-- Ejecucion de la función:
FROM CUENTAS
El siguiente ejemplo muestra cómo utilizar una función escalar en un script Transact SQL.
@Resultado DECIMAL(10,2)
PRINT @Resultado
Las funciones escalares son muy similares a procedimientos almacenados con parámetros de salida, pero
estas pueden ser utilizadas en consultas de selección y en la cláusula where de las mismas.
Las funciones en línea son las funciones que devuelven un conjunto de resultados correspondientes a la
ejecución de una sentencia SELECT.
-- Lista de parámetros
RETURNS TABLE
AS
RETURN
@NumCuenta VARCHAR(20)
RETURNS TABLE
AS
RETURN
(
SELECT MOVIMIENTOS.*
FROM MOVIMIENTOS
Las funciones en línea pueden utilizarse dentro de joins o querys como si fueran una tabla normal.
SELECT *
FROM CUENTAS
Las funciones en línea de múltiples sentencias son similares a las funciones en línea excepto que el
conjunto de resultados que devuelven puede estar compuesto por la ejecución de varias consultas
SELECT.
Este tipo de función se usa en situaciones donde se requiere una mayor lógica de proceso.
-- Lista de parámetros
RETURNS
AS
BEGIN
RETURN
END
El siguiente ejemplo muestra el uso de una función de tabla de multi sentencias.
* de estas cuentas
*/
NumCuenta varchar(20),
Saldo decimal(10,2),
Saldo_anterior decimal(10,2),
Saldo_posterior decimal(10,2),
Importe_Movimiento decimal(10,2),
FxMovimiento datetime
AS
BEGIN
@numcuenta varchar(20),
@saldo decimal(10,2)
FROM CUENTAS
OPEN CDATOS
-- Recorremos el cursor
WHILE (@@FETCH_STATUS = 0)
BEGIN
(NumCuenta, Saldo)
VALUES
(@numcuenta, @saldo)
(Saldo_anterior, Saldo_posterior,
Importe_Movimiento, FxMovimiento )
SELECT TOP 3
SALDO_ANTERIOR, SALDO_POSTERIOR,
IMPORTE, FXMOVIMIENTO
FROM MOVIMIENTOS
END
CLOSE CDATOS;
DEALLOCATE CDATOS;
RETURN
END
Cast y Convert
Convierten una expresión de un tipo de datos en otro de forma explícita. CAST y CONVERT
proporcionan funciones similares.
Dónde:
SELECT @fecha
@fechaFormateada varchar(20)
-- 3 => dd/mm/aa
SET @fecha = GETDATE()
SELECT @fechaFormateada
@dato2 int
SELECT @dato2
Isnull
Evalua una expresion de entrado y si esta es NULL, reemplaza NULL con el valor de reemplazo
especificado. El valor de reemplazo debe ser del mismo tipo de datos que la expresion a evaluar.
@datoVarchar varchar(100)
COALESCE
Devuelve la primera expresión distinta de NULL entre sus argumentos. Un aspecto a tener en
cuenta es que todos los argumentos deben ser del mismo tipo.
@dato2 int,
@dato3 int,
@dato4 int,
@dato5 int
-- Devuelve 100
SELECT COALESCE(@dato1,@dato2,@dato3,@dato4,@dato5)
GetDate y GetUTCDate
GetDate devuelve la fecha y hora actuales del sistema en el formato interno estándar de SQL
Server 2005 para los valores datetime.
GetUTCDate devuelve el valor datetime que representa la hora UTC (hora universal
coordinada u hora del meridiano de Greenwich) actual.
@fechaUTC datetime
Trigger DML, se ejecutan cuando un usuario intenta modificar datos mediante un evento de
lenguaje de manipulación de datos (DML). Los eventos DML son instrucciones INSERT, UPDATE o
DELETE de una tabla o vista.
Trigger DDL, se ejecutan en respuesta a una variedad de eventos de lenguaje de definición de
datos (DDL). Estos eventos corresponden principalmente a instrucciones CREATE, ALTER y DROP
de Transact-SQL, y a determinados procedimientos almacenados del sistema que ejecutan
operaciones de tipo DDL.
Trigger DML.
Los trigger DML se ejecutan cuando un usuario intenta modificar datos mediante un evento de lenguaje
de manipulación de datos (DML). Los eventos DML son instrucciones INSERT, UPDATE o DELETE de una
tabla o vista.
AS
BEGIN
END
Las instrucciones de triggers DML utilizan dos tablas especiales denominadas inserted y deleted. SQL
Server 2005 crea y administra automáticamente ambas tablas. La estructura de las tablas inserted y
deleted es la misma que tiene la tabla que ha desencadenado la ejecución del trigger.
La primera tabla (inserted) solo está disponible en las operaciones INSERT y UPDATE y en ella están
los valores resultantes despues de la inserción o actualización. Es decir, los datos insertados. Inserted
estará vacia en una operación DELETE.
En la segunda (deleted), disponible en las operaciones UPDATE y DELETE, están los valores anteriores
a la ejecución de la actualización o borrado. Es decir, los datos que serán borrados. Deleted estará vacia
en una operacion INSERT.
¿No existe una tabla UPDATED? No, hacer una actualización es lo mismo que borrar (deleted) e
insertar los nuevos (inserted). La sentencia UPDATE es la única en la que inserted y deleted tienen
datos simultaneamente.
El siguiente ejemplo, graba un histórico de saldos cada vez que se modifica un saldo de la tabla
cuentas.
ON CUENTAS
AFTER UPDATE
AS
BEGIN
FROM INSERTED
END
La siguiente instrucción provocará que el trigger se ejecute:
UPDATE CUENTAS
WHERE IDCUENTA = 1
Una consideración a tener en cuenta es que el trigger se ejecutará aunque la instruccion DML (UPDATE,
INSERT o DELETE ) no haya afectado a ninguna fila. En este caso inserted y deleted devolveran un
conjunto de datos vacio.
ON CUENTAS
AFTER UPDATE
AS
BEGIN
BEGIN
FROM INSERTED
END
END
Los trigger están dentro de la transacción original (Insert, Delete o Update) por lo cual si dentro de
nuestro trigger hacemos un RollBack Tran, no solo estaremos echando atrás nuestro trigger sino también
toda la transacción; en otras palabras si en un trigger ponemos un RollBack Tran, la transacción de Insert,
Delete o Update volverá toda hacia atrás.
ON CUENTAS
AFTER UPDATE
AS
BEGIN
FROM INSERTED
ROLLBACK
END
En este caso obtendremos el siguiente mensaje de error:
GO
GO
GO
Los trigger DDL se ejecutan en respuesta a una variedad de eventos de lenguaje de definición de datos
(DDL). Estos eventos corresponden principalmente a instrucciones CREATE, ALTER y DROP de Transact-
SQL, y a determinados procedimientos almacenados del sistema que ejecutan operaciones de tipo DDL.
ON DATABASE
AS
BEGIN
...
END
La siguiente instrucción impide que se ejecuten sentencias DROP TABLE y ALTER TABLE en la base de
datos.
AS
BEGIN
ROLLBACK TRANSACTION
END
Cursores en Transact SQL
Un cursor es una variable que nos permite recorrer con un conjunto de resultados obtenido a
través de una sentencia SELECT fila a fila.
FOR
<sentencia_sql>
OPEN <nombre_cursor>
WHILE (@@FETCH_STATUS = 0)
BEGIN
...
END -- Fin del bucle WHILE
-- Cierra el cursor
CLOSE <nombre_cursor>
DEALLOCATE <nombre_cursor>
@Nombre varchar(255),
@Apellido1 varchar(255),
@Apellido2 varchar(255),
@NifCif varchar(20),
@FxNacimiento datetime
FROM CLIENTES
OPEN cClientes
BEGIN
END
CLOSE cClientes
DEALLOCATE cClientes
Valor
Descripción
devuelto
0 La instrucción FETCH se ejecutó correctamente.
La instrucción FETCH no se ejecutó correctamente o la fila estaba más allá del
-1
conjunto de resultados.
-2 Falta la fila recuperada.
En la apertura del cursor, podemos especificar los siguientes parámetros:
[ LOCAL | GLOBAL ]
[ FORWARD_ONLY | SCROLL ]
[ TYPE_WARNING ]
FOR <sentencia_sql>
LOCAL
Específica que el ámbito del cursor es local para el proceso por lotes, procedimiento almacenado o
desencadenador en que se creó el cursor.
FROM CLIENTES
GLOBAL
Especifica que el ámbito del cursor es global para la conexión. Puede hacerse referencia al nombre
del cursor en cualquier procedimiento almacenado o proceso por lotes que se ejecute en la conexión.
FROM CLIENTES
FORWARD_ONLY
Especifica que el cursor sólo se puede desplazar de la primera a la última fila. FETCH NEXT es la
única opción de recuperación admitida.
FROM CLIENTES
SCROLL
Especifica que están disponibles todas las opciones de recuperación (FIRST, LAST, PRIOR, NEXT,
RELATIVE, ABSOLUTE). Si no se especifica SCROLL en una instrucción DECLARE CURSOR la única
opción de recuperación que se admite es NEXT. No es posible especificar SCROLL si se incluye
también FAST_FORWARD.
Si se incluye la opción SCROLL, la forma en la realizamos la lectura del cursor varia, debiendo utilizar
la siguiente sintaxis: FETCH [ NEXT | PRIOR | FIRST | LAST | RELATIVE | ABSOLUTE ] FROM < INTO
@Nombre varchar(255),
@Apellido1 varchar(255),
@Apellido2 varchar(255),
@NifCif varchar(20),
@FxNacimiento datetime
FROM CLIENTES
OPEN cClientes
WHILE (@@FETCH_STATUS = 0 )
BEGIN
INTO @id,@Nombre,@Apellido1,@Apellido2,@NifCif,@FxNacimiento
END
CLOSE cClientes
DEALLOCATE cClientes
FROM CLIENTES
KEYSET
Especifica que la pertenencia y el orden de las filas del cursor se fijan cuando se abre el cursor. El
conjunto de claves que identifica las filas de forma única está integrado en la tabla denominada
keyset de tempdb.
FROM CLIENTES
DYNAMIC
Define un cursor que, al desplazarse por él, refleja en su conjunto de resultados todos los cambios
realizados en los datos de las filas. Los valores de los datos, el orden y la pertenencia de las filas
pueden cambiar en cada operación de recuperación. La opción de recuperación ABSOLUTE no se
puede utilizar en los cursores dinámicos.
FROM CLIENTES
FAST_FORWARD
Especifica un cursor FORWARD_ONLY, READ_ONLY con las optimizaciones de rendimiento
habilitadas. No se puede especificar FAST_FORWARD si se especifica también SCROLL o
FOR_UPDATE.
FROM CLIENTES
READ_ONLY
Evita que se efectúen actualizaciones a través de este cursor. No es posible hacer referencia al cursor
en una cláusula WHERE CURRENT OF de una instrucción UPDATE o DELETE. Esta opción reemplaza
la capacidad de actualizar el cursor.
FROM CLIENTES
SCROLL_LOCKS
Especifica que se garantiza que las actualizaciones o eliminaciones posicionadas realizadas a través
del cursor serán correctas. Microsoft SQL Server bloquea las filas cuando se leen en el cursor para
garantizar que estarán disponibles para futuras modificaciones. No es posible especificar
SCROLL_LOCKS si se especifica también FAST_FORWARD o STATIC.
FROM CLIENTES
OPTIMISTIC
Especifica que las actualizaciones o eliminaciones posicionadas realizadas a través del cursor no se
realizarán correctamente si la fila se ha actualizado después de ser leída en el cursor. SQL Server no
bloquea las filas al leerlas en el cursor. En su lugar, utiliza comparaciones de valores de columna
timestamp o un valor de suma de comprobación si la tabla no tiene columnas timestamp, para
determinar si la fila se ha modificado después de leerla en el cursor. Si la fila se ha modificado, el
intento de actualización o eliminación posicionada genera un error. No es posible especificar
OPTIMISTIC si se especifica también FAST_FORWARD.
FROM CLIENTES
TYPE_WARNING
Especifica que se envía un mensaje de advertencia al cliente si el cursor se convierte implícitamente
del tipo solicitado a otro.
FROM CLIENTES
Para actualizar los datos de un cursor debemos especificar FOR UPDATE despues de la sentencia
SELECT en la declaración del cursor, y WHERE CURRENT OF <nombre_cursor> en la sentencia
UPDATE tal y como muestra el siguiente ejemplo.
@Nombre varchar(255),
@Apellido1 varchar(255),
@Apellido2 varchar(255),
@NifCif varchar(20),
@FxNacimiento datetime
FROM CLIENTES
FOR UPDATE
OPEN cClientes
FETCH cClientes
INTO @id, @Nombre, @Apellido1, @Apellido2, @NifCif, @FxNacimiento
WHILE (@@FETCH_STATUS = 0 )
BEGIN
UPDATE Clientes
SET APELLIDO2 = isnull(@Apellido2,'') + ' - Modificado'
FETCH cClientes
INTO @id, @Nombre, @Apellido1, @Apellido2,
@NifCif, @FxNacimiento
END
CLOSE cClientes
DEALLOCATE cClientes
SQL dinámico en Transact SQL
Transact SQL permite dos formas de ejecutar SQL dinámico (construir sentencias SQL
dinámicamente para ejecutarlas en la base de datos):
La instrucción EXECUTE
La instrucción EXECUTE - o simplemente EXEC - permite ejecutar una cadena de caracteres que
representa una sentencia SQL. La cadena de caracteres debe ser de tipo nvarchar .
El siguiente ejemplo muestra como ejecutar una cadena de caracteres con la instrucción EXEC.
COD_PAIS,
NOMBRE_PAIS,
ACTIVO,
FX_ALTA
FROM
PAISES'
EXEC (@sql)
También con SQL dinámico podemos ejecutar sentencias de tipo DDL (Data Definition
Languaje), como CREATE TABLE.
EXEC (@sql)
EXEC (@sql)
Para solventar el problema debemos trabajar siempre con sq_executesql, que permite el uso
de parametros y con el que obtendremos un mejor rendimiento de nuestras consultas.
COD_PAIS,
NOMBRE_PAIS,
ACTIVO,
FX_ALTA
FROM
PAISES'
@paramDefinition nvarchar(255),
@paramValue char(3)
COD_PAIS,
NOMBRE_PAIS,
ACTIVO,
FX_ALTA
FROM
PAISES
En muchas ocasiones es necesario poder obtener una columna con el número de registro o también
poder generar un ranking. Hasta SQL2000 este tipo de operaciones no eran tan simples de realizar y
no disponíamos de instrucciones directas. En TSQL 2005 disponemos de una serie de instrucciones
las cuales nos hacen el trabajo mucho más simple y eficiente. Veamos de qué se trata ello.
Row_Number: Esta nueva función de TSQL nos permitirá numerar los resultados de una query.
Use AdventureWorks
Go
order by name
Use AdventureWorks
Go
order by color,name
Este ejemplo nos retornara un listado de productos donde el color sea Blue o Silver y los numerara
con rowid pero al cambiar el color el numerador volverá a comenzar.
TOP @n:
Tsql2005 incorpora una nueva funcionalidad a la instrucción TOP, hasta la versión 2000 no se le
podía pasar un parámetro variable a la misma, en la versión 2005 esta funcionalidad se ha
agregado. El siguiente ejemplo nos muestra cómo se implementa:
USE ADVENTUREWORKS
GO
SET @NUM = 3
En el siguiente ejercicio veremos cómo podemos utilizar TOP @n para eliminar registros de a
grupos:
Use AdventureWorks
Go
GO
GO
DECLARE @N INT
SET @N = 1
BEGIN
SET @N = @N+1
END
GO
SET ROWCOUNT 0
Conclusiones: Sin lugar a dudas que muchos de los desarrolladores y DBA que venimos trabajando
con Sql2000 estábamos reclamando esta funcionalidad del TOP, con la misma como se podrá
observar se pueden lograr muchas funcionalidades que antes se debían resolver quizás con SQL-
Dinámico.
Control de errores:
Tsql 2005 incorpora al control de errores los bloques TRY..CATH. La administración de errores de
esta manera es conocida por los desarrolladores de la actualidad ya que .NET administra de la
misma manera. En esta sección les mostrare varios ejemplos de su utilización. Para poder realizar
estos ejercicios he creado una tabla de prueba
USE ADVENTUREWORKS
GO
GO
CREATE TABLE EMPLEADOS (ID INT PRIMARY KEY, NOMBRE VARCHAR(30) NOT NULL)
GO
En nuestro primer ejemplo veremos como poder capturar un error al intentar realizar una
operación de insert sobre nuestra tabla donde el campo Nombre no admite valores nulos.
BEGIN TRY
END TRY
BEGIN CATCH
END CATCH
Como podemos observar al suceder un error SQL sale a la sección CATCH donde capturamos el
mismo y podemos informar al usuario con algún mensaje. En este ejemplo se hace uso de la función
ERROR_NUMBER() las cual nos retorna el número de error, pero también podríamos hacer uso de
las siguientes funciones:
BEGIN TRY
END TRY
BEGIN CATCH
IF ERROR_NUMBER() = 515
BEGIN
END
BEGIN
END
ELSE
BEGIN
END
END CATCH
En este artículo no hemos tratado como manejar errores cuando existen transacciones de por medio,
pero el manejo de las mismas en sql2005 es mucho más simple y amigable que en la versión 2000. Si
se desea ampliar sobre este tema les recomiendo que lean sobre la función XACT_STATE en sus
libros online (BOL).
MAX para columnas dinámicas:
En sql2005 disponemos de la característica MAX para los tipos de datos VARCHAR, NVARCHAR
y VARBINARY. La idea de esta característica es poder ampliar la capacidad de estos tipos de datos.
En sql2000 estos tipos de datos disponían un máximo de 8000 y 4000 (para los Nvarchar), con MAX
se puede almacenar hasta 2GB de información en estos tipos de datos. La idea seria reemplazar
donde se pueda este tipo de datos por los viejos IMAGE , TEXT y NTEXT.
Use AdventureWorks
Go
go
Go
Go
Conclusiones: Esta nueva capacidad en los tipos de datos Varchar, Nvarchar y Narbinary es mucho
más simple que los viejos Image, Text y Ntext. De todas maneras habrá que analizar bien cuando es
conveniente migrar a este tipo de datos, si la aplicación es nueva yo recomendaría utilizarlos en
lugar de sus pares de la versión 2000.
SET Default y SET NULL (DRI Actions):
SQL Server 2005 Beta2 incluye soporte para dos (2) nuevas DRI actions (Declarative Referential
Integrity). Estas nuevas DRI Actions se utilizaran en las relaciones Foreign Key tanto para UPDATE
como para DELETE.
El siguiente ejemplo nos muestra como usar SET DEFAULT y SET NULL:
Use AdventureWorks
Go
Go
Go
Go
INSERT INTO CLIENTES VALUES ('MICROSOFT','MICROSOFT')
Go
Go
Hasta aquí hemos creados dos(2) tablas, una llamada Clientes y la otra Pedidos, en esta ultima
hemos agregado una relación con la primera y se ha definido que ante una acción de DELETE (en
clientes) se introduzca Null en el campo Cliente_id de Pedidos y ante una acción de UPDATE se
introduzca el valor Default de dicho campo.
GO
Ahora que tenemos los registros en nuestras dos (2) tablas, haremos una acción Delete en Clientes y
observaremos que ha sucedido con esos registros en la tabla Pedidos
GO
Go
numero cliente_id
----------- ----------
1 NULL
2 . . .
..
Como podemos observar el registro (1) que contenía el cliente IBM , ahora el campo de referencia
tiene un valor Null ya que hemos eliminado su maestro de la tabla Clientes y nuestro DRI actions
indicaba que se debía introducir Null.
Ahora veremos que sucede al realizar un Update sobre nuestra tabla Clientes
Go
----------- ----------
1 NULL
2 MICROSOFT
... ...
Como podemos observar el realizar un Update sobre el campo llave de la tabla Clientes, en nuestra
tabla hija (Pedidos) se ha cambiado al valor Default del campo (‘Microsoft’)
Conclusiones: Sin ninguna duda que el agregado de estas dos (2) nuevas funciones de DRI nos
ayudaran considerablemente al momento de realizar nuestras relaciones padres – hijos, que hasta la
versión 2000 realizar este mismo tipo de operatoria como hemos visto en los ejemplos era una tarea
muy incómoda.
DDL Triggers:
En esta sección veremos dos (2) ejemplos sobre estos nuevos tipos de triggers, uno de ellos hará una
auditoria de instrucciones DDL y el otro no permitirá la ejecución de una instrucción ALTER
TABLE
USE ADVENTUREWORKS
GO
ROLLBACK
GO
En este ejemplo hemos creado un trigger DDL en la base de datos AdventureWorks el cual
impedirá que se realicen operaciones ALTER TABLE sobre dicha base de datos.
USE ADVENTUREWORKS
GO
GO
Ahora veremos un ejemplo donde usaremos un DDL trigger para realizar auditorías DDL
USE ADVENTUREWORKS
GO
CREATE TABLE DDL_AUDIT (LSN INT NOT NULL IDENTITY,POSTTIME DATETIME NOT
NULL,
GO
El primer paso ha sido crear una tabla donde registraremos las auditorias DDL.
DECLARE @V AS XML
SET @V = EVENTDATA()
TARGETOBJECTNAME) VALUES (
CAST(@V.query('data(//PostTime)') as varchar(23)),
CAST(@V.query('data(//EventType)') as sysname),
CAST(@V.query('data(//LoginName)') as sysname),
CAST(@V.query('data(//ObjectName)') as sysname),
CAST(@V.query('data(//TargetObjectName)') as sysname))
GO
Este segundo paso es el que genera el trigger DDL el cual registrara en nuestra tabla cada
acontecimiento que suceda.
Ahora solo nos resta por probar el funcionamiento del trigger
GO
Conclusiones: Los DDL triggers son una nueva herramienta muy poderosa de verdad, la cual nos
permitirá desde ahora poder tener control sobre las sentencias DDL como así también poder
realizar auditorías a las mismas.
Conclusiones Generales:
En este artículo hemos visto algunas de las novedades de Sql2005 en lo que respecta a
T-SQL. Aún quedan muchas otras funcionalidades por mostrar pero debo indicar que esta nueva
versión del popular motor de base de datos es muy distinta a su antecesora incorporando
muchas mejoras tanto para el desarrollador como así también para los DBA.