MENU
  1. Inicio
  2. SQL
  3. Cómo realizar el manejo de errores de manera eficiente con TRY…CATCH en SQL

Cómo realizar el manejo de errores de manera eficiente con TRY…CATCH en SQL

SQL

El manejo de errores es un aspecto crucial en la administración de bases de datos SQL. SQL Server ofrece una estructura TRY…CATCH que permite optimizar el manejo de errores. En este artículo, explicaremos desde los conceptos básicos hasta el uso avanzado de la estructura TRY…CATCH, brindando conocimientos útiles para su aplicación en entornos reales. Abordaremos temas como la clasificación de errores, la gestión de registros, el impacto en el rendimiento y sus soluciones, todo con el objetivo de mejorar la eficiencia en la administración de bases de datos.

Índice

Fundamentos de la estructura TRY…CATCH

La estructura TRY…CATCH es el método básico de manejo de errores en SQL Server. Utilizando esta estructura, es posible ejecutar acciones adecuadas cuando ocurre un error, manteniendo la estabilidad de la base de datos. A continuación, explicaremos cómo usar la estructura básica de TRY…CATCH.

Sintaxis básica de TRY…CATCH

La estructura TRY…CATCH se escribe de la siguiente manera. El bloque TRY contiene el código SQL que podría generar un error, mientras que el bloque CATCH contiene el código que maneja el error si ocurre.

BEGIN TRY
    -- Código SQL que puede generar errores
END TRY
BEGIN CATCH
    -- Manejo de errores
    SELECT 
        ERROR_NUMBER() AS ErrorNumber,
        ERROR_SEVERITY() AS ErrorSeverity,
        ERROR_STATE() AS ErrorState,
        ERROR_PROCEDURE() AS ErrorProcedure,
        ERROR_LINE() AS ErrorLine,
        ERROR_MESSAGE() AS ErrorMessage;
END CATCH;

Funcionamiento de TRY…CATCH

  • Bloque TRY: El código SQL en este bloque se ejecuta. Si no se produce ningún error, se omite el bloque CATCH.
  • Bloque CATCH: Si ocurre un error en el bloque TRY, el control pasa al bloque CATCH, donde se recupera la información del error y se realiza el manejo correspondiente.

Ejemplo básico: Manejo de errores al insertar datos

A continuación, veamos un ejemplo concreto. El siguiente código muestra cómo manejar un error que ocurre al intentar insertar datos en una tabla.

BEGIN TRY
    INSERT INTO Employees (EmployeeID, Name, Position)
    VALUES (1, 'John Doe', 'Manager');
END TRY
BEGIN CATCH
    PRINT 'Ha ocurrido un error';
    SELECT 
        ERROR_NUMBER() AS ErrorNumber,
        ERROR_MESSAGE() AS ErrorMessage;
END CATCH;

En este ejemplo, si ocurre un error durante la ejecución de la sentencia INSERT, se ejecutará el bloque CATCH, mostrando el mensaje de error.

Esto cubre los fundamentos del uso de la estructura TRY…CATCH. A continuación, revisaremos los tipos de errores y cómo abordarlos.

Clasificación de errores y soluciones

En SQL Server pueden ocurrir varios tipos de errores, y cada uno requiere una solución específica. A continuación, describimos los principales tipos de errores y sus soluciones.

Clasificación de errores

Los errores SQL se dividen en las siguientes categorías.

Errores del sistema

Los errores del sistema son aquellos que ocurren a nivel de sistema, como problemas con SQL Server o la falta de recursos del servidor. Estos incluyen la falta de espacio en disco o de memoria.

Errores de la base de datos

Los errores de la base de datos están relacionados con la estructura o configuración de la base de datos. Ejemplos de esto son el acceso a una columna que no existe en una tabla o la violación de una restricción de clave externa.

Errores del usuario

Los errores del usuario ocurren debido a errores de entrada o errores en la sintaxis SQL. Ejemplos incluyen errores gramaticales o incompatibilidad de tipos de datos.

Soluciones para errores

A continuación, se presentan soluciones para los distintos tipos de errores.

Soluciones para errores del sistema

Para los errores del sistema, las siguientes soluciones son efectivas.

  • Monitoreo de recursos: Es crucial monitorear constantemente el uso de recursos del servidor y configurar alertas que se activen ante cualquier anomalía.
  • Planes de respaldo y recuperación: Realizar copias de seguridad periódicas y tener un plan de recuperación en caso de fallos del sistema.

