296 preguntas que exigen explicar

Parte 00 · clase 001 · Fundamentos

1. Da un ejemplo propio de un dato que sin contexto pueda significar tres cosas
2. ¿Por qué una tabla exige que todas las filas tengan los mismos campos? ¿Qué
3. Un campo `telefono` guarda `+56 9 1111 / +56 2 2222` para algunos clientes.
4. Explica por qué `(sin correo)` es peor que dejar el campo vacío.

Parte 00 · clase 002 · Fundamentos

1. Enumera las cuatro cosas que una base de datos hace y un archivo no.
2. Explica con tus palabras cómo se pierde una escritura con dos copias de una
3. ¿Por qué un CSV compartido no resuelve el problema? Da dos motivos distintos.
4. Da un caso propio en el que **no** usarías base de datos, y justifica con el

Parte 00 · clase 003 · Fundamentos

1. ¿Qué diferencia hay entre la familia de definición y la de manipulación?
2. ¿Por qué conviene nombrar los campos en un `INSERT`?
3. ¿Qué significa `NOT NULL` y qué ocurre exactamente al violarlo?
4. Explica por qué `SELECT *` es cómodo para explorar y mala idea en el código de

Parte 00 · clase 004 · Fundamentos

1. ¿En qué orden aplica el motor `FROM`, `WHERE`, `SELECT`, `ORDER BY` y `LIMIT`?
2. ¿Por qué `WHERE nota = NULL` devuelve cero filas?
3. ¿Qué problema concreto resuelve añadir un segundo criterio al `ORDER BY`?
4. Explica por qué `LIMIT 3` sin `ORDER BY` puede dar un resultado distinto en dos

Parte 00 · clase 005 · Fundamentos

1. ¿Qué hace exactamente `DELETE FROM notas;`?
2. ¿Cómo se comprueba el alcance de un `UPDATE` **antes** de ejecutarlo?
3. ¿Qué diferencia hay entre borrar una fila y vaciar uno de sus campos?
4. Explica en qué caso el número de filas afectadas te habría avisado de un error

Parte 00 · clase 006 · Fundamentos

1. ¿Por qué `100` va antes que `58` al ordenar texto?
2. ¿Cuándo usarías `DECIMAL` y cuándo coma flotante? Da un ejemplo de cada uno.
3. ¿Qué dos formas aceptables hay de guardar una fecha, y por qué el formato
4. ¿Qué significa que SQLite tenga tipado por afinidad y qué consecuencia

Parte 00 · clase 007 · Fundamentos

1. ¿Qué tres cosas garantiza una clave primaria?
2. ¿Por qué el correo es mala clave primaria aunque sea único?
3. ¿Qué regla de negocio impone una clave primaria compuesta en una tabla de
4. Si eliges clave sustituta, ¿qué hay que declarar además y por qué?

Parte 00 · clase 008 · Fundamentos

1. Nombra las tres anomalías que produce guardar dos cosas en una tabla.
2. ¿Qué impide exactamente una clave foránea, y qué **no** impide?
3. ¿Por qué en SQLite una clave foránea puede no estar comprobando nada?
4. ¿Qué devuelve una reunión escrita sin condición `ON`, y por qué casi nunca es

Parte 00 · clase 009 · Fundamentos

1. Enumera las tres preguntas del criterio y explica qué garantiza cada una.
2. ¿Por qué el tamaño de los datos es mal criterio? Da un ejemplo.
3. ¿En qué caso concreto elegirías SQLite antes que PostgreSQL, y por qué?
4. Nombra tres costos de añadir un motor que no aparecen en su página de

Parte 00 · clase 010 · Fundamentos

1. Nombra las seis familias y el problema que resuelve cada una.
2. ¿Por qué la división «SQL frente a NoSQL» explica poco? Propón una mejor.
3. Da un caso en el que un motor documental es peor opción que uno relacional, y
4. ¿Qué comprobación conviene hacer **antes** de añadir un motor especializado a

