Módulo 3: Gestión segura de datos y transacciones

Una base de datos correctamente diseñada todavía necesita operaciones seguras. Los productos cambian de precio, los pacientes actualizan su teléfono, las existencias aumentan y disminuyen, y algunos registros deben retirarse.

Modificar datos es una tarea de mayor riesgo que consultarlos. Una consulta incorrecta puede mostrar un resultado equivocado; una actualización incorrecta puede alterar miles de filas. Una eliminación ejecutada sin cuidado puede destruir información que no se puede reconstruir.

En este módulo aprenderás a trabajar con datos de forma controlada. Antes de ejecutar un cambio, comprobarás qué filas serán afectadas. Cuando varias instrucciones formen una sola operación, las protegerás mediante una transacción.

Principio del módulo: una modificación profesional se prepara, se comprueba, se ejecuta y se verifica. Nunca se lanza a ciegas.

Al completar el módulo serás capaz de:

• Explicar el ciclo CRUD y diferenciar sus cuatro operaciones.
• Insertar uno o varios registros mediante INSERT.
• Utilizar listas explícitas de columnas en las inserciones.
• Aplicar correctamente valores predeterminados y NULL.
• Interpretar errores producidos por restricciones.
• Modificar una o varias columnas mediante UPDATE.
• Utilizar WHERE para dirigir un cambio a filas concretas.
• Eliminar registros específicos mediante DELETE.
• Diferenciar DELETE de DROP TABLE.
• Comprobar el alcance de una modificación antes y después de ejecutarla.
• Respetar el orden de las operaciones cuando existen claves foráneas.
• Explicar el propósito de una transacción.
• Utilizar BEGIN, COMMIT y ROLLBACK.
• Probar operaciones peligrosas sin conservar los cambios.
• Agrupar varias instrucciones como una unidad indivisible.
• Recuperar el estado anterior cuando una operación no debe confirmarse.
• Preparar scripts reproducibles de carga y mantenimiento.
• Crear evidencias claras de una operación confirmada y una revertida.

El proyecto principal será un inventario con historial de movimientos:

inventario.db
├── categorias
├── productos
└── movimientos