Soluciones para errores de la base de datos

Para los errores de la base de datos, las siguientes soluciones son recomendables.

  • Definición precisa del esquema: Asegurarse de definir correctamente las tablas y columnas, y establecer adecuadamente las claves externas y restricciones.
  • Validación de datos: Implementar reglas de validación al insertar datos para evitar que se almacenen datos incorrectos.

Soluciones para errores del usuario

Para los errores del usuario, las siguientes soluciones son eficaces.

  • Validación de entradas: Validar las entradas del usuario para prevenir ataques de inyección SQL y otros errores.
  • Mensajes de error detallados: Proporcionar mensajes detallados para facilitar la identificación y solución de problemas.

Mejores prácticas para el manejo de errores

  • Manejo de errores consistente: Implementar un manejo de errores consistente para todas las operaciones SQL.
  • Registro de errores: Registrar los detalles de los errores para poder analizarlos posteriormente.

Esto cubre los conceptos básicos sobre la clasificación y manejo de errores. A continuación, explicaremos cómo gestionar los registros de errores.

Gestión de registros

Cuando ocurre un error, es fundamental registrar los detalles para analizarlos posteriormente. Una buena gestión de registros permite una detección temprana de problemas y una rápida respuesta. A continuación, explicamos cómo gestionar los registros de errores.

Importancia de los registros de errores

Los registros de errores son una fuente invaluable de información para identificar y resolver problemas en sistemas y aplicaciones. Son importantes por los siguientes motivos:

  • Seguimiento de problemas: Registran cuándo, dónde y qué tipo de error ocurrió, ayudando a rastrear la causa del problema.
  • Análisis de tendencias: Permiten analizar patrones de errores recurrentes y mejorar el sistema.
  • Auditoría y cumplimiento: Los registros documentan el comportamiento del sistema, útiles para auditorías o cumplimiento de regulaciones.

Métodos para registrar errores

En SQL Server, se pueden utilizar las estructuras TRY…CATCH para registrar los errores. A continuación, se explica cómo hacerlo.

Creación de una tabla de registro de errores

Primero, cree una tabla para almacenar los registros de errores.

CREATE TABLE ErrorLog (
    ErrorLogID INT IDENTITY(1,1) PRIMARY KEY,
    ErrorNumber INT,
    ErrorSeverity INT,
    ErrorState INT,
    ErrorProcedure NVARCHAR(128),
    ErrorLine INT,
    ErrorMessage NVARCHAR(4000),
    ErrorTime DATETIME DEFAULT GETDATE()
);

Script para insertar registros de errores

Luego, cree un script que inserte los datos en la tabla de registros cuando ocurra un error.

BEGIN TRY
    -- Código SQL que puede generar errores
    INSERT INTO Employees (EmployeeID, Name, Position)
    VALUES (1, 'John Doe', 'Manager');
END TRY
BEGIN CATCH
    INSERT INTO ErrorLog (ErrorNumber, ErrorSeverity, ErrorState, ErrorProcedure, ErrorLine, ErrorMessage)
    VALUES (
        ERROR_NUMBER(),
        ERROR_SEVERITY(),
        ERROR_STATE(),
        ERROR_PROCEDURE(),
        ERROR_LINE(),
        ERROR_MESSAGE()
    );
    PRINT 'Ha ocurrido un error y ha sido registrado en el log.';
END CATCH;

Gestión y análisis de registros de errores

Para gestionar de manera eficaz los registros de errores, considere los siguientes puntos clave.

  • Revisión periódica de los registros: Es importante revisar los registros con regularidad para detectar cualquier anomalía.
  • Configuración de alertas: Establezca alertas que notifiquen a los administradores en caso de errores graves.
  • Retención de registros: Archive los registros antiguos y elimínelos cuando sea necesario para mantener el rendimiento de la base de datos.

Uso de herramientas

El uso de herramientas como las siguientes puede mejorar la gestión de registros:

  • SQL Server Management Studio (SSMS): Permite visualizar y gestionar los registros fácilmente.
  • Herramientas de terceros: Ofrecen capacidades avanzadas para analizar y visualizar los registros.