Parte 01 · clase 011 · Fundamentos

1. Explica, con una traza temporal propia, una anomalía de concurrencia distinta de la actualización perdida y por qué el sistema de archivos no la evita.
2. Un compañero afirma: «migramos a PostgreSQL, así que los datos ya son consistentes». ¿Qué le falta declarar para que esa frase sea cierta?
3. Da un caso real de tu trabajo donde usar un SGBD sería una mala decisión, y justifica con los criterios del diagrama.
4. ¿Qué componente descrito por Hellerstein et al. desaparece si renuncias a la durabilidad, y qué garantía pierdes con él?

Parte 01 · clase 012 · Fundamentos

1. ¿En qué etapa se detecta un nombre de columna mal escrito, y por qué no puede detectarse antes ni después?
2. Explica con números por qué un barrido secuencial puede ganarle a una búsqueda por índice.
3. Tu servidor pasa de 50 a 500 conexiones y el rendimiento cae. Da dos causas plausibles ligadas al modelo de proceso.
4. ¿Qué componente falla si, tras un corte de energía, aparecen filas de una transacción que nunca se confirmó?

Parte 01 · clase 013 · Fundamentos

1. Da un cambio de tu propio código que rompió clientes y clasifícalo: ¿fue una fuga de independencia física o lógica?
2. ¿Por qué `SELECT *` es una dependencia del nivel externo respecto del conceptual?
3. Una vista con `GROUP BY` no es actualizable. Explica por qué en términos de información perdida.
4. ¿Qué garantiza y qué no garantiza la independencia física cuando se cambia un índice B-Tree por uno hash?

Parte 01 · clase 014 · Fundamentos

1. ¿Por qué una base en memoria produce ejecuciones más comparables que una en archivo?
2. Un compañero muestra un tiempo de 3 ms como prueba de que su índice funciona. ¿Qué tres datos le pedirías antes de aceptarlo?
3. Escribe una invariante del dominio que no pueda expresarse como clave foránea, y la consulta que la comprueba.
4. ¿Qué afirmación *no* puede sostenerse con el laboratorio base, por bien que se ejecute?

Parte 02 · clase 015 · Fundamentos

1. Da un atributo de tu dominio que parezca un hecho y sea en realidad una decisión de implementación.
2. ¿Qué pierdes exactamente si no preguntas por la temporalidad de un atributo que sí cambia?
3. Un cliente afirma que el correo identifica a la persona. Da dos casos reales que rompan esa afirmación.
4. ¿Por qué la lista de exclusiones es parte del modelo y no del acta de la reunión?

Parte 02 · clase 016 · Fundamentos

1. Explica con un ejemplo del dominio por qué la nota es atributo de la relación y no de la entidad.
2. Da una relación ternaria genuina de tu experiencia y demuestra que no se descompone en tres binarias.
3. ¿Qué diferencia práctica hay entre `ON DELETE CASCADE` y `ON DELETE RESTRICT` en la tabla `teaching`?
4. Un modelo declara participación total en ambos lados de una relación 1:1. ¿Cómo se inserta la primera fila?

Parte 02 · clase 017 · Fundamentos

1. Da una clave natural de tu dominio que cumpla los tres criterios y justifica por qué la elegirías.
2. ¿Por qué el ancho de la clave primaria afecta al tamaño de índices que no la incluyen explícitamente?
3. Explica el problema de localidad de UUID v4 con una traza de inserciones sobre un B-Tree.
4. En `enrollments` se eligió clave natural compuesta. Da un requisito futuro que obligaría a añadir una sustituta.

Parte 02 · clase 018 · Intermedio

1. Da una dependencia funcional cierta en tu dominio que hoy los datos no reflejarían.
2. Demuestra con un ejemplo pequeño que una descomposición con intersección no clave inventa filas.
3. ¿Qué anomalía concreta elimina 3FN que 2FN no elimina?
4. Presenta un caso donde te quedarías en 3FN pudiendo llegar a BCFN, y di quién vigila entonces la dependencia perdida.

