SQL Server permite a los desarrolladores almacenar, recuperar y manipular datos utilizando el lenguaje SQL. Sin embargo, a medida que los scripts y los procedimientos almacenados se vuelven más complejos, puede resultar desafiante gestionar y manipular datos sin variables.

Sin variables, los desarrolladores pueden necesitar repetir consultas o cálculos complejos varias veces dentro de un script, lo que resulta en un código inflado y difícil de leer propenso a errores. Además, no utilizar variables puede dificultar el manejo efectivo de errores, ya que los desarrolladores pueden necesitar repetir el mismo código de manejo de errores varias veces dentro de un script. Esto puede resultar en un código difícil de mantener y dificulta la identificación y corrección de errores cuando ocurren.

En este tutorial, discutiremos el concepto de usar variables en SQL Server, junto con varios ejemplos para demostrar su uso.

Declarando una Variable SQL Individual

La sintaxis T-SQL para declarar una variable en SQL Server es la siguiente:

DECLARE @nombre_variable tipo_de_dato [= valor];

Por ejemplo, declaremos una variable llamada @ProductID de tipo de dato entero y asignemos un valor estático de 778:

DECLARE @ProductID int = 778;

SELECT [SalesOrderID], [CarrierTrackingNumber], [OrderQty], [ProductID], [SpecialOfferID], [UnitPrice], [LineTotal]
FROM [AdventureWorks2019].[Sales].[SalesOrderDetail]
WHERE ProductID = @ProductID;

También puedes asignar el valor más tarde utilizando la palabra clave SET:

DECLARE @ProductID int;

SET @ProductID = 778;

SELECT [SalesOrderID], [CarrierTrackingNumber], [OrderQty], [ProductID], [SpecialOfferID], [UnitPrice], [LineTotal]
FROM [AdventureWorks2019].[Sales].[SalesOrderDetail]
WHERE ProductID = @ProductID;

Puedes usar variables con diferentes tipos de datos, como caracteres, fechas y decimales:

DECLARE @employee_name VARCHAR(50);
SET @employee_name = 'Rajendra';

DECLARE @current_date DATE = GETDATE();

DECLARE @tax_rate DECIMAL(4,2);
SET @tax_rate = 0.04;

Declarando Múltiples Variables en SQL Server

Para declarar múltiples variables, puedes usar diferentes palabras clave DECLARE:

DECLARE @Nombre varchar(50);
DECLARE @Edad tinyint;
DECLARE @DOJ int;

Alternativamente, puedes usar una sola palabra clave DECLARE y separar múltiples variables con una coma:

DECLARE @Nombre varchar(50), @Edad tinyint, @DOJ int;

Asignando Valores Dinámicos a Variables

Puedes establecer el valor de una variable de forma dinámica. Por ejemplo, el siguiente código declara tres variables, @AvgUnitPrice, @AvgOrderQty y @AvgLineTotal. La instrucción SELECT calcula el precio unitario promedio, la cantidad de pedido promedio y el total de línea promedio, y asigna estos valores calculados a las variables:

DECLARE @AvgUnitPrice int, @AvgOrderQty int, @AvgLineTotal int;

SELECT @AvgUnitPrice = Avg(UnitPrice), @AvgOrderQty = Avg(OrderQty), @AvgLineTotal = Avg(LineTotal)
FROM [AdventureWorks2019].[Sales].[SalesOrderDetail];

SELECT @AvgUnitPrice as AvgLineTotal, @AvgOrderQty as AvgOrderQty, @AvgLineTotal as AvgLineTotal;

Usando Variables en Procedimientos Almacenados

Las variables en los procedimientos almacenados proporcionan flexibilidad y control sobre la manipulación de datos. Por ejemplo, el siguiente procedimiento almacenado utiliza dos variables, @JobTitle y @BirthDate. El procedimiento almacenado asigna valores a estas variables e imprime la información requerida utilizando estas variables:

CREATE PROCEDURE dbo.GetPersonInfo
    @NationalIDNumber INT
AS
BEGIN
    DECLARE @JobTitle VARCHAR(50);
    DECLARE @BirthDate date;
 
    SELECT @JobTitle = JobTitle, @BirthDate = BirthDate
    FROM [AdventureWorks2019].[HumanResources].[Employee]
    WHERE [NationalIDNumber] = @NationalIDNumber;
 
    -- Utiliza las variables para procesamiento adicional
    PRINT 'Título del trabajo: ' + @JobTitle;
    PRINT 'Fecha de nacimiento: ' + CAST(@BirthDate AS VARCHAR(10));
END;

EXEC GetPersonInfo 295847284;

Usando Variables en Cursores

Las variables se pueden usar en cursores para almacenar y manipular datos. Por ejemplo, la siguiente consulta declara un cursor, SalesOrder_Cursor, y obtiene el número de orden de venta, el total adeudado y el ID del vendedor de la base de datos AdventureWorks2019. El cursor itera a través de los IDs de orden de venta, asigna la información obtenida a las variables @SalesOrderNumber, @TotalDue y @SalesPersonID, e imprime esta información con mensajes específicos:

