Cursor SQL: Guía completa

En esta guía completa aprenderás qué es un cursor sql, cómo funciona, cuándo conviene usarlo, sus ventajas, desventajas y ejemplos prácticos para que puedas aplicarlo en tu trabajo diario.

Cuando trabajamos con bases de datos relacionales, la mayoría de las operaciones se ejecutan de forma conjunta sobre conjuntos de resultados completos. Sin embargo, existen casos donde necesitamos procesar cada registro fila por fila, aplicando lógica personalizada que no puede resolverse fácilmente con una sola sentencia SQL. Es en este escenario donde aparece un recurso fundamental: el cursor o cursores SQL.

¿Qué es un Cursor SQL?

Un cursor SQL es un objeto de la base de datos que permite recorrer un conjunto de resultados registro por registro, de forma secuencial. A diferencia de una consulta normal, donde obtenemos todos los datos de una vez, los cursores SQL permiten acceder a cada fila individualmente para realizar operaciones personalizadas.

En otras palabras, un cursor sql funciona como un “apuntador” que se mueve sobre los resultados de una consulta, permitiéndonos ejecutar acciones específicas en cada paso. Es útil cuando necesitamos lógica iterativa dentro de SQL Server u otros motores de base de datos.

¿Para qué sirve un Cursor SQL?

Los cursores SQL son ideales cuando debemos realizar tareas que no se pueden ejecutar con sentencias SQL tradicionales. Algunos usos comunes incluyen:

1. Aplicar lógica compleja a cada fila

Por ejemplo:

• Calcular valores dependientes de resultados previos.
• Validar información antes de actualizarla o eliminarla.
• Aplicar reglas avanzadas que requieren condiciones dinámicas.

2. Procesar datos de forma secuencial

Cuando el orden es importante, como:

• Numeración personalizada.
• Procesamiento por lotes.
• Auditorías avanzadas.

3. Ejecutar procedimientos sobre cada registro

Por ejemplo:

• Enviar un correo por cada cliente.
• Registrar movimientos individuales.
• Generar documentos por fila.

4. Migraciones o transformaciones de datos

Cuando se requiere un control total sobre cada dato migrado.

En resumen, un cursor sql permite convertir una operación global en una operación controlada, secuencial y con lógica específica.

Estructura básica de un Cursor SQL

Un cursor sigue siempre esta estructura general:

1. Declararlo
2. Abrirlo
3. Leer la primera fila
4. Recorrer fila por fila
5. Cerrar el cursor
6. Liberar recursos

Ejemplo conceptual:

DECLARE cursor_name CURSOR FOR
SELECT columnas FROM tabla;

OPEN cursor_name;

FETCH NEXT FROM cursor_name INTO @variables;

WHILE @@FETCH_STATUS = 0
BEGIN

    -- Lógica a ejecutar por cada fila

    FETCH NEXT FROM cursor_name INTO @variables;
END;

CLOSE cursor_name;
DEALLOCATE cursor_name;

Esta secuencia se aplica prácticamente en cualquier motor SQL.

Ejemplo completo de Cursor en SQL Server

Aquí tienes un ejemplo real utilizando cursores SQL para actualizar el saldo de clientes de forma secuencial:

DECLARE @ClienteId INT,
        @Saldo DECIMAL(10,2);

DECLARE ActualizarSaldos CURSOR FAST_FORWARD FOR
SELECT ClienteID, Saldo
FROM Clientes
WHERE Estado = 'ACTIVO';

OPEN ActualizarSaldos;

FETCH NEXT FROM ActualizarSaldos INTO @ClienteId, @Saldo;

WHILE @@FETCH_STATUS = 0
BEGIN

    UPDATE Clientes
    SET Saldo = @Saldo + 10
    WHERE ClienteID = @ClienteId;

    FETCH NEXT FROM ActualizarSaldos INTO @ClienteId, @Saldo;
END;

CLOSE ActualizarSaldos;
DEALLOCATE ActualizarSaldos;

Este cursor recorre cada cliente activo y suma 10 a su saldo.

Ejemplo de Cursor SQL Server con Lógica Compleja por Fila

Supongamos que tienes una tabla llamada VentasDiarias, y quieres:

• Revisar las ventas de cada día.
• Calcular un acumulado progresivo dependiente de la fila anterior.
• Validar datos antes de actualizar (ej.: evitar nulos, negativos, etc.).
• Aplicar reglas avanzadas (si detecta valores anómalos, marcarlos).

Tabla de ejemplo

CREATE TABLE VentasDiarias (
    Id INT IDENTITY(1,1) PRIMARY KEY,
    Fecha DATE,
    Monto DECIMAL(10,2),
    Acumulado DECIMAL(10,2),
    Estado VARCHAR(20)
);

Cursor SQL con lógica compleja por fila

DECLARE @Id INT,
        @Fecha DATE,
        @Monto DECIMAL(10,2),
        @AcumuladoAnterior DECIMAL(10,2) = 0,
        @NuevoAcumulado DECIMAL(10,2),
        @Estado VARCHAR(20);