Parte 02 · clase 019 · Intermedio

1. ¿Qué relación lecturas/escrituras usarías como umbral en tu contexto y por qué?
2. Explica por qué la vista materializada no puede divergir lógicamente y la columna derivada sí.
3. Describe un punto caliente que crearía una columna derivada en tu dominio y cómo lo repartirías.
4. Un proceso de carga masiva escribe con `COPY` y salta los disparadores. ¿Cómo lo detectas y cómo lo reparas?

Parte 03 · clase 020 · Fundamentos

1. Da una consulta cuyo resultado cambie al crear un índice, sin que cambien los datos, y explica por qué.
2. ¿Por qué `COUNT(*)` y `COUNT(DISTINCT ...)` difieren, y qué dice eso del modelo subyacente?
3. Explica el acceso por valor y por qué prohíbe exponer identificadores de fila físicos.
4. La propiedad de cierre habilita las CTE. Da una consulta tuya que sería imposible sin ella.

Parte 03 · clase 021 · Fundamentos

1. Demuestra con un contraejemplo que E3 no vale si la condición usa atributos de ambas relaciones.
2. ¿Por qué la intersección no es un operador primitivo?
3. Da una consulta donde omitir `DISTINCT` produzca un total inflado en un informe, con números.
4. Explica por qué la formulación de división con `HAVING COUNT` exige unicidad de `(student_id, course_id)`.

Parte 03 · clase 022 · Intermedio

1. ¿Por qué toda consulta SQL es automáticamente una expresión segura?
2. Traduce `∀c ∈ obligatorios: inscrito(s, c)` a SQL y explica cada negación.
3. Da un caso real donde `NOT IN` y `NOT EXISTS` devuelvan resultados distintos, con datos concretos.
4. ¿Qué le añade SQL al álgebra relacional, y por qué esas adiciones no rompen la capacidad de optimizar?

Parte 03 · clase 023 · Intermedio

1. ¿Por qué un `CHECK` no rechaza los nulos y qué hay que escribir para que lo haga?
2. Da un caso de tu dominio donde `CASCADE` destruiría información que debe conservarse.
3. Explica con una traza por qué el ciclo obligatorio necesita restricciones diferidas.
4. Elige entre detectar y prevenir para la regla del cupo, y defiende la elección con el costo de cada una.

Parte 04 · clase 024 · Fundamentos

1. Demuestra numéricamente por qué `REAL` no sirve para dinero.
2. ¿Qué diferencia práctica hay entre `TIMESTAMP` y `TIMESTAMPTZ` durante un cambio de horario?
3. Escribe la unicidad condicional de tu dominio en dos motores distintos.
4. Tu migración falla a mitad en MySQL. Describe el estado del esquema y cómo lo recuperas.

Parte 04 · clase 025 · Fundamentos

1. Explica con el orden lógico por qué un alias funciona en `ORDER BY` y no en `WHERE`.
2. Da un caso donde `WHERE` y `HAVING` produzcan resultados distintos, con datos.
3. ¿Por qué la paginación por clave necesita un índice sobre exactamente las columnas del `ORDER BY`?
4. Tu aplicación funciona en MySQL y falla en PostgreSQL al buscar correos. Diagnostica y propón la corrección definitiva.

Parte 04 · clase 026 · Intermedio

1. Con `A` de 1 000 filas y `B` de 50 000 con clave foránea a `A`, ¿cuántas filas produce `A JOIN B`? ¿Y `A LEFT JOIN B`?
2. Explica por qué `EXISTS` no necesita `DISTINCT`.
3. Da una consulta tuya donde el doble conteo pasaría desapercibido, e indica cómo lo detectarías.
4. ¿Por qué un bucle anidado sobre dos tablas grandes es una señal de alarma en un plan?

Parte 04 · clase 027 · Intermedio

