Agrupando sumas mediante particiones en SQL
Cuando el cliente te pide una funcionalidad relacionada con la generación de informes, sabes que vas a tener que enfrentarte a un concepto que, a menudo, provoca verdaderos dolores de cabeza cuando se trata de realizar consultas SQL: los valores agrupados.
No entraremos en detalle en el concepto de agrupación, ya que cualquier manual de SQL le dedica secciones enteras a este concepto. Trataremos un caso particular de agrupación: la agrupación de sumas.
Obtener el identificador de un registro recien insertado en SQL Server
Cuando insertamos un registro en una tabla en la que su Identificador es único y autoincrementable, podemos solicitar a la base de datos que nos devuelva ese ID en concreto para realizar o encadenar nuevas operaciones. Ese ID se obtiene llamando a la función SCOPE_IDENTITY() de T-SQL.
Así, si almacenamos la siguiente sentencia en una cadena de texto:
string sentenciaSQL = "INSERT INTO USUARIOS(Nombre, Apellidos, NIF, Login, Password) VALUES('Alberto' 'Lopez Villarino', '12345678Z', 'alopezv', '7EVASGEAGE9='); SELECT SCOPE_IDENTITY();";
Al invocar al método ExecuteScalar() de un objeto de la clase SqlCommand utilizando la sentencia anterior, el valor devuelto será, precisamente, el ID del registro insertado.
Tratamiento de cadenas en SQL Server
En cualquier lenguaje de programación es tarea obligada poseer una manipulación de cadenas fluida.
Transact SQL proporciona una variedad bastante amplia de funciones para llevar a cabo tal tarea. Algunas de las operaciones que podemos realizar son concatenación, obtención de subcadenas, pasar a mayúsculas o minúsculas, eliminar espacios en blanco… incluso detectar la similitud entre expresiones.
A continuación veremos algunas de ellos y aplicaremos algunos ejemplos:
Eliminar la hora a una fecha en SQL Server 2005
Hay veces que pese a recibir un parámetro en formato fecha que almacene dia y hora, nos interese únicamente almacenar (o recuperar) la parte correspondiente a la fecha.
Aquellos que hayan realizado alguna vez comparaciones de fechas situadas en un intervalo probablemente sepan de qué hablo: ¿Comparar entre un día a las 00:00:00 y el siguiente a las 00:00:00? ¿Entre el mismo día entre las 00:00:00 y las 23:59:59?
Una forma simple de ahorrarnos dolores de cabeza sería almacenar la fecha sin hora. Para ello haremos uso de los distintos formatos de fecha que nos permite promocionar SQL Server y escribiríamos algo así:
UPDATE NombreTabla SET CampoFecha = convert(datetime, convert(varchar(10), CampoFecha, 103))
Con lo cual, almacenaremos nuestra fecha en formato DD:MM:AAAA 00:00:00.
Realizando una transacción en SQL Server
Por norma general, me gusta codificar la lógica de acceso a datos en programa, en lugar de en procedimientos almacenados en base de datos. Esta aproximación no es muy óptima (como se suele decir, al César lo que es del César y a Dios lo que es de Dios), ya que el entorno transaccional estará mejor gestionado por el SGBD que por el código .NET.
Si queremos trasladar la responsabilidad de gestionar la transacción al SGBD, deberemos saber en primer lugar que se declara del siguiente modo:
BEGIN TRAN -- Ejecución de sentencias COMMIT TRAN
Como imaginaremos, la primera sentencia “arranca” la transacción, mientras que la última la compromete. Pero ¿y si ocurre un error en alguna de las sentencias? ¿Cómo lo detectamos?
En el siguiente ejemplo, utilizaremos variables enteras para trazar los fallos y realizar un ROLLBACK en el caso de que la transacción falle.
Se declarará una variable de tipo INT por cada sentencia a ejecutar, y se inician a 0. Se comprueba, después de cada sentencia ejecutada, la variable @@Error, y se almacena en las variables anteriormente creadas. Si es distinta de 0, hay un error, por lo que se añade información al mensaje de error.
Al final de la transacción, si todas las variables son 0, se hace el COMMIT. Si una de ellas es distinta de cero, significará que existe un error y se hace el Rollback, mostrando el mensaje de error.
DECLARE @CadenaError varchar(1000);
DECLARE @CodigosError varchar(1000);
DECLARE @ErrorSentencia1 int;
DECLARE @ErrorSentencia2 int;
DECLARE @ErrorSentencia3 int;
SET @ErrorSentencia1 = 0;
SET @ErrorSentencia2 = 0;
SET @ErrorSentencia3 = 0;
SET @CadenaError = 'Error al realizar actualización: ';
SET @CodigosError = 'Códigos de error: ';
-- Inicio de la transacción
BEGIN TRAN
-- Primera actualización
UPDATE Usuario SET Nombre = 'Elena' WHERE Nombre = "Helena";
-- Almacenamos el posible código de error
SET @ErrorSentencia1 = @@Error;
IF (@ErrorSentencia1 <> 0)
BEGIN
SET @CadenaError = @CadenaError + 'Actualización 1; '
SET @CodigosError = @CodigosError + CAST(@ErrorSentencia1 AS VARCHAR(10)) + '; ';
END
-- Segunda actualización
UPDATE Perfil SET Nombre = 'Administrador' WHERE Nombre = "Admin";
-- Almacenamos el posible código de error
SET @ErrorSentencia2 = @@Error;
IF (@ErrorSentencia2 <> 0)
BEGIN
SET @CadenaError = @CadenaError + 'Actualización 2; '
SET @CodigosError = @CodigosError + CAST(@ErrorSentencia2 AS VARCHAR(10)) + '; ';
END
-- Tercera actualización
UPDATE UsuarioPerfil SET CodigoUsuario = 1 WHERE CodigoPerfil < 3;
-- Almacenamos el posible código de error
SET @ErrorSentencia3 = @@Error;
IF (@ErrorSentencia3 <> 0)
BEGIN
SET @CadenaError = @CadenaError + 'Actualización 3; '
SET @CodigosError = @CodigosError + CAST(@ErrorSentencia3 AS VARCHAR(10)) + '; ';
END
-- En ausencia de errores, comprometemos la transacción
IF (@ErrorSentencia1 = 0) AND (@ErrorSentencia2 = 0) AND (@ErrorSentencia3 = 0)
BEGIN
COMMIT TRAN;
PRINT('Transacción realizada con éxito');
END
ELSE
BEGIN
ROLLBACK TRAN;
PRINT('Transacción abortada');
PRINT(@CadenaError);
PRINT(@CodigosError);
END
Con todo esto, obtendremos suficiente información (esperemos) como para detectar donde está el fallo.
