Revisão de Segurança da Migração

--- name: revisao-seguridad-migraciones description: Revisa migraciones de esquema de base de datos (SQL crudo o generado por ORM de Rails, Django, Alembic, Prisma, Knex, Laravel, Flyway) para riesgos de producción antes de que se implementen - DDL que bloquea tablas, reescrituras completas de tablas, pérdida de datos, cambios que rompen el código de la aplicación en ejecución y rutas de rollback faltantes - y propone reescrituras seguras de cero tiempo de inactividad. Úsalo cuando un diff o PR agrega o cambia archivos de migración, cuando el usuario pregunta "¿es segura esta migración?", o antes de implementar cambios de esquema en una base de datos PostgreSQL o MySQL ocupada. --- # Revisión de Seguridad de Migraciones Estás revisando migraciones de esquema de la manera en que un DBA senior cuidadoso lo haría antes de un despliegue de producción. El objetivo es un veredicto claro más SQL concreto y más seguro - no una conferencia genérica sobre bases de datos. ## Archivos en esta habilidad - `scripts/scan_migration.py` - escáner heurístico rápido para sentencias SQL riesgosas - `references/risk-catalog.md` - peligros operación por operación y patrones seguros - `references/expand-contract.md` - mantener el código de la aplicación antiguo y nuevo funcionando durante el despliegue - `templates/review-report.md` - el formato de informe que debes producir - `examples/example-review.md` - una revisión completa trabajada para calibrar tono y profundidad ## Flujo de trabajo ### 1. Encuentra las migraciones en el alcance - Si se revisa una rama o PR: `git diff --name-only origin/main...HEAD` y conserva los archivos bajo las carpetas de migración (`migrations/`, `db/migrate/`, `alembic/versions/`, `prisma/migrations/`, `database/migrations/`, `db/migration/`). - De lo contrario, usa los archivos o SQL que el usuario señaló. - Anota qué migraciones son nuevas versus las que ya se aplicaron en cualquier entorno. Nunca sugieras editar una migración aplicada; propón una nueva migración de seguimiento. ### 2. Establece el contexto Determina, a partir de archivos de configuración, docker-compose, o preguntando al usuario: - Motor y versión principal (por ejemplo, PostgreSQL 15, MySQL 8.0). El comportamiento de bloqueo depende de ello. - Tamaño aproximado y tráfico de escritura de cada tabla afectada. - Cómo funcionan los despliegues: ¿las migraciones se ejecutan antes, durante o después de que el nuevo código se implementa? Si el tamaño o el tráfico son desconocidos, asume que la tabla es grande y activa, y dilo. ### 3. Obtén el SQL real El código del ORM oculta lo que realmente se ejecuta. Renderiza el SQL primero: | Framework | Comando | |-----------|---------| | Django | `python manage.py sqlmigrate <app> <migration>` | | Rails | `rails db:migrate` en una BD de prueba, luego inspecciona el diff de `db/structure.sql` | | Alembic | `alembic upgrade <from>:<to> --sql` | | Prisma | lee `prisma/migrations/<name>/migration.sql` | | Laravel | `php artisan migrate --pretend` | | Knex | ejecuta en una BD de prueba con `DEBUG=knex:query` y copia el SQL registrado | | Flyway / Liquibase | el archivo `.sql` o `liquibase update-sql` | Guarda el SQL renderizado en un archivo temporal si aún no es un archivo `.sql`. ### 4. Ejecuta el escáner ```bash python3 scripts/scan_migration.py --dialect postgres path/to/migration.sql python3 scripts/scan_migration.py --dialect mysql db/*.sql ``` Imprime `archivo:línea [SEVERIDAD] REGLA mensaje` y sale con 1 si existe algún hallazgo HIGH. Trata su salida como pistas, no como el veredicto: usa expresiones regulares, puede omitir SQL dinámico y no puede conocer los tamaños de las tablas. ### 5. Revisa cada sentencia manualmente Para cada sentencia, usa `references/risk-catalog.md` para responder: 1. ¿Qué bloqueo toma y por cuánto tiempo (instantáneo, escaneo de tabla o reescritura completa)? 2. ¿Puede perder o corromper datos? ¿Es intencional y está respaldado? 3. ¿Se pondrá en cola detrás de transacciones largas? ¿Está `lock_timeout` (Postgres) o `lock_wait_timeout` (MySQL) configurado para que falle rápido en lugar de bloquear todo el tráfico? 4. ¿Se ejecuta en una transacción donde no debe (por ejemplo, `CREATE INDEX CONCURRENTLY`)? 5. ¿Los backfills de datos grandes están por lotes y separados del DDL? ### 6. Verifica la compatibilidad de la aplicación Durante un despliegue continuo, el código antiguo y el nuevo se ejecutan al mismo tiempo contra el nuevo esquema. Sigue `references/expand-contract.md`: - Busca en el código base (`rg -n '<nombre_de_columna_o_tabla>'`) cada objeto renombrado, eliminado o con cambio de tipo, incluido SQL crudo, serializadores y consultas analíticas. - Señala cualquier cambio que el código actualmente desplegado no pueda tolerar. ### 7. Verifica la ruta de rollback - ¿Existe una migración de bajada y realmente restaura el estado anterior? - Las eliminaciones y los cambios de tipo con pérdida son unidireccionales: requieren una copia de seguridad o un plan por etapas. ### 8. Escribe el informe Completa `templates/review-report.md` exactamente. Iguala la profundidad de `examples/example-review.md`. Para cada hallazgo HIGH o MEDIUM, proporciona SQL de reemplazo o código de migración que logre el mismo estado final de manera segura, dividido en pasos de despliegue ordenados cuando sea necesario. ## Veredictos - **SEGURO** - sin bloqueos bloqueantes en tablas grandes, sin pérdida de datos, compatible con versiones anteriores. - **SEGURO CON CAMBIOS** - se puede implementar una vez que se apliquen las reescrituras enumeradas. - **INSEGURO** - causaría tiempo de inactividad, pérdida de datos o errores en el código en ejecución tal como está escrito. ## Reglas - Nunca ejecutes migraciones contra bases de datos de producción o compartidas tú mismo. - No modifiques archivos de migración a menos que el usuario lo pida; propón cambios en el informe. - Sé específico: nombra la tabla, el bloqueo y el modo de falla. Omite consejos genéricos. - Si no estás seguro sobre un comportamiento específico de una versión, dilo y sugiere probar en una copia de tamaño de producción con `\timing` / `EXPLAIN` y monitoreo de bloqueos. FILE:references/risk-catalog.md # Catálogo de Riesgos: Operaciones Comunes de Migración Los nombres de bloqueo son de PostgreSQL. ACCESS EXCLUSIVE bloquea todas las lecturas y escrituras; SHARE bloquea escrituras; SHARE UPDATE EXCLUSIVE no bloquea ninguna. ## El problema de la cola de bloqueos (se aplica a todo lo siguiente) Incluso un `ALTER TABLE` "instantáneo" necesita ACCESS EXCLUSIVE brevemente. Si una consulta larga o una sesión inactiva-en-transacción mantiene la tabla, el ALTER espera - y cada nueva consulta se pone en cola detrás de él. Un cambio de 1 ms puede causar una interrupción de varios minutos. Siempre comienza las migraciones riesgosas con: ```sql SET lock_timeout = '5s'; -- falla rápido, reintenta más tarde SET statement_timeout = '15min'; -- límite superior opcional ``` Equivalente en MySQL: `SET SESSION lock_wait_timeout = 5;` (bloqueos de metadatos). ## Operaciones de PostgreSQL | Operación | Riesgo | Patrón seguro | |-----------|--------|---------------| | `CREATE INDEX` | Bloqueo SHARE: escrituras bloqueadas durante toda la construcción | `CREATE INDEX CONCURRENTLY`, fuera de una transacción; en caso de fallo, elimina el índice INVALID y reintenta. Rails: `disable_ddl_transaction!`; Django: `atomic = False` | | `DROP INDEX` | ACCESS EXCLUSIVE | `DROP INDEX CONCURRENTLY` | | `ADD COLUMN` nullable, sin valor predeterminado | Instantáneo | Seguro (aún así configura lock_timeout) | | `ADD COLUMN ... DEFAULT <constante>` | Instantáneo en PG 11+, reescritura antes de 11 | Seguro en 11+ | | `ADD COLUMN ... DEFAULT now()/random()/gen_random_uuid()` | Valor predeterminado volátil: reescritura completa de la tabla | Agrega columna nullable, rellena en lotes, luego establece el valor predeterminado | | `ADD COLUMN ... NOT NULL` sin valor predeterminado | Falla en tabla no vacía | Agrega nullable, rellena, luego aplica NOT NULL (abajo) | | `ALTER COLUMN ... SET NOT NULL` | Escaneo completo bajo ACCESS EXCLUSIVE | `ADD CONSTRAINT c CHECK (col IS NOT NULL) NOT VALID`; `VALIDATE CONSTRAINT c`; luego `SET NOT NULL` (PG 12+ omite el escaneo); elimina `c` | | `ALTER COLUMN ... TYPE` | Generalmente reescritura completa + reconstrucción de índice bajo ACCESS EXCLUSIVE | Seguro solo si es coercible binariamente (varchar(n) a n más grande o a text). De lo contrario, nueva columna + escritura dual + relleno + intercambio | | `ADD FOREIGN KEY` | Bloquea ambas tablas mientras valida todas las filas | `ADD CONSTRAINT ... NOT VALID`, luego `VALIDATE CONSTRAINT` en un paso separado | | `ADD CHECK` | Escaneo bajo ACCESS EXCLUSIVE | Mismo patrón NOT VALID + VALIDATE | | `ADD UNIQUE` / `ADD PRIMARY KEY` | Construye índice bajo bloqueo | `CREATE UNIQUE INDEX CONCURRENTLY idx ...`; luego `ADD CONSTRAINT ... UNIQUE USING INDEX idx` | | `RENAME COLUMN` / `RENAME TO` | Instantáneo, pero rompe el código en ejecución | Expandir/contraer (ver expand-contract.md) | | `DROP COLUMN` | Instantáneo, pero irreversible; el código antiguo que lo selecciona da error | Elimina todas las referencias de código e implementa primero; luego elimina | | `DROP TABLE` / `TRUNCATE` | Pérdida de datos irreversible | Confirma copia de seguridad y cero lectores; considera renombrar a `_deprecated` primero | | `ALTER TYPE ... ADD VALUE` | Nuevo valor inutilizable en la misma transacción; sin transacción antes de PG 12 | Ponlo en su propia migración | | `VACUUM FULL` / `CLUSTER` / `REINDEX` | Reescritura completa bajo ACCESS EXCLUSIVE | `REINDEX CONCURRENTLY` (PG 12+), `pg_repack` para bloat | | `UPDATE` / `DELETE` grande | Bloqueos de fila largos, pico de WAL, retraso de réplica | Lote por clave primaria (1k-10k filas), confirma por lote, ejecuta fuera de la migración DDL | ## Notas de MySQL 8.0 (InnoDB) - Siempre indica el algoritmo para que MySQL dé error en lugar de copiar la tabla silenciosamente: `ALTER TABLE t ADD COLUMN c INT, ALGORITHM=INSTANT;` o `ALTER TABLE t ADD INDEX i (c), ALGORITHM=INPLACE, LOCK=NONE;` - `ADD COLUMN` es INSTANT en 8.0.12+ (última posición) y 8.0.29+ (cualquier posición). - Los cambios de tipo `MODIFY` / `CHANGE COLUMN` usan ALGORITHM=COPY: escrituras bloqueadas. - Para tablas grandes con cambios solo de COPY usa `gh-ost` o `pt-online-schema-change`. - El DDL no es transaccional en MySQL: una migración fallida de múltiples sentencias deja el esquema a medio aplicar. Mantén una sentencia DDL por migración. FILE:references/expand-contract.md # Expandir / Contraer: Cambios de Esquema Compatibles con Versiones Anteriores Durante un despliegue continuo, las versiones de aplicación antiguas y nuevas se ejecutan lado a lado. Si las migraciones se ejecutan antes de que el nuevo código esté activo, el código antiguo debe funcionar con el nuevo esquema. Si se ejecutan después, el nuevo código debe funcionar con el esquema antiguo. Expandir/contraer hace que cada paso sea compatible con ambos. ## Las tres fases 1. **Expandir** - agrega solo estructuras nuevas (columnas, tablas, índices). Nada se elimina o renombra. El código antiguo ignora las adiciones. 2. **Migrar** - implementa código que escribe tanto en las estructuras antiguas como en las nuevas, rellena las filas existentes en lotes, luego cambia las lecturas a la nueva estructura. 3. **Contraer** - una vez que ningún código desplegado toca la estructura antigua, elimínala en una migración separada y posterior. Cada fase es su propio despliegue. Nunca combines expandir y contraer en una sola migración. ## Recetas ### Renombrar una columna (`users.name` a `users.full_name`) 1. Migración: agrega `full_name` nullable. 2. Código: escribe tanto `name` como `full_name`; lee `name`. 3. Rellena `full_name = name` en lotes donde `full_name IS NULL`. 4. Código: lee `full_name`; sigue escribiendo ambos. 5. Código: deja de escribir `name`. (Rails: agrega `name` a `ignored_columns` aquí). 6. Migración: elimina `name`. ### Cambiar el tipo de una columna (`orders.amount` int a numeric) Igual que renombrar: agrega `amount_numeric`, escritura dual, relleno, cambia lecturas, elimina la antigua. Un disparador puede manejar escrituras duales si los cambios de aplicación son difíciles. ### Hacer una columna NOT NULL 1. Código: siempre escribe un valor. 2. Rellena las filas NULL en lotes. 3. Migración: CHECK ... NOT VALID, VALIDATE, SET NOT NULL (ver risk-catalog.md). ### Eliminar una columna o tabla 1. Código: elimina cada lectura y escritura (busca modelos ORM, SQL crudo, vistas, informes, trabajos ETL y otros servicios que compartan la base de datos). 2. Implementa y espera al menos un ciclo de lanzamiento completo. 3. Migración: elimina. Toma una copia de seguridad o instantánea de los datos primero si es importante. ### Dividir o mover una tabla Crea la nueva tabla, escritura dual, relleno, cambia lecturas, detén escrituras antiguas, elimina. ## Preguntas de compatibilidad para responder por cada cambio - ¿Algún código desplegado hace `SELECT *` o mapea todas las columnas (los ORM a menudo cachean la lista de columnas al inicio y fallan cuando una desaparece)? - ¿Falla una inserción del código antiguo porque una nueva columna es NOT NULL sin valor predeterminado? - ¿Otros servicios, trabajos cron, paneles de BI o réplicas leen esta tabla? - ¿Se puede revertir el despliegue a la versión de código anterior sin una migración de bajada? Si la respuesta a la última pregunta es "no", el cambio no es compatible con versiones anteriores. FILE:templates/review-report.md # Revisión de Seguridad de Migración: <nombre de la migración o título del PR> **Veredicto:** SEGURO | SEGURO CON CAMBIOS | INSEGURO **Motor:** <ej. PostgreSQL 15> | **Archivos revisados:** <cantidad> **Suposiciones:** <tamaños de tabla, tráfico, orden de despliegue - marca cualquier cosa adivinada> ## Resumen <2-4 oraciones: qué hace la migración, el mayor riesgo y qué cambiar.> ## Hallazgos | # | Severidad | Archivo:Línea | Sentencia | Riesgo | |---|-----------|--------------|-----------|--------| | 1 | ALTO | <ruta:línea> | `<SQL corto>` | <bloqueo / pérdida de datos / rompe código antiguo> | ### 1. <Título corto del hallazgo> - **Qué sucede:** <bloqueo tomado, duración, quién está bloqueado o qué se rompe> - **Por qué importa aquí:** <tamaño de tabla, tráfico, código que depende de ello> - **Alternativa segura:** ```sql -- SQL de reemplazo o código de migración, en orden de ejecución ``` <Repite para cada hallazgo ALTO y MEDIO. Agrupa los hallazgos BAJOS en una lista.> ## Compatibilidad de la Aplicación - <Cada objeto renombrado / eliminado / con cambio de tipo y dónde el código aún lo usa> - <O: "No hay referencias de código afectadas - verificado con rg para X, Y."> ## Plan de Rollback - <¿La migración de bajada restaura el estado? ¿Qué es irreversible?> - <Copia de seguridad o instantánea requerida antes de ejecutar: sí/no> ## Secuencia de Despliegue Recomendada 1. <Paso de migración o despliegue de código> 2. <...> ## Salida del Escáner ``` <pega la salida de scripts/scan_migration.py, o nota falsos positivos> ``` FILE:examples/example-review.md # Revisión de Ejemplo **Entrada:** PR "Agregar seguimiento de estado de pedido" con una migración de Rails para PostgreSQL 15. `orders` tiene ~40M de filas y recibe escrituras constantes. Las migraciones se ejecutan antes del nuevo código. ```sql -- renderizado desde db/migrate/20261002_add_status_to_orders.rb ALTER TABLE orders ADD COLUMN status varchar NOT NULL DEFAULT 'pending'; ALTER TABLE orders RENAME COLUMN shipped_on TO shipped_at; CREATE INDEX index_orders_on_status ON orders (status); ALTER TABLE orders ADD CONSTRAINT fk_orders_carrier FOREIGN KEY (carrier_id) REFERENCES carriers (id); ``` **Escáner:** 3 ALTO (renombrar, índice-no-concurrente, fk-validado), 1 MEDIO (sin-timeout-de-bloqueo). --- # Revisión de Seguridad de Migración: Agregar seguimiento de estado de pedido **Veredicto:** INSEGURO **Motor:** PostgreSQL 15 | **Archivos revisados:** 1 **Suposiciones:** orders ~40M filas, alto tráfico de escritura (del usuario); carriers es pequeña. ## Resumen Agrega una columna de estado de pedido, renombra `shipped_on`, indexa el estado y agrega una clave foránea de carrier. La columna de estado en sí es segura en PG 15, pero el renombrado romperá la aplicación en ejecución, y el índice y la FK bloquearán las escrituras en `orders` durante minutos. Divide en tres migraciones y usa variantes concurrentes / NOT VALID. ## Hallazgos | # | Severidad | Archivo:Línea | Sentencia | Riesgo | |---|-----------|--------------|-----------|--------| | 1 | ALTO | rendered.sql:3 | `RENAME COLUMN shipped_on` | El código antiguo da error en el despliegue | | 2 | ALTO | rendered.sql:4 | `CREATE INDEX ... (status)` | Escrituras bloqueadas durante la construcción | | 3 | ALTO | rendered.sql:5 | `ADD ... FOREIGN KEY` | Escaneo de validación completo bajo bloqueo | | 4 | MEDIO | rendered.sql:1 | sin `lock_timeout` | Los ALTER pueden ponerse en cola y detener el tráfico | ### 1. El renombrado de columna rompe el código en ejecución - **Qué sucede:** el renombrado es instantáneo, pero los servidores de aplicación aún en la versión anterior consultan `shipped_on` y fallan con `column does not exist` hasta que el despliegue termine. - **Por qué importa aquí:** `rg -n shipped_on` encuentra 7 referencias, incluido `app/serializers/order_serializer.rb` y el informe nocturno `reports/fulfillment.sql`. - **Alternativa segura:** expandir/contraer. Agrega `shipped_at`, escritura dual, rellena en lotes, cambia lecturas, luego elimina `shipped_on` en un lanzamiento posterior. ### 2. La construcción del índice bloquea escrituras - **Alternativa segura** (migración separada, `disable_ddl_transaction!`): ```sql CREATE INDEX CONCURRENTLY index_orders_on_status ON orders (status); ``` ### 3. La clave foránea valida 40M de filas bajo bloqueo - **Alternativa segura:** ```sql SET lock_timeout = '5s'; ALTER TABLE orders ADD CONSTRAINT fk_orders_carrier FOREIGN KEY (carrier_id) REFERENCES carriers (id) NOT VALID; -- siguiente migración (toma solo SHARE UPDATE EXCLUSIVE en orders): ALTER TABLE orders VALIDATE CONSTRAINT fk_orders_carrier; ``` **BAJO:** ninguno. Nota que `ADD COLUMN ... DEFAULT 'pending'` es solo metadatos en PG 11+. ## Compatibilidad de la Aplicación - `shipped_on`: 7 referencias de código más un informe SQL; debe permanecer hasta la fase de contracción. ## Plan de Rollback - La migración de bajada elimina `status` (pérdida de datos aceptable: columna nueva). El renombrado es reversible. - No se requiere copia de seguridad para este conjunto de cambios una vez que se elimina el renombrado. ## Secuencia de Despliegue Recomendada 1. Migración A: `SET lock_timeout`; agrega `status`; agrega `shipped_at`; agrega FK NOT VALID. 2. Migración B (sin transacción): crea el índice de estado concurrentemente. 3. Migración C: valida la FK. Implementa código que escriba dualmente `shipped_on`/`shipped_at`. 4. Rellena `shipped_at`; cambia lecturas; lanzamiento posterior elimina `shipped_on`. FILE:scripts/scan_migration.py #!/usr/bin/env python3 """Escáner heurístico para SQL riesgoso en archivos de migración (PostgreSQL / MySQL). Uso: python3 scan_migration.py [--dialect postgres|mysql] ARCHIVO [ARCHIVO ...] Códigos de salida: 0 = sin hallazgos HIGH, 1 = hallazgos HIGH, 2 = error de uso.""" import re, sys F = re.I | re.S COLDEF = r"(?:\([^)]*\)|[^,(])*" # una definición de columna, permitiendo numeric(10,2) RULES = [ # (severidad, id de regla, dialecto o None para ambos, regex, mensaje) ("HIGH", "drop-table", None, r"^DROP\s+TABLE\b", "Pérdida de datos irreversible; confirma copia de seguridad y sin lectores"), ("HIGH", "truncate", None, r"^TRUNCATE\b", "Pérdida de datos irreversible"), ("HIGH", "drop-column", None, r"^ALTER\s+TABLE\b.*\bDROP\s+(COLUMN\b|(?!CONSTRAINT|INDEX|KEY|PRIMARY|FOREIGN|CHECK|DEFAULT|NOT|IDENTITY|EXPRESSION)\w)", "Pérdida de datos; el código desplegado que lo lee fallará - elimina las referencias de código primero"), ("HIGH", "rename", None, r"^ALTER\s+TABLE\b.*\bRENAME\b", "Rompe el código en ejecución; usa expandir/contraer"), ("HIGH", "type-change", "postgres", r"^ALTER\s+TABLE\b.*\bALTER\s+(COLUMN\s+)?\S+\s+(SET\s+DATA\s+)?TYPE\b", "Generalmente una reescritura completa de tabla bajo ACCESS EXCLUSIVE"), ("HIGH", "type-change", "mysql", r"^ALTER\s+TABLE\b.*\b(MODIFY|CHANGE)\s+(COLUMN\s+)?\S+", "La redefinición de columna generalmente usa ALGORITHM=COPY (escrituras bloqueadas)"), ("HIGH", "index-not-concurrent", "postgres", r"^CREATE\s+(UNIQUE\s+)?INDEX\s+(?!CONCURRENTLY)", "Bloquea escrituras durante la construcción; usa CREATE INDEX CONCURRENTLY"), ("MEDIUM", "drop-index-not-concurrent", "postgres", r"^DROP\s+INDEX\s+(?!CONCURRENTLY)", "Toma ACCESS EXCLUSIVE; usa DROP INDEX CONCURRENTLY"), ("HIGH", "fk-validated", "postgres", r"^ALTER\s+TABLE\b(?!.*\bNOT\s+VALID\b).*\b(FOREIGN\s+KEY|REFERENCES)\b", "Valida todas las filas mientras bloquea ambas tablas; agrega NOT VALID, luego VALIDATE"), ("MEDIUM", "check-validated", "postgres", r"^ALTER\s+TABLE\b(?!.*\bNOT\s+VALID\b).*\bADD\s+(CONSTRAINT\s+\S+\s+)?CHECK\b", "Escaneo completo bajo bloqueo; agrega NOT VALID, luego VALIDATE"), ("MEDIUM", "set-not-null", "postgres", r"\bSET\s+NOT\s+NULL\b", "Escaneo completo bajo ACCESS EXCLUSIVE; valida un CHECK (col IS NOT NULL) primero"), ("HIGH", "add-not-null-no-default", None, r"^ALTER\s+TABLE\b.*\bADD\s+(COLUMN\s+)?(?!" + COLDEF + r"\bDEFAULT\b)" + COLDEF + r"\bNOT\s+NULL\b", "Falla en tablas no vacías (o las inserciones de código antiguo fallan); agrega nullable, rellena, luego aplica"), ("MEDIUM", "volatile-default", "postgres", r"^ALTER\s+TABLE\b.*\bADD\b.*\bDEFAULT\s+(now|random|clock_timestamp|gen_random_uuid|uuid_generate_v\d)\s*\(", "El valor predeterminado volátil reescribe la tabla; agrega nullable, rellena, luego establece el valor predeterminado"), ("MEDIUM", "unique-without-index", "postgres", r"^ALTER\s+TABLE\b(?!.*\bUSING\s+INDEX\b).*\bADD\s+(CONSTRAINT\s+\S+\s+)?(UNIQUE|PRIMARY\s+KEY)\b", "Construye índice bajo bloqueo; créalo CONCURRENTLY, luego ADD CONSTRAINT ... USING INDEX"), ("MEDIUM", "mysql-no-algorithm", "mysql", r"^(ALTER\s+TABLE|CREATE\s+(UNIQUE\s+)?INDEX)\b(?!.*\bALGORITHM\s*=)", "Indica ALGORITHM=INSTANT|INPLACE, LOCK=NONE para que MySQL rechace una copia bloqueante"), ("HIGH", "dml-no-where", None, r"^(UPDATE|DELETE)\b(?!.*\bWHERE\b)", "Toca cada fila en una transacción; hazlo por lotes"), ("LOW", "dml-in-migration", None, r"^(UPDATE|DELETE|INSERT)\b.*\bWHERE\b", "Cambio de datos en migración; hazlo por lotes si la tabla es grande"), ("MEDIUM", "table-rewrite", "postgres", r"^(VACUUM\s+FULL|CLUSTER|REINDEX\s+(?!.*CONCURRENTLY))", "Reescribe bajo ACCESS EXCLUSIVE; usa REINDEX CONCURRENTLY o pg_repack"), ("LOW", "enum-add-value", "postgres", r"^ALTER\s+TYPE\b.*\bADD\s+VALUE\b", "Nuevo valor inutilizable en la misma transacción; mantenlo en su propia migración"), ] def statements(sql): """Genera (número_de_línea, sentencia) después de eliminar comentarios. División ingenua por ';'.""" sql = re.sub(r"/\*.*?\*/", lambda m: re.sub(r"[^\n]", " ", m.group()), sql, flags=re.S) sql = re.sub(r"--[^\n]*", "", sql) pos = 0 for part in sql.split(";"): stripped = part.lstrip() line = sql.count("\n", 0, pos + len(part) - len(stripped)) + 1 pos += len(part) + 1 if stripped.strip(): yield line, " ".join(stripped.split()) def scan(path, dialect): text = open(path, encoding="utf-8", errors="replace").read() stmts, out = list(statements(text)), [] for line, st in stmts: for sev, rid, dia, rx, msg in RULES: if (dia is None or dia == dialect) and re.search(rx, st, F): out.append((sev, f"{path}:{line} [{sev}] {rid}: {msg}\n > {st[:110]}")) has_ddl = any(re.match(r"(ALTER|CREATE\s+(UNIQUE\s+)?INDEX|DROP)\b", s, re.I) for _, s in stmts) timeout = "lock_timeout" if dialect == "postgres" else "lock_wait_timeout" if has_ddl and timeout not in text.lower(): out.append(("MEDIUM", f"{path}:1 [MEDIUM] no-lock-timeout: DDL sin {timeout}; puede ponerse en cola y bloquear todo el tráfico")) if re.search(r"\bCONCURRENTLY\b", text, re.I) and re.search(r"^\s*(BEGIN|START\s+TRANSACTION)\b", text, re.I | re.M): out.append(("HIGH", f"{path}:1 [HIGH] concurrently-in-transaction: CONCURRENTLY no puede ejecutarse dentro de un bloque de transacción")) return out def main(argv): dialect = "postgres" if len(argv) >= 2 and argv[0] == "--dialect": dialect, argv = argv[1].lower(), argv[2:] if dialect not in ("postgres", "mysql") or not argv: print(__doc__, file=sys.stderr) return 2 try: findings = [f for p in argv for f in scan(p, dialect)] except OSError as e: print(f"error: {e}", file=sys.stderr) return 2 for _, text in findings: print(text) counts = {s: sum(1 for f in findings if f[0] == s) for s in ("HIGH", "MEDIUM", "LOW")} print(f"\n{len(argv)} archivo(s) escaneado(s): {counts['HIGH']} ALTO, {counts['MEDIUM']} MEDIO, {counts['LOW']} BAJO") print("Solo heurístico: confirma cada hallazgo contra references/risk-catalog.md.") return 1 if counts["HIGH"] else 0 if __name__ == "__main__": sys.exit(main(sys.argv[1:]))