1. Con notas `6.0, NULL, NULL`, ¿qué devuelven `COUNT(*)`, `COUNT(nota)`, `AVG(nota)` y `SUM(nota)`?
2. ¿Por qué `COUNT(*)` es incorrecto tras un `LEFT JOIN` cuando quieres contar hijos?
3. Explica cuándo agrupar solo por la clave primaria es válido y por qué.
4. Da dos porcentajes correctos y distintos para la misma pregunta de negocio, y di cómo elegirías.

Parte 04 · clase 028 · Intermedio

1. ¿Por qué no se puede filtrar `ROW_NUMBER()` en `WHERE`?
2. Da un conjunto de datos donde `ROWS` y `RANGE` produzcan acumulados distintos.
3. Explica por qué la subconsulta correlacionada puede devolver dos filas donde la ventana devuelve una.
4. Escribe la cota de una CTE recursiva sobre tu jerarquía y justifica el valor elegido.

Parte 04 · clase 029 · Intermedio

1. Evalúa `NULL OR TRUE`, `NULL AND FALSE` y `NOT NULL` bajo lógica de tres valores.
2. ¿Por qué `GROUP BY` agrupa los nulos y `=` no los iguala?
3. Da un caso donde un índice `UNIQUE` con varios nulos sea el comportamiento deseado.
4. Convierte una columna con nulo «no aplicable» a un diseño sin nulos y compara las dos consultas equivalentes.

Parte 05 · clase 030 · Intermedio

1. Da un ejemplo propio de divergencia semántica y explica por qué es peor que una sintáctica.
2. ¿Por qué `LIMIT` es más portable en la práctica que `FETCH FIRST`, pese a no estar en la norma?
3. Escribe el `UPSERT` de tu dominio en tres dialectos.
4. Justifica un caso donde usarías una extensión propietaria a sabiendas, y cómo la documentarías.

Parte 05 · clase 031 · Intermedio

1. ¿Por qué `work_mem` puede consumirse varias veces en una sola consulta?
2. Explica qué ocurre en una tabla con muchas actualizaciones si el autovacuum no llega a tiempo.
3. Da un caso de tu dominio donde `jsonb` sea correcto y otro donde sea una excusa para no modelar.
4. ¿Qué pierdes al migrar de PostgreSQL a un motor sin índices parciales, y cómo lo compensas?

Parte 05 · clase 032 · Intermedio

1. ¿Por qué `ONLY_FULL_GROUP_BY` desactivado produce informes erróneos y no errores?
2. Explica qué código de tu dominio se rompería al migrar a Oracle por el tratamiento de la cadena vacía.
3. ¿Qué implica que SQL Server use bloqueo en `READ COMMITTED` para una consulta de informe larga?
4. Escribe un `ORDER BY` con posición de nulos fijada que funcione en los cinco motores de la tabla.

Parte 05 · clase 033 · Intermedio

1. ¿Qué garantías se pierden al no tener proceso servidor, y cuáles se conservan?
2. Explica con números por qué el formato columnar reduce la E/S de una consulta analítica.
3. ¿Por qué el modo WAL no permite dos escritores simultáneos?
4. Da un sistema real de tu experiencia que hoy usa un servidor y podría usar SQLite, y defiende la decisión.

Parte 06 · clase 034 · Intermedio

1. ¿Por qué la frontera del agregado es la frontera de la atomicidad?
2. Da un agregado de tu dominio que crecería sin límite y propón cómo acotarlo.
3. Explica el criterio de Helland de idempotencia con un mensaje concreto de tu sistema.
4. ¿En qué caso concreto renunciarías al modelo relacional por uno de agregados, y con qué evidencia?

Parte 06 · clase 035 · Intermedio

1. ¿Por qué «se leen juntos» no implica «se guardan dentro»?
2. Calcula el punto de equilibrio de duplicar un campo en tu dominio, con cifras reales.
3. Explica el efecto de un arreglo de 5 000 elementos sobre un índice multiclave.
4. Da un caso de tu dominio donde el modelo documental sea peor que el relacional, y justifícalo.