DECLARE CursorVentas CURSOR FOR
SELECT Id, Fecha, ISNULL(Monto,0)
FROM VentasDiarias
ORDER BY Fecha;

OPEN CursorVentas;
FETCH NEXT FROM CursorVentas INTO @Id, @Fecha, @Monto;

WHILE @@FETCH_STATUS = 0
BEGIN

    ---------------------------------------------
    -- VALIDACIONES COMPLEJAS POR FILA
    ---------------------------------------------
    IF @Monto < 0
    BEGIN
        SET @Estado = 'Error';
        SET @NuevoAcumulado = @AcumuladoAnterior;   
    -- No suma valores negativos
    END
    ELSE IF @Monto = 0
    BEGIN
        SET @Estado = 'Sin Datos';
        SET @NuevoAcumulado = @AcumuladoAnterior;
    END
    ELSE
    BEGIN
        SET @Estado = 'OK';
        SET @NuevoAcumulado = @AcumuladoAnterior + @Monto;
    END

    ---------------------------------------------
    -- ACTUALIZAR LA FILA PROCESADA
    ---------------------------------------------
    UPDATE VentasDiarias
    SET Acumulado = @NuevoAcumulado,
        Estado = @Estado
    WHERE Id = @Id;

    ---------------------------------------------
    -- PREPARAR DATOS PARA LA SIGUIENTE FILA
    ---------------------------------------------
    SET @AcumuladoAnterior = @NuevoAcumulado;

    FETCH NEXT FROM CursorVentas INTO @Id, @Fecha, @Monto;
END

CLOSE CursorVentas;
DEALLOCATE CursorVentas;

🔍 ¿Qué hace este cursor?

✔ Recorre cada fila en orden por fecha

✔ Calcula un acumulado progresivo dependiente del valor anterior

✔ Aplica validaciones lógicas:

• Monto negativo → marca “Error”
• Monto 0 → marca “Sin datos”
• Valor válido → recalcula acumulado

✔ Actualiza cada fila según la lógica aplicada

✔ Mantiene variables internas para decisiones dinámicas

Ventajas y deventajas de usar cursores sql

Alternativas para los cursores sql

Muchos desarrolladores los consideran un último recurso: Por eso, antes de usar un cursor sql, siempre se recomienda evaluar si una operación puede resolverse con:

• Funciones de ventana (ROW_NUMBER, LEAD, LAG)
• Operaciones UPDATE, DELETE, INSERT en bloque
• JOINs
• Tablas temporales
• Procedimientos almacenados híbridos

Si no es posible, entonces un SQL cursor es la opción correcta.

Tipos de cursores SQL

Según el motor de base de datos, los cursores pueden clasificarse por:

1. Cursores implícitos

Los maneja el motor automáticamente. Son internos y no requieren declaración del usuario.

2. Cursores explícitos

El programador los declara manualmente, los abre, los recorre y los cierra.

Además, pueden definirse como:

• STATIC: copia los datos en memoria.
• DYNAMIC: mide los cambios en la tabla mientras recorres.
• FAST_FORWARD: cursor sql rápido, de solo lectura y hacia adelante.
• KEYSET: permite ver cambios de tipo UPDATE mientras recorres.

El tipo más usado es FAST_FORWARD por su rapidez y bajo consumo.

Buenas prácticas al usar cursores SQL

Para garantizar el mejor rendimiento:

✔ Usa FAST_FORWARD siempre que sea posible

Es más ligero y rápido.

✔ Procesa la menor cantidad de filas

Filtra todo lo que puedas antes de declarar el cursor.

✔ Evita acciones que bloqueen tablas

Como SELECT sin usar NOLOCK en contexto de solo lectura.

✔ Cierra siempre el cursor

Dejarlo abierto consume recursos innecesarios.

✔ Considera alternativas

Cursores SQL deben ser un recurso de último uso.

¿Cuándo usar un SQL Cursor y cuándo NO

✔ Úsalo cuando:

• Necesitas lógica fila por fila
• Requieres procesar datos con dependencias
• Generas notificaciones o documentos uno por uno

✘ NO lo uses cuando:

Estás en una operación crítica de rendimiento

• Un UPDATE masivo puede resolverlo
• Puedes usar una función de ventana
• Procesas miles o millones de filas

Conclusión: ¿Vale la pena usar cursores SQL?

Los cursores SQL son una herramienta valiosa cuando debemos procesar datos de manera secuencial y con lógica compleja que no puede resolverse con sentencias tradicionales. Son muy útiles en procesos administrativos, migraciones, validaciones avanzadas y generación de datos calculados.

Sin embargo, deben utilizarse con moderación. Un SQL cursor mal aplicado puede afectar el rendimiento, generar bloqueos y ralentizar las consultas. Lo ideal es evaluar siempre alternativas más eficientes antes de recurrir a ellos.

Si entiendes cómo funcionan, cuándo usarlos y las mejores prácticas, los cursores SQL pueden convertirse en un recurso poderoso dentro de tu arsenal como desarrollador o administrador de bases de datos.