Una gestión adecuada de los registros de errores aumenta la estabilidad y confiabilidad del sistema. A continuación, se explicarán algunos ejemplos prácticos del uso de TRY…CATCH.

Ejemplos prácticos

Se presentan a continuación algunos ejemplos prácticos de manejo de errores utilizando TRY…CATCH, lo que le permitirá comprender cómo implementar el manejo de errores en operaciones SQL diarias.

Manejo de errores al insertar datos

El siguiente ejemplo muestra cómo manejar un error al intentar insertar información de empleados en una tabla, cuando existen datos duplicados.

BEGIN TRY
    INSERT INTO Employees (EmployeeID, Name, Position)
    VALUES (1, 'John Doe', 'Manager');
END TRY
BEGIN CATCH
    INSERT INTO ErrorLog (ErrorNumber, ErrorSeverity, ErrorState, ErrorProcedure, ErrorLine, ErrorMessage)
    VALUES (
        ERROR_NUMBER(),
        ERROR_SEVERITY(),
        ERROR_STATE(),
        ERROR_PROCEDURE(),
        ERROR_LINE(),
        ERROR_MESSAGE()
    );
    PRINT 'Ha ocurrido un error al insertar los datos y ha sido registrado en el log.';
END CATCH;

Este script captura errores como la duplicación de EmployeeID y los registra en la tabla de errores.

Manejo de errores en una transacción

Cuando ocurre un error dentro de una transacción, es necesario realizar un rollback. El siguiente ejemplo muestra cómo manejar una transacción que contiene múltiples operaciones cuando ocurre un error.

BEGIN TRY
    BEGIN TRANSACTION;

    -- Varias operaciones de base de datos
    INSERT INTO Employees (EmployeeID, Name, Position) VALUES (2, 'Jane Smith', 'Developer');
    UPDATE Departments SET Budget = Budget - 1000 WHERE DepartmentID = 1;

    COMMIT TRANSACTION;
END TRY
BEGIN CATCH
    IF @@TRANCOUNT > 0
    BEGIN
        ROLLBACK TRANSACTION;
    END

    INSERT INTO ErrorLog (ErrorNumber, ErrorSeverity, ErrorState, ErrorProcedure, ErrorLine, ErrorMessage)
    VALUES (
        ERROR_NUMBER(),
        ERROR_SEVERITY(),
        ERROR_STATE(),
        ERROR_PROCEDURE(),
        ERROR_LINE(),
        ERROR_MESSAGE()
    );
    PRINT 'Ha ocurrido un error en la transacción y ha sido revertida.';
END CATCH;

Este script realiza un rollback de la transacción si ocurre un error y registra la información en la tabla de errores.

Manejo de errores en procedimientos almacenados

El manejo de errores en procedimientos almacenados también se puede realizar utilizando la estructura TRY…CATCH. A continuación, un ejemplo de cómo manejar errores dentro de un procedimiento almacenado.

CREATE PROCEDURE InsertEmployee
    @EmployeeID INT,
    @Name NVARCHAR(100),
    @Position NVARCHAR(50)
AS
BEGIN
    BEGIN TRY
        INSERT INTO Employees (EmployeeID, Name, Position)
        VALUES (@EmployeeID, @Name, @Position);
    END TRY
    BEGIN CATCH
        INSERT INTO ErrorLog (ErrorNumber, ErrorSeverity, ErrorState, ErrorProcedure, ErrorLine, ErrorMessage)
        VALUES (
            ERROR_NUMBER(),
            ERROR_SEVERITY(),
            ERROR_STATE(),
            ERROR_PROCEDURE(),
            ERROR_LINE(),
            ERROR_MESSAGE()
        );
        PRINT 'Ha ocurrido un error en el procedimiento almacenado y ha sido registrado en el log.';
    END CATCH
END;

Este procedimiento almacenado captura cualquier error que ocurra al insertar información de empleados y lo registra en la tabla de errores.

En un entorno de producción, es importante aplicar estos patrones básicos para mejorar el manejo de errores de manera efectiva. A continuación, explicamos cómo la estructura TRY…CATCH puede afectar el rendimiento y cómo abordarlo.

Impacto en el rendimiento

Al utilizar la estructura TRY…CATCH, es importante considerar su impacto en el rendimiento. Si no se implementa correctamente, puede afectar negativamente el rendimiento del sistema. A continuación, explicamos cómo afecta el rendimiento y cómo mitigar este impacto.