Parte 06 · clase 036 · Intermedio

1. ¿Por qué el rango va al final en la regla ESR?
2. ¿Qué condiciones exactas debe cumplir una consulta cubierta?
3. Explica el efecto de un `$lookup` colocado antes de un `$match` selectivo.
4. Da un caso de tu dominio donde un índice parcial reduzca el tamaño más de un 80 %.

Parte 06 · clase 037 · Intermedio

1. ¿Cuántos datos se pierden exactamente con `appendfsync everysec` y una caída de la máquina?
2. Traza la carrera entre un lector y un escritor que deja un valor obsoleto en la caché.
3. Calcula la estampida esperada en tu sistema con sus cifras de tráfico.
4. Da un dato de tu dominio que **no** guardarías en Redis y explica por qué.

Parte 07 · clase 038 · Intermedio

1. Explica la adyacencia sin índice y por qué el tamaño total del grafo deja de importar.
2. Calcula las búsquedas de índice de un recorrido de profundidad 6 con ramificación 10.
3. Da una consulta de tu dominio donde el grafo sería claramente peor.
4. ¿Qué garantías de integridad pierdes al mover datos de un relacional a un grafo?

Parte 07 · clase 039 · Avanzado

1. ¿Por qué CQL prohíbe las reuniones en lugar de permitirlas y avisar de su costo?
2. Calcula el tamaño de partición de una serie tuya y elige el cubo temporal.
3. Con RF = 5, ¿qué combinaciones de `R` y `W` dan lectura consistente?
4. Da una consulta nueva sobre tu modelo y describe el trabajo completo de añadirla.

Parte 07 · clase 040 · Intermedio

1. ¿Por qué un identificador de usuario nunca debe ser etiqueta?
2. Calcula el almacenamiento anual de tu serie con y sin retención por niveles.
3. Explica la diferencia entre tiempo de evento y de ingesta con un caso de tu sistema.
4. ¿Qué ventaja tiene eliminar un fragmento frente a un `DELETE` con filtro temporal?

Parte 07 · clase 041 · Intermedio

1. ¿Por qué la saturación de la frecuencia de término mejora el ranking frente a TF-IDF puro?
2. Da un caso donde eliminar acentos empeore los resultados en español.
3. Calcula el IDF de un término presente en 999 de 1 000 documentos e interpreta el valor.
4. Justifica con cifras si tu caso necesita un motor de búsqueda dedicado.

Parte 07 · clase 042 · Avanzado

1. Calcula la E/S de una consulta tuya en ambos formatos, con cifras reales.
2. ¿Por qué ordenar por una columna de baja cardinalidad reduce el tamaño total?
3. Explica por qué la ejecución vectorizada ayuda incluso con todos los datos en memoria.
4. Da una métrica de tu negocio donde el error del 1 % de HyperLogLog sea inaceptable.

Parte 08 · clase 043 · Intermedio

1. ¿Por qué la C es de naturaleza distinta a A, I y D?
2. Da una invariante de tu dominio que ningún `CHECK` pueda expresar y di quién la vigila.
3. Enumera los cuatro fallos frente a los que puede exigirse durabilidad y el mecanismo de cada uno.
4. Explica el efecto de una transacción abierta durante una hora en un motor MVCC.

Parte 08 · clase 044 · Avanzado

1. ¿Por qué el sesgo de escritura no lo detecta el aislamiento de instantánea?
2. Escribe una operación de tu sistema que hoy sea lectura-modificación-escritura y conviértela en atómica.
3. ¿Qué debe hacer la aplicación al recibir un error de serialización, y por qué no basta con reintentar sin límite?
4. Diseña el guion de dos sesiones que demuestre si tu motor permite fantasmas en su nivel por defecto.

Parte 08 · clase 045 · Avanzado