DECLARE @SalesOrderID int = 71951;
DECLARE @SalesOrderNumber varchar(20);
DECLARE @TotalDue DECIMAL(10, 2);
DECLARE @SalesPersonID varchar(20);

DECLARE SalesOrder_Cursor CURSOR FOR
SELECT SalesOrderNumber, TotalDue, SalesPersonID
FROM [AdventureWorks2019].[Sales].[SalesOrderHeader]
WHERE SalesOrderID >= @SalesOrderID AND SalesPersonID IS NOT NULL;

OPEN SalesOrder_Cursor;

FETCH NEXT FROM SalesOrder_Cursor INTO @SalesOrderNumber, @TotalDue, @SalesPersonID;

WHILE @@FETCH_STATUS = 0
BEGIN
    -- Realiza operaciones utilizando las variables
    PRINT 'ID del vendedor: ' + @SalesPersonID;
    PRINT 'Orden de venta: ' + CAST(@SalesOrderNumber AS VARCHAR(10));
    PRINT 'Total adeudado: ' + CAST(@TotalDue AS VARCHAR(10));

    -- Obtén el siguiente conjunto de datos del cursor
    FETCH NEXT FROM SalesOrder_Cursor INTO @SalesOrderNumber, @TotalDue, @SalesPersonID;
END;

CLOSE SalesOrder_Cursor;
DEALLOCATE SalesOrder_Cursor;

Usando Variables para Crear Declaraciones SQL Dinámicas

Las variables se pueden utilizar para crear declaraciones SQL dinámicas combinando varias partes de las consultas, como nombres de tablas, parámetros y argumentos. Por ejemplo, el siguiente código crea y ejecuta dinámicamente una declaración SQL utilizando el procedimiento almacenado sp_executesql:

DECLARE @table_name VARCHAR(50) = 'SalesOrderHeader';
DECLARE @schema varchar(20) = 'Sales';
DECLARE @SalesOrderID varchar(20) = 71951;
DECLARE @sql_stmt NVARCHAR(MAX);

SET @sql_stmt = 'SELECT * FROM ' + @schema + '.' + QUOTENAME(@table_name) + ' WHERE SalesOrderID =' + @SalesOrderID;

EXEC sp_executesql @sql_stmt;

Usando Variables para Controlar la Ejecución de Bucles

Las variables pueden ayudar a controlar la ejecución de bucles estableciendo condiciones, controlando el contador del bucle y determinando cuándo el bucle debe continuar o salir. Por ejemplo, el siguiente código demuestra un bucle que contiene información sobre un rango de IDs de orden de venta. El bucle comienza desde @SalesOrderIDStart y termina una vez que el valor del ID de orden de venta es igual a @SalesOrderIDEnd. La instrucción SET en el bucle while incrementa el ID de orden de venta en 1:

DECLARE @SalesOrderIDStart INT = 43659, @SalesOrderIDEnd INT = 43759;

WHILE @SalesOrderIDStart <= @SalesOrderIDEnd
BEGIN
    SELECT [AccountNumber], [CustomerID], [SalesPersonID], [TerritoryID], [BillToAddressID], [ShipToAddressID], [ShipMethodID], [CreditCardID], [CreditCardApprovalCode], [TaxAmt], [Freight], [TotalDue]
    FROM [AdventureWorks2019].[Sales].[SalesOrderHeader]
    WHERE SalesOrderID = @SalesOrderIDStart;
    
    SET @SalesOrderIDStart = @SalesOrderIDStart + 1;
END;

Manejo de Errores Utilizando Variables

El manejo de errores es necesario para capturar errores durante la ejecución del código. Por ejemplo, si has definido una clave primaria en la columna ID y alguien intenta insertar un valor duplicado, se produciría un error de violación de clave primaria. El siguiente código utiliza el bloque TRY CATCH para capturar el error debido a la violación de clave primaria. El bloque CATCH asigna el mensaje de error a la variable @ErrorMessage e imprime el mensaje:

CREATE TABLE Employee
(
   ID int PRIMARY KEY,
   First_name varchar(50),
   Country varchar(20)
);

BEGIN TRY
    INSERT INTO Employee Values(1, 'Rajendra', 'India');

    -- Insertar un registro duplicado que generará un error debido a la CLAVE PRIMARIA
    INSERT INTO Employee Values(1, 'Rajendra', 'India');
END TRY

BEGIN CATCH
    -- Declarar variables para almacenar información del error
    DECLARE @ErrorMessage NVARCHAR(MAX);
    SELECT @ErrorMessage = ERROR_MESSAGE();
    PRINT 'Ocurrió un error: ' + @ErrorMessage; 
END CATCH;

Al utilizar variables, puedes manejar errores de manera efectiva y proporcionar mensajes de error apropiados.

Conclusión

Declarar variables en SQL Server permite a los desarrolladores almacenar y manipular datos durante la ejecución de un script o procedimiento almacenado. Las variables son útiles para mantener conjuntos de resultados intermedios, controlar el flujo de trabajo, preparar declaraciones SQL dinámicas y manejar errores. Al utilizar variables de manera efectiva, los desarrolladores pueden escribir un código más eficiente y fácil de mantener.

Última actualización del artículo: 2023-08-16