Impacto en el rendimiento

La estructura TRY…CATCH es una herramienta poderosa para el manejo de errores, pero puede afectar el rendimiento en los siguientes aspectos:

Aumento de sobrecarga

El uso excesivo de la estructura TRY…CATCH puede incrementar la sobrecarga del sistema debido a la verificación constante de errores. Esto puede afectar negativamente el rendimiento, especialmente en consultas que se ejecutan con frecuencia.

Rollback de transacciones

Cuando ocurre un error, es necesario realizar un rollback de toda la transacción, lo que puede disminuir el rendimiento, especialmente en transacciones de gran tamaño. El rollback es una operación costosa, por lo que se debe diseñar cuidadosamente.

Medidas para mejorar el rendimiento

Las siguientes medidas pueden ayudar a minimizar el impacto de la estructura TRY…CATCH en el rendimiento:

Ajustar la granularidad del manejo de errores

Es recomendable ajustar la granularidad del bloque TRY…CATCH para reducir la sobrecarga. Limite el bloque TRY al mínimo necesario para realizar la verificación de errores.

BEGIN TRY
    -- Incluir solo las operaciones críticas dentro del bloque TRY
    INSERT INTO Employees (EmployeeID, Name, Position) VALUES (3, 'Alice Johnson', 'Analyst');
END TRY
BEGIN CATCH
    INSERT INTO ErrorLog (ErrorNumber, ErrorSeverity, ErrorState, ErrorProcedure, ErrorLine, ErrorMessage)
    VALUES (
        ERROR_NUMBER(),
        ERROR_SEVERITY(),
        ERROR_STATE(),
        ERROR_PROCEDURE(),
        ERROR_LINE(),
        ERROR_MESSAGE()
    );
    PRINT 'Ha ocurrido un error al insertar y ha sido registrado en el log.';
END CATCH;

Utilizar comprobaciones previas

Realizar comprobaciones previas antes de entrar en el bloque TRY puede evitar errores innecesarios, mejorando el rendimiento.

IF NOT EXISTS (SELECT 1 FROM Employees WHERE EmployeeID = 3)
BEGIN TRY
    INSERT INTO Employees (EmployeeID, Name, Position) VALUES (3, 'Alice Johnson', 'Analyst');
END TRY
BEGIN CATCH
    INSERT INTO ErrorLog (ErrorNumber, ErrorSeverity, ErrorState, ErrorProcedure, ErrorLine, ErrorMessage)
    VALUES (
        ERROR_NUMBER(),
        ERROR_SEVERITY(),
        ERROR_STATE(),
        ERROR_PROCEDURE(),
        ERROR_LINE(),
        ERROR_MESSAGE()
    );
    PRINT 'Ha ocurrido un error al insertar y ha sido registrado en el log.';
END CATCH;

Optimización de transacciones

Minimice el rango de las transacciones para reducir la sobrecarga en caso de rollback. Considere dividir grandes transacciones en transacciones más pequeñas.

Monitoreo del rendimiento

Es fundamental monitorear continuamente el rendimiento del manejo de errores y aplicar medidas correctivas si es necesario. Utilice herramientas de monitoreo de rendimiento de SQL Server y evaluaciones periódicas para garantizar que el manejo de errores no afecte negativamente el sistema.

Estas medidas pueden minimizar el impacto en el rendimiento al utilizar la estructura TRY…CATCH. A continuación, revisaremos ejemplos avanzados y las mejores prácticas para el uso de TRY…CATCH.

Ejemplos avanzados y mejores prácticas

Presentamos algunos ejemplos avanzados y las mejores prácticas para utilizar de manera efectiva la estructura TRY…CATCH. Esto ayudará a mejorar el manejo de errores y a aumentar la estabilidad y confiabilidad del sistema.

Ejemplos avanzados

Integración de múltiples errores

Con TRY…CATCH, es posible manejar múltiples errores diferentes en un solo bloque CATCH, evitando la duplicación de código y manteniendo el código más limpio.

BEGIN TRY
    -- Varias operaciones SQL
    INSERT INTO Employees (EmployeeID, Name, Position) VALUES (4, 'Mark Spencer', 'Sales');
    UPDATE Departments SET Budget = Budget - 500 WHERE DepartmentID = 2;