1. ¿Por qué el 2PL estricto evita las reversiones en cascada?
2. Explica con `xmin`/`xmax` por qué la sesión A sigue viendo 240 000 filas.
3. ¿Qué bloquea exactamente `FOR UPDATE` sobre una consulta sin índice en InnoDB?
4. Da dos transacciones de tu sistema que podrían formar un ciclo y define su orden canónico.

Parte 08 · clase 046 · Avanzado

1. ¿Por qué el registro debe llegar al disco antes que la página de datos?
2. Explica por qué la fase de rehacer reaplica transacciones que no se confirmaron.
3. ¿Qué función cumplen los registros de compensación si el sistema cae durante la recuperación?
4. Con `synchronous_commit = off`, ¿qué se pierde exactamente y ante qué fallo?

Parte 08 · clase 047 · Avanzado

1. ¿Por qué la restricción única es más fiable que comprobar antes de insertar?
2. Da una operación de tu sistema que no sea idempotente y conviértela.
3. Explica qué ocurre con reintentos sincronizados sin dispersión, con cifras.
4. ¿Qué efecto externo de tu código quedaría inconsistente si la transacción se revierte?

Parte 09 · clase 048 · Intermedio

1. Calcula las páginas de una tabla de 20 M de filas de 250 bytes.
2. ¿Por qué 40 000 lecturas aleatorias pueden ser más lentas que 65 000 secuenciales?
3. Explica la diferencia entre montón e índice agrupado y una consecuencia práctica de cada una.
4. Da un caso donde una tasa de aciertos del 99 % siga siendo un problema.

Parte 09 · clase 049 · Intermedio

1. Calcula la altura de un B-Tree con 500 millones de filas y clave de 16 bytes.
2. ¿Por qué un índice sobre `(a, b)` no sirve para `WHERE b = 2`?
3. Explica por qué un rango impide aprovechar las columnas posteriores.
4. Da una consulta tuya donde el índice cubriente compense y otra donde no.

Parte 09 · clase 050 · Avanzado

1. ¿Por qué un LSM escribe más bytes y aun así sostiene más caudal de escritura?
2. Calcula la tasa de falsos positivos con 8 bits por clave y 5 funciones hash.
3. Explica por qué borrar puede aumentar el espacio ocupado y ralentizar las lecturas.
4. ¿Qué estrategia de compactación elegirías para datos con TTL de 30 días, y por qué?

Parte 09 · clase 051 · Avanzado

1. ¿Qué condición debe cumplir la tabla para que BRIN sea útil, y cómo se comprueba?
2. Explica por qué `WHERE date(creado) = '2026-08-01'` no usa el índice sobre `creado`.
3. Da una consulta de tu dominio que solo un GIN pueda acelerar.
4. Calcula el ahorro de convertir en parcial uno de tus índices, con cifras reales.

Parte 09 · clase 052 · Avanzado

1. ¿Por qué una subestimación de cardinalidad lleva a elegir bucle anidado?
2. Explica por qué el planificador subestima con columnas correlacionadas y cómo se corrige.
3. ¿Qué significa `Heap Fetches` distinto de cero en un barrido de índice?
4. Da una hipótesis tuya que resultó refutada y qué hiciste con el cambio.

Parte 10 · clase 053 · Avanzado

1. ¿Cuántas transacciones se pierden en una conmutación asíncrona con 340 ms de retraso y 2 000 escrituras/s?
2. Explica por qué fijar la sesión a una réplica no resuelve la lectura de tus escrituras.
3. Con N = 5, enumera las combinaciones `R`/`W` que solapan y su tolerancia a fallos.
4. Da una operación de tu sistema que justifique replicación síncrona y otra que no.

Parte 10 · clase 054 · Avanzado

1. ¿Por qué particionar por tiempo destruye la ventaja de un clúster grande?
2. Calcula el porcentaje de claves movidas al pasar de 8 a 9 nodos con `mod N` y con hash consistente.
3. Da una clave caliente de tu dominio y dimensiona su salado con lectura y escritura.
4. ¿Cuándo preferirías índice secundario global sobre local, con cifras?