categorias ||────o{ productos ||────o{ movimientos

La tabla productos conservará la existencia actual. La tabla movimientos registrará por qué cambió esa existencia.

Una entrada o salida de inventario requerirá dos cambios relacionados:

1. Actualizar la existencia del producto.
2. Registrar el movimiento.

Si una de las dos instrucciones falla, ninguna debe conservarse. Esa necesidad se resolverá mediante una transacción.

Los tiempos son orientativos. Una práctica de modificación puede repetirse en una copia de la base hasta comprender exactamente qué ocurrió.

El ciclo CRUD

Un registro no permanece necesariamente igual desde que se crea.

Ejemplo de un producto:

Se registra
    ↓
Se consulta
    ↓
Se corrige o actualiza
    ↓
Puede retirarse

Las cuatro operaciones se conocen como CRUD:

En CRUD, “Create” significa crear datos mediante INSERT. No debe confundirse con CREATE TABLE, que crea una estructura.

Saber la instrucción no basta. Antes de cambiar datos debes responder:

1. ¿Cuál es la base correcta?
2. ¿Cuál es la tabla correcta?
3. ¿Qué fila o filas deben cambiar?
4. ¿Cuál debe ser el estado final?
5. ¿Qué reglas podrían rechazar el cambio?
6. ¿Hay otras tablas relacionadas?
7. ¿Cómo se comprobará el resultado?
8. ¿Cómo se recuperará el estado anterior si algo sale mal?

Durante las demostraciones utilizarás:

PRAGMA foreign_keys = ON;

CREATE TABLE categorias (
    id INTEGER PRIMARY KEY,
    nombre TEXT NOT NULL UNIQUE
);

CREATE TABLE productos (
    id INTEGER PRIMARY KEY,
    codigo TEXT NOT NULL UNIQUE,
    nombre TEXT NOT NULL,
    precio REAL NOT NULL CHECK (precio > 0),
    stock INTEGER NOT NULL DEFAULT 0 CHECK (stock >= 0),
    activo INTEGER NOT NULL DEFAULT 1 CHECK (activo IN (0, 1)),
    descripcion TEXT,
    categoria_id INTEGER NOT NULL,
    FOREIGN KEY (categoria_id)
        REFERENCES categorias(id)
        ON UPDATE CASCADE
        ON DELETE RESTRICT
);

Carga inicial:

INSERT INTO categorias (id, nombre)
VALUES
    (1, 'Papelería'),
    (2, 'Tecnología'),
    (3, 'Accesorios');

INSERT INTO productos (
    id,
    codigo,
    nombre,
    precio,
    stock,
    descripcion,
    categoria_id
) VALUES
    (1, 'PAP-001', 'Cuaderno profesional', 4.50, 20, 'Cuaderno de 100 páginas', 1),
    (2, 'TEC-010', 'Memoria USB 32 GB', 9.90, 12, NULL, 2),
    (3, 'ACC-006', 'Soporte para teléfono', 7.25, 8, 'Soporte ajustable', 3),
    (4, 'PAP-014', 'Marcador negro', 1.20, 35, NULL, 1);

Conserva una copia de esta base para repetir las prácticas.

Insertar datos profesionalmente

INSERT INTO productos (
    id,
    codigo,
    nombre,
    precio,
    stock,
    descripcion,
    categoria_id
) VALUES (
    5,
    'TEC-021',
    'Teclado compacto',
    24.90,
    6,
    'Teclado con conexión USB',
    2
);

La lista de columnas y la lista de valores deben tener la misma cantidad y el mismo orden.

Evita:

INSERT INTO productos
VALUES (5, 'TEC-021', 'Teclado compacto', 24.90, 6, 1, NULL, 2);

Aunque pueda funcionar si conoces exactamente el orden del esquema, resulta difícil de leer y puede romperse si la estructura cambia.

Prefiere:

INSERT INTO productos (
    id,
    codigo,
    nombre,
    precio,
    stock,
    categoria_id
) VALUES (
    5,
    'TEC-021',
    'Teclado compacto',
    24.90,
    6,
    2
);

Las columnas omitidas utilizarán su valor predeterminado o NULL cuando la estructura lo permita.

En este caso:

• activo recibe 1 por DEFAULT.
• descripcion recibe NULL.

INSERT INTO productos (
    id,
    codigo,
    nombre,
    precio,
    stock,
    categoria_id
) VALUES
    (6, 'PAP-020', 'Carpeta azul', 2.10, 18, 1),
    (7, 'ACC-011', 'Cable organizador', 3.75, 25, 3),
    (8, 'TEC-030', 'Ratón inalámbrico', 16.50, 10, 2);

La inserción múltiple es útil para datos iniciales. Si una fila viola una restricción, la instrucción puede fallar; revisa todo el conjunto antes de ejecutarlo.

Un valor predeterminado se utiliza cuando la columna se omite:

activo INTEGER NOT NULL DEFAULT 1

INSERT INTO productos (
    id,
    codigo,
    nombre,
    precio,
    categoria_id
) VALUES (
    9,
    'PAP-025',
    'Regla de 30 cm',
    1.10,
    1
);

Resultado esperado:

stock  = 0
activo = 1
descripcion = NULL

DEFAULT no se utiliza si proporcionas explícitamente otro valor.

Utiliza NULL si una descripción todavía no existe:

descripcion = NULL

No utilices NULL para evitar investigar datos obligatorios como código, nombre o categoría.

1. Insertar categoría.
2. Insertar producto que la referencia.

Una fila hija no puede hacer referencia a una fila padre inexistente.

Incorrecto:

INSERT INTO productos (
    id,
    codigo,
    nombre,
    precio,
    stock,
    categoria_id
) VALUES (
    10,
    'MOB-001',
    'Silla ergonómica',
    85.00,
    2,
    99
);

Si no existe la categoría 99 y las claves foráneas están activas, SQLite rechaza la inserción.

Posibles mensajes:

UNIQUE constraint failed
NOT NULL constraint failed
CHECK constraint failed
FOREIGN KEY constraint failed

No intentes “resolver” el error desactivando la restricción. Busca la causa:

• ¿Se repitió un código?
• ¿Falta un valor obligatorio?
• ¿El precio es inválido?
• ¿La categoría no existe?

Práctica guiada 1 — Inserciones válidas e inválidas

1. Crea una copia de la base de práctica.
2. Inserta el producto con id 5.
3. Comprueba los valores predeterminados.
4. Intenta repetir TEC-021 con otro identificador.
5. Intenta insertar un precio negativo.
6. Intenta utilizar una categoría inexistente.
7. Registra qué restricción rechazó cada caso.
8. Conserva solamente los datos válidos.

Modificar datos con UPDATE

UPDATE productos
SET precio = 5.25
WHERE id = 1;

Lectura:

En la tabla productos,
establece precio en 5.25,
solamente para la fila cuyo id es 1.

Sin WHERE:

UPDATE productos
SET precio = 5.25;

La instrucción modifica el precio de todas las filas.

En este módulo no ejecutarás actualizaciones sin WHERE sobre datos del proyecto.

Paso 1. Describe el cambio

Cambiar el precio del producto con id 1 de 4.50 a 5.25.

Paso 2. Consulta la fila objetivo

SELECT id, codigo, nombre, precio
FROM productos
WHERE id = 1;

Paso 3. Comprueba el identificador

Verifica que el resultado corresponda al producto correcto.

Paso 4. Ejecuta el cambio

UPDATE productos
SET precio = 5.25
WHERE id = 1;

Paso 5. Vuelve a consultar

SELECT id, codigo, nombre, precio
FROM productos
WHERE id = 1;

Paso 6. Comprueba otras filas

Revisa la tabla y confirma que no cambió otro producto.

Consultar → comprobar → actualizar → volver a consultar

UPDATE productos
SET
    precio = 8.50,
    descripcion = 'Soporte metálico ajustable'
WHERE id = 3;

Las asignaciones se separan mediante comas.

UPDATE productos
SET stock = stock + 5
WHERE id = 2;

La expresión toma el valor actual y le suma cinco.

Si el stock era 12, el resultado será 17.

Para una salida:

UPDATE productos
SET stock = stock - 3
WHERE id = 2;

La restricción CHECK (stock >= 0) evita una existencia negativa, pero no sustituye la revisión previa.

UPDATE productos
SET descripcion = NULL
WHERE id = 3;

Solo es válido si la columna permite NULL y la ausencia representa una situación real.

UPDATE productos
SET precio = 12.00
WHERE id = 999;

No siempre aparece un error. Si no existe la fila 999, no se actualiza ninguna fila.

Por eso debes consultar y comprobar antes y después.

Modificar claves primarias no debe ser una operación habitual. Si una relación declara ON UPDATE CASCADE, el cambio puede propagarse. Si utiliza RESTRICT, puede rechazarse.

Los datos descriptivos se actualizan con frecuencia. Las identidades deberían permanecer estables.

Práctica guiada 2 — Corregir un producto

Situación:

El producto ACC-006 conserva el mismo código, pero su nombre correcto es “Soporte metálico para teléfono”, su precio es 8.50 y la descripción anterior ya no es válida.

Realiza:

1. Consulta la fila por su identificador.
2. Confirma el código.
3. Actualiza nombre y precio.
4. Coloca NULL en descripción.
5. Consulta nuevamente.
6. Explica por qué el código no fue modificado.

Eliminar datos con DELETE

DELETE FROM productos
WHERE id = 8;

Elimina la fila cuyo identificador es 8.

DELETE FROM productos;

La instrucción elimina todas las filas de la tabla. La estructura permanece, pero los datos desaparecen.

No la ejecutes sobre el proyecto.

Paso 1. Justifica la eliminación

No elimines un registro solamente porque “ya no se usa”. Puede existir un historial relacionado.

Paso 2. Consulta la fila

SELECT id, codigo, nombre
FROM productos
WHERE id = 8;

Paso 3. Comprueba relaciones

Si existen movimientos del producto, la clave foránea puede impedir la eliminación.

Paso 4. Ejecuta dentro de una transacción

Primero prueba el efecto con ROLLBACK.

Paso 5. Verifica ausencia y estado de las relaciones

SELECT id, codigo, nombre
FROM productos
WHERE id = 8;

DROP TABLE modifica el esquema. DELETE modifica los datos.

Algunos sistemas no borran físicamente un producto. Cambian su estado:

UPDATE productos
SET activo = 0
WHERE id = 8;

Esto se conoce como eliminación lógica o desactivación. Permite conservar historial.

No siempre es la solución correcta. Si la información no necesita conservarse y no tiene dependencias, una eliminación física puede ser válida.

Si un producto tiene movimientos y la relación utiliza ON DELETE RESTRICT, SQLite rechazará la eliminación.

Ese error protege el historial.

No desactives las claves foráneas para forzar el borrado. Decide si corresponde:

• Conservar y desactivar el producto.
• Eliminar primero datos dependientes autorizados.
• Cambiar la regla del modelo mediante una migración planificada.

Práctica guiada 3 — Eliminar o desactivar

Para cada caso, decide entre eliminación física, desactivación o conservación obligatoria:

1. Producto de prueba creado por error y sin movimientos.
2. Producto real retirado de venta con historial de movimientos.
3. Categoría sin productos creada con un nombre equivocado.
4. Paciente con citas históricas.
5. Registro duplicado que nunca fue referenciado.

Justifica cada respuesta antes de escribir SQL.

Transacciones: todo o nada

Una salida de inventario necesita:

1. Reducir el stock.
2. Registrar el movimiento.

Supón que la primera instrucción funciona y la segunda falla:

Stock reducido       ✓
Movimiento registrado ✗

El inventario queda sin explicación. La operación está incompleta.

Una transacción agrupa instrucciones para tratarlas como una unidad.

BEGIN
  instrucción 1
  instrucción 2
  verificación
COMMIT   → conservar todo

o

ROLLBACK → deshacer todo

Transferir dinero implica restar de una cuenta y sumar en otra. No sería aceptable conservar solamente una mitad.

Cuenta A: -100
Cuenta B: +100

Ambos cambios deben confirmarse juntos o deshacerse juntos.

BEGIN TRANSACTION;

Inicia una transacción explícita.

COMMIT;

Confirma los cambios realizados desde BEGIN.

ROLLBACK;

Deshace los cambios no confirmados de la transacción.

Estado inicial:

SELECT id, nombre, stock
FROM productos
WHERE id = 2;

Transacción de prueba:

BEGIN TRANSACTION;

UPDATE productos
SET stock = stock - 3
WHERE id = 2;

SELECT id, nombre, stock
FROM productos
WHERE id = 2;

ROLLBACK;

Consulta final:

SELECT id, nombre, stock
FROM productos
WHERE id = 2;

Durante la transacción observarás el valor reducido. Después de ROLLBACK, el stock regresará al valor inicial.

BEGIN TRANSACTION;

UPDATE productos
SET stock = stock + 5
WHERE id = 2;

SELECT id, nombre, stock
FROM productos
WHERE id = 2;

COMMIT;

Después de COMMIT, el nuevo valor permanece.

Primero crea la tabla de movimientos en una base de práctica:

CREATE TABLE movimientos (
    id INTEGER PRIMARY KEY,
    producto_id INTEGER NOT NULL,
    tipo TEXT NOT NULL
        CHECK (tipo IN ('ENTRADA', 'SALIDA', 'AJUSTE')),
    cantidad INTEGER NOT NULL CHECK (cantidad > 0),
    stock_anterior INTEGER NOT NULL CHECK (stock_anterior >= 0),
    stock_nuevo INTEGER NOT NULL CHECK (stock_nuevo >= 0),
    fecha TEXT NOT NULL,
    motivo TEXT NOT NULL,
    FOREIGN KEY (producto_id)
        REFERENCES productos(id)
        ON DELETE RESTRICT
);

Salida de tres unidades del producto 2, cuyo stock inicial es 12:

BEGIN TRANSACTION;

UPDATE productos
SET stock = stock - 3
WHERE id = 2;

INSERT INTO movimientos (
    id,
    producto_id,
    tipo,
    cantidad,
    stock_anterior,
    stock_nuevo,
    fecha,
    motivo
) VALUES (
    1,
    2,
    'SALIDA',
    3,
    12,
    9,
    '2026-08-02 10:30',
    'Entrega de pedido interno'
);

SELECT id, nombre, stock
FROM productos
WHERE id = 2;

SELECT *
FROM movimientos
WHERE id = 1;

COMMIT;

Las dos instrucciones se conservan juntas.

1. No ejecutes COMMIT.
2. Lee el mensaje de error.
3. Ejecuta ROLLBACK si la transacción continúa abierta.
4. Consulta el estado final.
5. Corrige la causa.
6. Inicia una transacción nueva.

No intentes continuar agregando instrucciones al azar.

Las restricciones y las transacciones cumplen funciones diferentes:

Necesitas ambas.

Atomicidad

La operación se completa entera o no se conserva.

Consistencia

Las reglas de integridad deben seguir cumpliéndose.

Aislamiento

Las operaciones simultáneas no deberían mezclarse de forma incorrecta. El estudio detallado de concurrencia queda fuera de este módulo.

Durabilidad

Después de confirmar, los cambios deben permanecer incluso si el programa termina.

DB Browser puede mantener cambios pendientes mediante sus botones Write Changes y Revert Changes. Cuando utilices BEGIN, COMMIT y ROLLBACK explícitos:

1. Guarda o revierte cualquier cambio pendiente antes de comenzar.
2. Ejecuta el bloque desde BEGIN hasta COMMIT o ROLLBACK.
3. No ejecutes un segundo BEGIN dentro de una transacción abierta.
4. Si aparece “cannot start a transaction within a transaction”, termina o revierte la transacción pendiente y vuelve a empezar.
5. Cierra siempre una transacción con COMMIT o ROLLBACK.

Propósito: reforzar por qué una transacción agrupa cambios y cómo se confirman o revierten.

Práctica guiada 4 — Confirmar y revertir

1. Consulta el stock del producto 4.
2. Inicia una transacción.
3. Suma diez unidades.
4. Consulta el valor dentro de la transacción.
5. Ejecuta ROLLBACK.
6. Comprueba que el valor original regresó.
7. Repite la operación.
8. Esta vez utiliza COMMIT.
9. Comprueba que el nuevo valor permaneció.
10. Explica la diferencia mediante una frase.

Práctica guiada 5 — Recuperar una operación inválida

1. Selecciona un producto con stock menor que 20.
2. Inicia una transacción.
3. Intenta restar 20 unidades.
4. Observa la respuesta de CHECK (stock >= 0).
5. Ejecuta ROLLBACK.
6. Comprueba que el stock original permanece.
7. Corrige la cantidad y repite en una transacción nueva.
8. Confirma solamente si el resultado es válido.

Método COA para cambios seguros

Utiliza esta secuencia en cada modificación manual:

1. IDENTIFICAR
   Base, tabla y objetivo.

2. RESPALDAR
   Trabajar con una copia si el riesgo lo justifica.

3. CONSULTAR
   Mostrar las filas objetivo mediante SELECT.

4. PREDECIR
   Escribir el estado esperado.

5. INICIAR
   BEGIN TRANSACTION.

6. MODIFICAR
   UPDATE, DELETE o varias instrucciones.

7. VERIFICAR
   Consultar dentro de la transacción.

8. DECIDIR
   COMMIT si es correcto; ROLLBACK si no lo es.

9. COMPROBAR
   Consultar nuevamente y revisar integridad.

10. DOCUMENTAR
    Registrar el propósito y resultado.

Para una práctica local sencilla:

1. Asegúrate de que no existan cambios pendientes.
2. Cierra DB Browser.
3. Copia el archivo .db.
4. Nombra la copia con propósito y fecha.

Ejemplo:

inventario_antes_ajuste_2026-08-02.db

Una copia no sustituye una estrategia profesional de respaldo, pero permite recuperar una práctica local.

Organiza el proyecto:

1. Configuración
2. Creación de tablas
3. Datos iniciales
4. Operaciones CRUD demostrativas
5. Transacciones confirmadas
6. Transacciones de prueba revertidas
7. Consultas de comprobación
8. Pruebas inválidas comentadas

Las transacciones demostrativas deben partir de un estado conocido para que sus resultados puedan explicarse.

Utiliza datos inventados. No practiques eliminaciones o modificaciones sobre información personal o sobre una base compartida.

Buenas prácticas y errores frecuentes

La condición puede ser sintácticamente correcta y seleccionar una fila equivocada.

Sin WHERE, todas las filas pueden cambiar o desaparecer.

Dos productos podrían compartir una descripción similar. Para cambios exactos, utiliza una clave única comprobada.

Después de COMMIT, ROLLBACK ya no deshace esa transacción. Verifica primero.

Puede bloquear escrituras o generar confusión sobre qué cambios están pendientes.

Una instrucción puede afectar cero filas y no producir error. Consulta el resultado.

Evitar el error no corrige la relación. Mantén:

PRAGMA foreign_keys = ON;

Analiza si el registro debe conservarse para explicar operaciones pasadas.

El historial y el estado actual quedarían en desacuerdo. Agrupa ambos cambios en una transacción.

Utiliza SQLite o una herramienta compatible. El archivo no es un documento SQL legible.

Videos recomendados del módulo

Tema exacto: operaciones para insertar, modificar y eliminar datos. Momento recomendado: después de estudiar CRUD. Objetivo: reforzar la sintaxis y el riesgo de modificar filas sin una condición adecuada.

Tema exacto: agrupación, confirmación y reversión de cambios. Momento recomendado: antes de construir las transacciones del proyecto. Objetivo: comprender por qué varias instrucciones deben tratarse como una unidad.

Los videos no sustituyen las pruebas. Debes observar el estado de la base antes, durante y después de cada transacción.

Documentación y recursos de lectura

• 📖`INSERT` — documentación oficial de SQLite
• 📖`UPDATE` — documentación oficial de SQLite
• 📖`DELETE` — documentación oficial de SQLite

• 📖Transacciones — documentación oficial de SQLite
• 📖Claves foráneas — documentación oficial de SQLite
• 📖Restricciones de `CREATE TABLE` — documentación oficial de SQLite

La documentación muestra variantes más avanzadas que no son necesarias en este módulo. Concéntrate en:

• INSERT ... VALUES.
• UPDATE ... SET ... WHERE.
• DELETE FROM ... WHERE.
• BEGIN, COMMIT y ROLLBACK.

Glosario

Resumen del módulo

CRUD representa las operaciones fundamentales sobre los datos:

Create → INSERT
Read   → SELECT
Update → UPDATE
Delete → DELETE

Una actualización o eliminación segura utiliza una condición y se verifica:

SELECT previo
    ↓
BEGIN TRANSACTION
    ↓
UPDATE o DELETE
    ↓
SELECT de verificación
    ↓
COMMIT o ROLLBACK

COMMIT conserva los cambios. ROLLBACK recupera el estado anterior mientras la transacción no haya sido confirmada.

Las transacciones evitan operaciones parciales, pero no reemplazan las restricciones. Una base profesional combina claves, CHECK, NOT NULL, integridad referencial y transacciones.

Ahora puedes:

• Insertar datos respetando columnas, tipos y relaciones.
• Interpretar errores de integridad.
• Corregir registros mediante actualizaciones dirigidas.
• Eliminar filas específicas mediante un procedimiento seguro.
• Decidir cuándo conservar historial mediante desactivación.
• Actualizar valores a partir de su estado actual.
• Crear y verificar transacciones.
• Confirmar operaciones válidas.
• Revertir pruebas o cambios incorrectos.
• Proteger operaciones compuestas contra estados parciales.
• Documentar el estado anterior y posterior de una modificación.

Comprueba que puedes explicar y demostrar:

• La diferencia entre CREATE TABLE y Create dentro de CRUD.
• Por qué las inserciones deben declarar columnas.
• Qué ocurre si un UPDATE no contiene WHERE.
• Qué diferencia existe entre DELETE y DROP TABLE.
• Cuándo conviene desactivar en lugar de eliminar.
• Por qué debes consultar antes y después de modificar.
• Qué diferencia existe entre una restricción y una transacción.
• Cuándo utilizar COMMIT.
• Cuándo utilizar ROLLBACK.
• Por qué un cambio confirmado no se deshace con un ROLLBACK posterior.
• Cómo impedir que el stock cambie sin registrar el movimiento.

No continúes con el Módulo 4 hasta que el proyecto de inventario haya sido aprobado. El siguiente módulo se concentrará en convertir preguntas reales en consultas, filtros, expresiones, funciones y resúmenes de información.