END TRY
BEGIN CATCH
    DECLARE @ErrorMessage NVARCHAR(4000) = ERROR_MESSAGE();
    DECLARE @ErrorSeverity INT = ERROR_SEVERITY();
    DECLARE @ErrorState INT = ERROR_STATE();

    -- Registro en la tabla de errores
    INSERT INTO ErrorLog (ErrorNumber, ErrorSeverity, ErrorState, ErrorProcedure, ErrorLine, ErrorMessage)
    VALUES (
        ERROR_NUMBER(),
        @ErrorSeverity,
        @ErrorState,
        ERROR_PROCEDURE(),
        ERROR_LINE(),
        @ErrorMessage
    );

    -- Mostrar el mensaje de error
    PRINT 'Ha ocurrido un error: ' + @ErrorMessage;
END CATCH;

Uso de mensajes de error personalizados

Es posible definir mensajes de error personalizados para proporcionar a los usuarios mensajes más claros cuando ocurre un error específico.

BEGIN TRY
    -- Operación que genera un error
    DELETE FROM Employees WHERE EmployeeID = 100;
END TRY
BEGIN CATCH
    DECLARE @ErrorMessage NVARCHAR(4000) = 'El EmployeeID especificado no existe.';
    RAISERROR (@ErrorMessage, 16, 1);

    INSERT INTO ErrorLog (ErrorNumber, ErrorSeverity, ErrorState, ErrorProcedure, ErrorLine, ErrorMessage)
    VALUES (
        ERROR_NUMBER(),
        ERROR_SEVERITY(),
        ERROR_STATE(),
        ERROR_PROCEDURE(),
        ERROR_LINE(),
        @ErrorMessage
    );
END CATCH;

Mejores prácticas

Manejo de errores exhaustivo

Implemente un manejo de errores exhaustivo y consistente para todas las operaciones SQL, adaptando las soluciones según el tipo de error. Esto evitará que errores inesperados afecten el funcionamiento del sistema.

Uso de registros de errores

Es fundamental registrar los detalles de los errores para poder identificarlos y resolverlos más fácilmente. Los registros deben incluir el número de error, la gravedad, el estado, el procedimiento donde ocurrió, la línea y el mensaje de error.

Mejora de las notificaciones a los usuarios

Proporcione notificaciones adecuadas a los usuarios cuando ocurra un error, brindándoles la información necesaria para tomar medidas. Los mensajes de error deben ser claros y evitar detalles técnicos innecesarios.

Revisión y actualización periódica

Revise y actualice el manejo de errores periódicamente. A medida que surgen nuevos errores o cambios en el sistema, asegúrese de mejorar continuamente el código de manejo de errores.

Automatización del manejo de errores

Automatice el proceso de manejo de errores para que el sistema pueda responder de manera automática cuando ocurran errores. Esto incluye la implementación de sistemas de alertas o scripts de reparación automática.

Al seguir estas mejores prácticas, podrá aprovechar al máximo la estructura TRY…CATCH y optimizar el manejo de errores en SQL Server. A continuación, presentamos algunos ejercicios para reforzar lo aprendido.

Ejercicios

Para profundizar en el uso de TRY…CATCH y el manejo de errores, a continuación se presentan algunos ejercicios. Al resolverlos, podrá adquirir habilidades prácticas.

Ejercicio 1: Implementación básica de TRY…CATCH

Modifique el siguiente script SQL utilizando TRY…CATCH para que, en caso de error, se registre en la tabla de errores.

CREATE TABLE Products (
    ProductID INT PRIMARY KEY,
    ProductName NVARCHAR(50),
    Price DECIMAL(10, 2)
);

INSERT INTO Products (ProductID, ProductName, Price)
VALUES (1, 'Laptop', 999.99);

INSERT INTO Products (ProductID, ProductName, Price)
VALUES (1, 'Smartphone', 499.99); -- Aquí ocurre un error

Respuesta sugerida

BEGIN TRY
    INSERT INTO Products (ProductID, ProductName, Price)
    VALUES (1, 'Laptop', 999.99);

    INSERT INTO Products (ProductID, ProductName, Price)
    VALUES (1, 'Smartphone', 499.99); -- Aquí ocurre un error