Parte 10 · clase 055 · Avanzado

1. Enuncia CAP con las definiciones exactas de C, A y P.
2. ¿Por qué Spanner puede ser PC/EC y tener alta disponibilidad práctica?
3. Da una operación de tu sistema que hoy es AP sin que nadie lo haya decidido.
4. ¿Qué garantías transaccionales son inalcanzables manteniendo disponibilidad total?

Parte 10 · clase 056 · Avanzado

1. Da un sistema serializable que no sea linealizable, con una traza.
2. ¿Por qué la consistencia causal sobrevive a una partición y la secuencial no?
3. Explica qué escrituras pierde un `LWW-Register` y en qué condiciones.
4. Elige el modelo mínimo suficiente para tres operaciones tuyas y justifica cada elección.

Parte 10 · clase 057 · Avanzado

1. ¿Por qué el consenso necesita mayoría estricta y no basta la mitad?
2. Traza el fallo del coordinador en 2PC y explica por qué los participantes no pueden decidir.
3. Da un paso de tu sistema cuya compensación no sea una simple inversión.
4. ¿Qué garantiza la bandeja de salida y qué obligación traslada al consumidor?

Parte 11 · clase 058 · Intermedio

1. ¿Por qué una réplica no protege de un `DELETE` sin `WHERE`?
2. Calcula el RPO real de tu configuración actual, en minutos.
3. ¿Qué comprobarías tras restaurar, antes de promover a producción?
4. Diseña la protección de tus copias frente a un atacante con credenciales de administrador.

Parte 11 · clase 059 · Avanzado

1. ¿Por qué `RENAME COLUMN` es peligroso si es instantáneo en el motor?
2. Explica la cola de bloqueos y cómo `lock_timeout` la evita.
3. ¿Qué aporta `SKIP LOCKED` en un relleno por lotes?
4. Da un cambio de tu esquema que sí exigiría una ventana de parada, y justifícalo.

Parte 11 · clase 060 · Intermedio

1. ¿Por qué la política de inquilino debe ser restrictiva y no permisiva?
2. Explica la fuga que produce `set_config` sin ámbito local en un agrupador.
3. ¿Qué añade `WITH CHECK` que `USING` no cubre?
4. Da un caso donde `SECURITY DEFINER` sea necesario y cómo lo asegurarías.

Parte 11 · clase 061 · Fundamentos

1. Explica a nivel de protocolo por qué un parámetro no puede inyectar.
2. ¿Por qué el nombre de una columna no se puede parametrizar?
3. Describe un caso de inyección de segundo orden en tu propio sistema.
4. Si una inyección llegara a ejecutarse, ¿qué podría hacer con tus privilegios actuales?

Parte 11 · clase 062 · Avanzado

1. Con p99 de 100 ms y 20 consultas por petición, ¿qué fracción de peticiones sufre la cola?
2. ¿Por qué una consulta de 2 ms puede ser más urgente que una de 8 s?
3. Da tres métricas de saturación de tu base y el umbral que elegirías para cada una.
4. Interpreta un `wait_event` de `Client:ClientRead` sostenido en 50 conexiones.

Parte 11 · clase 063 · Intermedio

1. ¿Por qué la seudonimización no exime de las obligaciones de protección de datos?
2. Da una columna de tu sistema que hoy no tendría base legal declarada.
3. Explica cómo atiendes una supresión conservando una obligación legal.
4. ¿Cuándo se completa realmente una supresión, dado tu ciclo de copias?

Parte 12 · clase 064 · Intermedio

1. Explica los tres conflictos con datos de tu propio sistema.
2. ¿Por qué una consulta analítica larga impide recuperar versiones muertas?
3. ¿En qué caso la exportación a Parquet supera a una réplica de solo lectura?
4. Da una situación donde no separar sea la decisión correcta, y defiéndela.

Parte 12 · clase 065 · Intermedio

1. Escribe el grano de una tabla de hechos tuya como frase completa.
2. ¿Por qué se guardan `aprobados` y `evaluados` en vez del porcentaje?
3. Da un hecho semiaditivo de tu dominio y la agregación que sería incorrecta.
4. Explica qué se rompe si la tabla de hechos guarda la clave natural.

Parte 12 · clase 066 · Avanzado

1. Explica con una traza cómo una transacción larga hace perder filas a la extracción por marca.
2. ¿Por qué los borrados son invisibles en ese enfoque y no en la captura desde el registro?
3. ¿Qué ocurre si el consumidor de una ranura de replicación se detiene una semana?
4. Da una transformación tuya que hoy sería imposible corregir retroactivamente, y cómo lo arreglarías.

Parte 12 · clase 067 · Avanzado

1. Da una pregunta de tu negocio que exija tiempo de evento y explica qué se rompería con tiempo de procesamiento.
2. ¿Qué compromiso codifica exactamente una marca de agua?
3. Explica por qué la entrega exactamente una vez de extremo a extremo no es una propiedad de la red.
4. Da un caso tuyo de «streaming» que en realidad se resuelva con SQL sobre una tabla con marca de tiempo.

Parte 13 · clase 068 · Intermedio

1. ¿Por qué con vectores normalizados las tres métricas dan el mismo orden?
2. Explica qué ocurre exactamente al consultar con vectores de dos modelos mezclados.
3. Calcula el almacenamiento de 10 M de vectores de 1 536 dimensiones en float32 e int8.
4. ¿Qué compromiso hay al elegir el tamaño del fragmento, y cómo lo resolverías?

Parte 13 · clase 069 · Avanzado

1. ¿Cómo se mide el recall y contra qué referencia?
2. Explica por qué el post-filtrado devuelve cero resultados con un filtro del 0,8 %.
3. ¿Qué diferencia hay entre `ef_construction` y `ef_search` en cuanto a cuándo se pueden cambiar?
4. Con un filtro que selecciona el 0,3 % del corpus, ¿qué estrategia elegirías y por qué?

Parte 13 · clase 070 · Avanzado

1. ¿Por qué RRF no necesita normalizar las puntuaciones?
2. Da una consulta de tu dominio donde el vectorial falle y BM25 acierte, y explica por qué.
3. Calcula el RRF de un documento que quedó 3.º en léxico y 15.º en vectorial.
4. ¿En qué caso la búsqueda solo léxica sería la decisión correcta?

Parte 13 · clase 071 · Avanzado

1. ¿Por qué recall@k es el techo de la calidad de la respuesta?
2. Explica por qué el reordenador sube la precisión y no el recall.
3. ¿Cómo distingues un fallo de recuperación de uno de generación con la traza?
4. Da una comprobación mecánica de alucinación que no requiera otro modelo.

Parte 14 · clase 072 · Avanzado

1. Enumera el costo permanente de añadir un almacén a tu sistema.
2. Da una carga tuya que hoy usa un motor especializado y podría volver al principal.
3. ¿Qué medirías antes de añadir un motor de búsqueda dedicado?
4. Escribe el umbral de revisión de una de tus decisiones y cómo lo vigilarías.

Parte 14 · clase 073 · Avanzado

1. ¿Por qué un ADR aceptado no se edita?
2. Da una decisión tuya prácticamente irreversible y di qué rigor recibió.
3. Estima el costo de salida de tu almacén principal, en horas.
4. Escribe la condición de revisión de una decisión vigente en tu equipo.

Parte 14 · clase 074 · Avanzado

1. Enuncia una afirmación de tu proyecto y la evidencia exacta que la respalda.
2. ¿Qué invariante de tu sistema no puede garantizar el motor y cómo la vigilas?
3. Da una alternativa que descartaste siendo mejor en alguna métrica, y por qué.
4. ¿Qué se rompe primero cuando tu sistema crezca diez veces, y cómo te enterarás?