END TRY
BEGIN CATCH
    INSERT INTO ErrorLog (ErrorNumber, ErrorSeverity, ErrorState, ErrorProcedure, ErrorLine, ErrorMessage)
    VALUES (
        ERROR_NUMBER(),
        ERROR_SEVERITY(),
        ERROR_STATE(),
        ERROR_PROCEDURE(),
        ERROR_LINE(),
        ERROR_MESSAGE()
    );
    PRINT 'Ha ocurrido un error: ' + ERROR_MESSAGE();
END CATCH;

Ejercicio 2: Manejo de errores en transacciones

Modifique el siguiente script SQL utilizando TRY…CATCH para que, si ocurre un error en la transacción, se realice un rollback.

BEGIN TRANSACTION;

UPDATE Inventory SET Quantity = Quantity - 1 WHERE ProductID = 1;
UPDATE Orders SET Status = 'Shipped' WHERE OrderID = 123;

COMMIT;

Respuesta sugerida

BEGIN TRY
    BEGIN TRANSACTION;

    UPDATE Inventory SET Quantity = Quantity - 1 WHERE ProductID = 1;
    UPDATE Orders SET Status = 'Shipped' WHERE OrderID = 123;

    COMMIT TRANSACTION;
END TRY
BEGIN CATCH
    IF @@TRANCOUNT > 0
    BEGIN
        ROLLBACK TRANSACTION;
    END

    INSERT INTO ErrorLog (ErrorNumber, ErrorSeverity, ErrorState, ErrorProcedure, ErrorLine, ErrorMessage)
    VALUES (
        ERROR_NUMBER(),
        ERROR_SEVERITY(),
        ERROR_STATE(),
        ERROR_PROCEDURE(),
        ERROR_LINE(),
        ERROR_MESSAGE()
    );
    PRINT 'Ha ocurrido un error en la transacción y ha sido revertida: ' + ERROR_MESSAGE();
END CATCH;

Ejercicio 3: Manejo de errores en procedimientos almacenados

Modifique el siguiente procedimiento almacenado utilizando TRY…CATCH para que, en caso de error, se registre en la tabla de errores.

CREATE PROCEDURE UpdateProductPrice
    @ProductID INT,
    @NewPrice DECIMAL(10, 2)
AS
BEGIN
    UPDATE Products
    SET Price = @NewPrice
    WHERE ProductID = @ProductID;
END;

Respuesta sugerida

CREATE PROCEDURE UpdateProductPrice
    @ProductID INT,
    @NewPrice DECIMAL(10, 2)
AS
BEGIN
    BEGIN TRY
        UPDATE Products
        SET Price = @NewPrice
        WHERE ProductID = @ProductID;
    END TRY


    BEGIN CATCH
        INSERT INTO ErrorLog (ErrorNumber, ErrorSeverity, ErrorState, ErrorProcedure, ErrorLine, ErrorMessage)
        VALUES (
            ERROR_NUMBER(),
            ERROR_SEVERITY(),
            ERROR_STATE(),
            ERROR_PROCEDURE(),
            ERROR_LINE(),
            ERROR_MESSAGE()
        );
        PRINT 'Ha ocurrido un error en el procedimiento almacenado y ha sido registrado en el log: ' + ERROR_MESSAGE();
    END CATCH
END;

Estos ejercicios le ayudarán a poner en práctica los conocimientos sobre TRY…CATCH y el manejo de errores en SQL Server. A continuación, presentaremos un resumen de lo aprendido.

Resumen

El uso de la estructura TRY…CATCH permite realizar el manejo de errores de manera eficiente en SQL Server. En este artículo, hemos explicado los conceptos básicos de TRY…CATCH, la clasificación de errores y sus soluciones, la gestión de registros de errores, el impacto en el rendimiento y sus medidas correctivas, así como ejemplos avanzados y mejores prácticas. Además, los ejercicios le ayudarán a reforzar estos conceptos.

El manejo de errores es un elemento clave para mantener la estabilidad y confiabilidad del sistema. Implementar un registro adecuado de errores, notificar a los usuarios de manera correcta y asegurarse de tener un manejo de errores consistente permitirá proteger el sistema de errores inesperados y optimizar la operación de la base de datos.

Aproveche estos conocimientos y técnicas para construir sistemas de bases de datos más estables y confiables.

SQL
Manejo de Errores SQL Gestión de Bases de Datos SQL Server optimización del rendimiento Transacciones TRY…CATCH Registro de Errores
Índice