Curso de T-SQL

Configurar una conexión segura a SQL Server, Azure SQL Database o Azure SQL Managed Instance usando credenciales de laboratorio y permisos controlados.

Usar SQL Server Management Studio o Visual Studio Code con extensiones SQL para escribir, ejecutar, formatear y depurar scripts T-SQL.

Preparar una base de datos de laboratorio con esquemas, tablas, relaciones, datos sintéticos y escenarios realistas de negocio.

Separar entornos de desarrollo, pruebas y producción para evitar ejecutar consultas destructivas en bases reales por error.

Configurar opciones básicas de sesión que afectan a resultados, mensajes, tratamiento de nulos, idioma, fechas y comportamiento de ejecución.

Aprender a leer errores de sintaxis, errores de permisos, errores de conversión, violaciones de constraints y mensajes del motor.

Organizar scripts en repositorio por carpetas: DDL, DML, consultas, procedimientos, funciones, vistas, pruebas y despliegues.

Crear una convención de nombres para objetos, scripts, variables, alias, constraints, índices y procedimientos.

Usar transacciones de prueba para validar operaciones de modificación sin dejar cambios persistentes no deseados.

Documentar comandos de conexión, restauración de base, carga de datos y ejecución de scripts para que el laboratorio sea reproducible.

Comprender tablas, columnas, claves primarias, claves externas, constraints, relaciones y cardinalidades como base de cualquier consulta fiable.

Diferenciar esquemas lógicos de base de datos, propietarios, namespaces y modelos de seguridad asociados.

Analizar cómo el diseño de tablas condiciona la complejidad de las consultas, el rendimiento y la facilidad de mantenimiento.

Diseñar modelos normalizados cuando se busca integridad, evitar duplicidad y mantener reglas de negocio consistentes.

Reconocer cuándo una estructura desnormalizada, resumen o tabla analítica puede tener sentido para reporting o rendimiento.

Definir claves naturales, claves sustitutas, claves compuestas y restricciones únicas con criterios de negocio y operación.

Entender el impacto de tipos de datos mal elegidos sobre almacenamiento, conversiones, índices, joins y precisión de resultados.

Revisar modelos legacy con nombres ambiguos, columnas sobrecargadas, relaciones implícitas y ausencia de constraints.

Crear documentación mínima del modelo: propósito de tabla, columna, relación, owner, sensibilidad y reglas de calidad.

Construir un modelo relacional de laboratorio con integridad referencial y datos representativos para consultas avanzadas.

Escribir consultas `SELECT` claras, evitando `SELECT *` en código productivo cuando el contrato de columnas debe ser explícito.

Usar alias de columnas y tablas para mejorar legibilidad sin ocultar el origen real de cada dato.

Aplicar expresiones calculadas, literales, funciones y conversiones con nombres claros para que el resultado sea consumible.

Entender el orden lógico de procesamiento de una consulta y por qué no siempre coincide con el orden escrito.

Usar `TOP`, `OFFSET` y `FETCH` con `ORDER BY` estable para paginación o muestras controladas.

Diferenciar orden de presentación y orden de procesamiento, evitando asumir que una tabla devuelve filas en orden natural.

Crear consultas legibles con saltos, indentación, comentarios útiles y estructura consistente para revisión de equipo.

Evitar lógica excesiva en una única sentencia si dificulta diagnóstico, pruebas o reutilización.

Validar resultados con recuentos, muestras, casos límite y comparación contra reglas de negocio.

Construir consultas base de consumo para listados, detalles, catálogos, búsquedas y exportaciones.

Usar `WHERE` con predicados claros para filtrar por igualdad, rangos, listas, patrones, fechas, estados y condiciones compuestas.

Aplicar `IS NULL` e `IS NOT NULL` correctamente, evitando comparaciones inválidas con `NULL`.

Combinar `AND`, `OR` y paréntesis de forma explícita para evitar resultados incorrectos por precedencia de operadores.

Usar `IN`, `EXISTS`, `BETWEEN`, `LIKE` y expresiones equivalentes con criterio semántico y de rendimiento.

Evitar funciones sobre columnas filtradas cuando impiden usar índices de forma eficiente.

Gestionar filtros por fechas con rangos abiertos y cerrados, evitando errores por horas, zonas y precisión temporal.

Detectar filtros que cambian una consulta de forma silenciosa por conversiones implícitas o tipos incompatibles.

Aplicar filtros de seguridad y visibilidad de datos por usuario, rol, tenant, departamento o unidad de negocio cuando procede.

Probar filtros con datos nulos, extremos, duplicados, estados no esperados y valores fuera de catálogo.

Construir una batería de consultas de filtrado para escenarios reales de búsqueda, auditoría y reporting.

Usar `ORDER BY` para devolver resultados deterministas, especialmente en pantallas, exportaciones, APIs y procesos batch.

Diseñar paginación con `OFFSET` y `FETCH` cuidando rendimiento, estabilidad del orden y experiencia del consumidor.

Evitar paginar sobre columnas no únicas sin añadir criterios de desempate que mantengan resultados consistentes.

Analizar cuándo la paginación basada en claves resulta más eficiente que saltar muchas filas con `OFFSET`.

Aplicar ordenaciones por fechas, importes, textos, estados y prioridades con criterios funcionales claros.

Controlar collation, mayúsculas, acentos y orden alfabético cuando afecta a búsquedas o listados empresariales.

Evitar ordenar dentro de vistas, subconsultas o CTEs esperando un comportamiento que el consumidor no garantiza.

Medir el coste de ordenar grandes volúmenes y revisar índices que ayuden a devolver datos ya ordenados.

Validar que exportaciones, dashboards y APIs reciben datos en el orden esperado aunque cambie el plan de ejecución.

Construir una consulta paginada profesional con orden estable, filtros combinados y medición de rendimiento.

Usar `INNER JOIN`, `LEFT JOIN`, `RIGHT JOIN`, `FULL JOIN` y `CROSS JOIN` entendiendo qué filas conserva cada operación.

Diseñar joins basados en claves correctas, evitando unir por nombres, textos o campos ambiguos sin garantías de unicidad.

Detectar multiplicación accidental de filas cuando se unen tablas con relaciones uno-a-muchos o muchos-a-muchos.

Usar `LEFT JOIN` sin convertirlo accidentalmente en `INNER JOIN` al filtrar columnas de la tabla opcional en `WHERE`.

Analizar cardinalidad esperada antes de escribir joins complejos para saber si el resultado debería crecer, reducirse o conservarse.

Crear joins sobre dimensiones, hechos, catálogos, usuarios, permisos, productos, pedidos o entidades habituales de negocio.

Evitar joins innecesarios que solo añaden coste y columnas no utilizadas.

Separar condiciones de relación y condiciones de filtrado para mejorar legibilidad y revisión.

Validar joins con recuentos antes y después, búsqueda de duplicados y comparación contra reglas funcionales.

Construir una consulta empresarial con varios joins, cardinalidad controlada y explicación del resultado.

Usar `COUNT`, `SUM`, `AVG`, `MIN`, `MAX` y agregaciones condicionales para crear métricas fiables.

Diseñar `GROUP BY` con la granularidad correcta, evitando mezclar columnas que cambian el nivel real del resultado.

Aplicar `HAVING` para filtrar grupos agregados cuando la condición depende de métricas calculadas.

Diferenciar filtros antes de agrupar y filtros después de agrupar para no alterar resultados por error.

Gestionar nulos en agregaciones, especialmente cuando afectan a promedios, recuentos, importes y métricas de calidad.

Crear indicadores por cliente, producto, periodo, departamento, estado, canal o cualquier dimensión relevante.

Detectar doble conteo cuando se agregan datos después de joins con relaciones no controladas.

Usar agregaciones condicionales para calcular varias métricas en una sola pasada sin consultas repetidas.

Validar resultados agregados contra totales conocidos, muestras manuales y reglas de negocio.

Construir un dataset agregado para reporting con métricas, filtros y granularidad documentada.

Usar subconsultas escalares, de tabla y correlacionadas cuando aportan claridad al problema que se quiere resolver.

Aplicar `EXISTS` para comprobar existencia de filas relacionadas sin necesitar recuperar valores concretos.

Comparar `IN`, `EXISTS`, joins y subconsultas según semántica, nulos, duplicados y rendimiento esperado.

Evitar subconsultas correlacionadas costosas cuando una reescritura con join o agregación resulta más eficiente.

Usar subconsultas para validaciones de negocio, detección de faltantes, reglas de elegibilidad y procesos de limpieza.

Detectar errores por subconsultas escalares que devuelven más de una fila.

Gestionar antijoins con `NOT EXISTS` de forma segura frente a problemas habituales de `NOT IN` con nulos.

Separar subconsultas complejas en CTEs cuando mejora legibilidad, diagnóstico y revisión.

Revisar planes de ejecución para entender cómo el optimizador transforma o ejecuta subconsultas.

Construir consultas de comparación entre datasets usando `EXISTS`, `NOT EXISTS` y subconsultas controladas.

Usar CTEs para estructurar consultas complejas en pasos lógicos, legibles y revisables.

Diferenciar CTEs de tablas temporales, vistas y subconsultas, entendiendo cuándo cada opción es más adecuada.

Crear CTEs encadenadas para limpiar, filtrar, enriquecer, agregar y preparar datos antes del resultado final.

Evitar CTEs innecesarias que solo cambian la forma de la consulta sin mejorar claridad ni rendimiento.

Usar CTEs recursivas para jerarquías, organigramas, categorías, estructuras padre-hijo y dependencias.

Controlar `MAXRECURSION` y condiciones de parada para evitar bucles recursivos no deseados.

Analizar rendimiento de CTEs cuando se referencian varias veces o cuando la consulta se vuelve difícil de optimizar.

Documentar cada CTE con nombres que expresen la transformación que realiza, no nombres genéricos como `cte1`.

Validar jerarquías con ciclos, nodos huérfanos, niveles profundos y datos incompletos.

Construir una consulta recursiva sobre una estructura organizativa con niveles, rutas y detección de errores.

Usar `OVER` con `PARTITION BY` y `ORDER BY` para calcular métricas sin perder detalle de fila.

Aplicar `ROW_NUMBER`, `RANK` y `DENSE_RANK` para rankings, deduplicación, prioridades y selección de registros relevantes.

Usar `LAG` y `LEAD` para comparar registros anteriores y posteriores en series temporales o cambios de estado.

Calcular acumulados, medias móviles, porcentajes y métricas por ventana sin recurrir a subconsultas innecesarias.

Diseñar ventanas con granularidad correcta para clientes, productos, periodos, contratos, sesiones o eventos.

Evitar errores de interpretación cuando `ORDER BY` no es determinista y dos filas tienen el mismo valor de orden.

Combinar funciones de ventana con CTEs para resolver problemas analíticos complejos en pasos legibles.

Medir impacto de funciones de ventana en grandes volúmenes y revisar índices que ayuden a ordenar y particionar.

Crear casos de uso: últimos movimientos, cambios de estado, top N por grupo, duplicados y tendencias.

Construir un análisis avanzado con funciones de ventana para detectar patrones, anomalías y evolución temporal.

Usar `INSERT` para cargar datos desde valores, consultas, staging tables o procesos de integración.

Diseñar `UPDATE` con filtros seguros, joins controlados y validación previa de filas afectadas.

Ejecutar `DELETE` con extrema cautela, validando condiciones, impacto y posibilidad de rollback antes de confirmar cambios.

Usar `MERGE` o alternativas controladas para sincronizar datasets, altas, bajas lógicas y actualizaciones masivas.

Comprobar `@@ROWCOUNT` después de operaciones DML para validar impacto real y detectar comportamientos inesperados.

Evitar modificar datos productivos sin transacción, copia de seguridad lógica, script de validación y plan de reversión.

Diseñar cargas idempotentes que puedan repetirse sin duplicar datos ni alterar estados incorrectamente.

Registrar cambios relevantes en tablas de auditoría o históricos cuando el negocio necesita trazabilidad.

Probar operaciones DML con datos sintéticos, casos límite, duplicados, nulos y conflictos de constraint.

Construir un script completo de actualización controlada con validación previa, transacción, DML y comprobación final.

Comprender `BEGIN TRANSACTION`, `COMMIT` y `ROLLBACK` como mecanismos para controlar atomicidad y recuperación ante errores.

Diseñar transacciones cortas, claras y con el menor número de recursos bloqueados posible.

Entender niveles de aislamiento, lecturas consistentes, bloqueos, esperas, lecturas sucias y fenómenos de concurrencia.

Usar transacciones explícitas en scripts administrativos, cargas y procesos críticos para evitar estados parciales.

Evitar dejar transacciones abiertas por errores de script, sesiones interactivas o procesos que esperan confirmación externa.

Diagnosticar bloqueos mediante vistas de sistema, sesiones, waits, transacciones abiertas y procesos en ejecución.

Gestionar concurrencia en operaciones de asignación, colas, reservas, actualizaciones de estado o procesos batch.

Diseñar reintentos controlados cuando se producen deadlocks o conflictos transitorios.

Documentar qué procedimientos controlan su propia transacción y cuáles delegan el commit al llamador.

Construir un laboratorio de concurrencia con dos sesiones, bloqueos, rollback, commit y análisis de impacto.

Usar `TRY...CATCH` para capturar errores y ejecutar lógica controlada de rollback, logging o propagación.

Extraer información de error con funciones como número, mensaje, severidad, estado, procedimiento y línea.

Usar `THROW` para relanzar errores preservando contexto o generar errores controlados con mensajes claros.

Evitar ocultar errores mediante bloques `CATCH` que solo imprimen mensajes y dejan procesos en estado incierto.

Diseñar mensajes de error útiles para soporte técnico sin exponer datos sensibles, secretos o detalles internos innecesarios.

Combinar manejo de errores con transacciones para garantizar que una operación falla completa o se confirma correctamente.

Diferenciar errores esperados de negocio, errores de validación, errores técnicos y errores críticos de infraestructura.

Registrar fallos con identificador de proceso, usuario, operación, clave de negocio y datos mínimos de diagnóstico.

Probar escenarios de error igual que escenarios de éxito, incluyendo constraints, permisos, conversiones y bloqueos.

Construir una plantilla de script T-SQL con transacción, `TRY...CATCH`, rollback, logging y relanzamiento controlado.

Crear vistas para ofrecer una capa estable de consumo sobre tablas internas, joins complejos o reglas de negocio compartidas.

Diseñar vistas con nombres claros, columnas documentadas y propósito funcional, evitando vistas genéricas sin owner.

Usar vistas para simplificar reporting, BI, APIs internas, seguridad de lectura o compatibilidad con consumidores existentes.

Evitar encapsular consultas demasiado pesadas en vistas que luego se combinan sin control y degradan rendimiento.

Gestionar cambios en vistas como cambios de contrato, especialmente si hay aplicaciones o informes dependientes.

Aplicar permisos sobre vistas para limitar acceso directo a tablas base cuando el consumidor no debe ver todo el modelo.

Revisar vistas anidadas, dependencias ocultas y columnas calculadas que dificultan análisis de planes.

Usar `SCHEMABINDING` cuando el caso lo justifica y se entiende su impacto sobre dependencias y cambios.

Documentar vistas críticas con owner, finalidad, consumidores, filtros de seguridad y reglas de cálculo.

Construir una capa de vistas de consumo para un modelo de ventas, clientes, permisos y reporting.

Crear procedimientos almacenados para encapsular operaciones repetibles, procesos de negocio, cargas, validaciones y tareas administrativas.

Diseñar parámetros de entrada y salida con tipos correctos, valores por defecto razonables y validaciones iniciales.

Separar procedimientos de consulta, procedimientos de modificación, procesos batch y utilidades administrativas.

Evitar procedimientos enormes que mezclan reglas de negocio, reporting, auditoría, mantenimiento y lógica de aplicación.

Controlar el uso de transacciones dentro de procedimientos para no romper flujos de aplicación o procesos superiores.

Devolver resultados y códigos de error de forma predecible para aplicaciones, jobs y herramientas de integración.

Evitar SQL dinámico dentro de procedimientos salvo que exista una necesidad real y se valide de forma segura.

Documentar contrato del procedimiento: propósito, parámetros, efectos sobre datos, permisos, errores y ejemplos.

Probar procedimientos con datos válidos, inválidos, nulos, duplicados, permisos insuficientes y concurrencia.

Construir un procedimiento empresarial con validación, DML, transacción, manejo de errores, logging y pruebas.

Crear funciones escalares cuando una regla o cálculo necesita reutilizarse con entrada y salida bien definidas.

Usar funciones con valores de tabla cuando se necesita devolver conjuntos de filas reutilizables y componibles.

Diferenciar funciones inline y multi-statement, entendiendo su impacto potencial en planes de ejecución y rendimiento.

Evitar funciones escalares costosas en consultas masivas si generan ejecución fila a fila o dificultan optimización.

Diseñar funciones deterministas de negocio para normalización, clasificación, cálculo o transformación simple.

Controlar restricciones de las funciones en cuanto a efectos secundarios, DML, transacciones y operaciones no permitidas.

Documentar cuándo una función puede usarse en consultas analíticas, filtros, columnas calculadas o lógica interna.

Probar funciones con valores nulos, límites, formatos inválidos, precisión numérica y escenarios extremos.

Revisar alternativas cuando una función oculta lógica que sería más clara con CTE, vista, join o columna persistida.

Construir una biblioteca de funciones T-SQL pequeñas, reutilizables, probadas y alineadas con reglas de negocio.

Usar variables escalares para valores de control, parámetros intermedios, flags y cálculos de una rutina.

Crear tablas temporales `#temp` para procesos intermedios que requieren índices, múltiples pasos o volúmenes relevantes.

Usar table variables con criterio, entendiendo sus límites y diferencias frente a tablas temporales.

Diseñar staging tables para cargas, validaciones, errores, conciliaciones y procesos ETL controlados.

Añadir índices temporales cuando un proceso intermedio consulta o cruza muchas filas repetidamente.

Evitar abusar de temporales como sustituto de un diseño de consulta claro o de un modelo de datos adecuado.

Limpiar objetos temporales y documentar la finalidad de cada estructura intermedia.

Medir rendimiento de alternativas: CTE, subconsulta, tabla temporal, table variable y staging persistente.

Crear procesos reejecutables que no dejan basura en tablas de trabajo ni dependen de estados manuales.

Construir una carga por etapas con staging, validación, errores, publicación y resumen final.

Usar constraints como primera línea de integridad para claves, unicidad, obligatoriedad, checks y relaciones.

Crear triggers solo cuando existe una razón clara que no se resuelve mejor con constraints, procedimientos o lógica explícita.

Diferenciar triggers `AFTER` e `INSTEAD OF`, y entender cómo se comportan con operaciones de varias filas.

Evitar triggers que asumen una sola fila modificada, un error frecuente en sistemas empresariales.

Controlar efectos secundarios, recursividad, orden de ejecución, rendimiento y dificultad de depuración en triggers.

Documentar triggers sobre tablas críticas para que desarrollo, DBA y soporte conozcan los efectos automáticos.

Usar triggers para auditoría o reglas muy localizadas cuando el impacto está justificado y probado.

Evitar lógica de negocio compleja y oculta dentro de triggers que sorprende a aplicaciones y procesos batch.

Probar triggers con inserts, updates, deletes, operaciones masivas, errores y rollback.

Refactorizar un trigger problemático hacia una alternativa más explícita, segura y mantenible.

Usar SQL dinámico cuando la estructura de la consulta cambia realmente en tiempo de ejecución, no por comodidad.

Construir sentencias dinámicas con `sp_executesql` y parámetros para evitar inyección SQL y mejorar reutilización de planes.

Validar nombres de tabla, columnas, ordenaciones y fragmentos dinámicos mediante listas permitidas, no concatenación libre.

Evitar concatenar valores recibidos de usuarios, aplicaciones o ficheros sin validación estricta.

Diseñar búsquedas dinámicas con filtros opcionales sin crear consultas imposibles de mantener o planes ineficientes.

Controlar permisos cuando el SQL dinámico ejecuta operaciones sensibles o accede a objetos fuera del contexto esperado.

Registrar sentencias generadas en modo diagnóstico sin exponer datos sensibles o credenciales.

Probar SQL dinámico con entradas válidas, inválidas, maliciosas, largas, nulas y combinaciones de filtros.

Evaluar alternativas como procedimientos parametrizados, consultas estáticas, vistas o generación controlada desde aplicación.

Construir un buscador dinámico seguro con filtros opcionales, orden permitido, paginación y parámetros enlazados.

Usar funciones JSON para validar, leer, modificar y transformar documentos almacenados en columnas o recibidos desde aplicaciones.

Aplicar `ISJSON`, `JSON_VALUE`, `JSON_QUERY`, `JSON_MODIFY` y `OPENJSON` para convertir datos semiestructurados en filas y columnas.

Diseñar modelos híbridos donde lo relacional y lo JSON conviven sin perder integridad, rendimiento ni claridad de contrato.

Evitar guardar todo en JSON cuando el dato necesita constraints, joins, filtros frecuentes o gobierno relacional fuerte.

Crear procesos de ingesta que reciben payloads JSON, validan estructura, extraen campos y registran errores por documento.

Aprovechar mejoras actuales de JSON en SQL Server 2025 cuando el entorno las soporte, validando disponibilidad y estado de preview.

Analizar impacto de índices, columnas calculadas y consultas sobre propiedades JSON frecuentes.

Documentar contratos JSON esperados, versiones, campos obligatorios, campos opcionales y reglas de compatibilidad.

Probar payloads incompletos, inválidos, con arrays, objetos anidados, tipos incorrectos y valores inesperados.

Construir un proceso T-SQL que ingiere JSON, lo normaliza, valida reglas y lo publica en tablas relacionales.

Usar funciones `REGEXP_*` cuando el entorno SQL Server o Azure SQL las soporta para validar, buscar, extraer o reemplazar patrones complejos.

Aplicar `REGEXP_LIKE`, `REGEXP_REPLACE`, `REGEXP_SUBSTR`, `REGEXP_INSTR`, `REGEXP_COUNT` y funciones relacionadas según el caso.

Diferenciar expresiones regulares de `LIKE`, `PATINDEX` y funciones clásicas de texto para elegir la opción más simple y mantenible.

Validar formatos de email, códigos, identificadores, matrículas, teléfonos, referencias o cadenas normalizadas sin abusar de patrones ilegibles.

Usar regex para limpieza de texto, extracción de componentes y detección de patrones en datos recibidos desde sistemas externos.

Controlar compatibilidad de nivel de base de datos y disponibilidad de funciones antes de usar regex en código productivo.

Evitar expresiones regulares excesivamente complejas que nadie puede revisar o que generan costes de rendimiento altos.

Documentar patrones críticos con ejemplos válidos, inválidos y explicación funcional.

Probar regex con datos reales anonimizados, casos extremos, acentos, espacios, caracteres especiales y cadenas largas.

Construir una rutina de calidad de datos con expresiones regulares para normalizar y validar entradas empresariales.

Trabajar con `date`, `datetime2`, `datetimeoffset`, `time` y conversiones entendiendo precisión, zona horaria y formato.

Evitar almacenar fechas como texto, porque complica filtros, ordenación, validación, índices y compatibilidad regional.

Diseñar filtros de fecha con rangos correctos, especialmente cuando existen horas, milisegundos o zonas horarias.

Usar funciones de fecha para calcular periodos, meses, trimestres, semanas, cierres, antigüedad y vencimientos.

Crear tablas calendario cuando el negocio necesita festivos, días laborables, periodos fiscales o lógica de planificación.

Gestionar cambios de estado en el tiempo mediante columnas de vigencia, históricos o tablas temporales cuando procede.

Evitar conversiones implícitas que dependen de idioma, formato de sesión o configuración regional.

Crear métricas temporales con funciones de ventana, acumulados, comparativas y periodos móviles.

Validar resultados temporales con casos límite: fin de mes, año bisiesto, cambio horario, nulos y periodos incompletos.

Construir un modelo de análisis temporal para ventas, incidencias, contratos o procesos operativos.

Comprender las tablas temporales del sistema como mecanismo para mantener historial de cambios asociado a una tabla.

Diseñar escenarios donde se necesita consultar el estado de los datos en un momento pasado o auditar evolución de registros.

Diferenciar auditoría funcional completa de historial temporal automático, entendiendo qué cubre y qué no cubre cada enfoque.

Crear consultas temporales para comparar versiones, detectar cambios, reconstruir estados y analizar evolución.

Evaluar impacto de almacenamiento, retención, crecimiento y rendimiento en tablas con historial.

Definir políticas de retención y archivado para evitar historiales inmanejables.

Controlar permisos sobre datos históricos, especialmente si contienen información sensible que ya no debería consultarse libremente.

Documentar qué tablas requieren historial y por qué, evitando activarlo por defecto sin necesidad.

Integrar tablas temporales con procesos de soporte, auditoría, reporting y análisis de incidencias.

Construir un caso práctico de historial de cambios con consultas “as of”, comparación de versiones y retención.

Trabajar con columnas y variables XML cuando la integración o el sistema legado lo exige.

Usar métodos XML para consultar, extraer, validar y transformar información estructurada en documentos.

Comparar XML y JSON desde interoperabilidad, legibilidad, tamaño, validación, compatibilidad y herramientas consumidoras.

Evitar mantener XML por inercia cuando el contrato puede modernizarse hacia JSON u otro formato más adecuado.

Diseñar procesos que reciben XML desde sistemas externos y lo transforman en tablas relacionales controladas.

Validar XML frente a estructura esperada cuando el contrato exige consistencia estricta.

Gestionar errores de parseo, nodos ausentes, espacios de nombres y tipos incorrectos.

Analizar rendimiento de consultas XML sobre grandes volúmenes antes de usarlo como estrategia masiva.

Documentar contratos XML legacy y planes de transición cuando forman parte de integraciones críticas.

Construir una carga XML de laboratorio con extracción, validación, normalización y registro de errores.

Comprender el tipo `vector` como capacidad actual para almacenar vectores orientados a búsquedas de similitud y aplicaciones de machine learning.

Diseñar escenarios donde una base SQL puede almacenar embeddings relacionados con documentos, productos, incidencias, clientes o conocimiento interno.

Revisar límites, dimensiones, tipos base y compatibilidad antes de incorporar vectores en modelos productivos.

Usar funciones vectoriales cuando el entorno las soporte para calcular distancias, similitud o búsquedas semánticas.

Evitar introducir vectores sin gobernanza de datos, trazabilidad del modelo de embeddings, calidad y control de costes.

Diseñar tablas que combinan datos relacionales, metadatos, texto original, embedding, versión de modelo y permisos de acceso.

Comparar almacenamiento vectorial en SQL Server con alternativas especializadas según volumen, latencia, actualización y arquitectura.

Integrar escenarios de RAG o búsqueda semántica con controles de seguridad, permisos y filtrado por usuario.

Documentar limitaciones, precisión, actualización de embeddings y riesgos de privacidad.

Construir un prototipo de tabla con datos vectoriales y consulta de similitud sobre datos sintéticos.

Comprender índices clustered, nonclustered, únicos, filtrados, columnas incluidas y su relación con patrones de consulta.

Leer planes de ejecución para identificar scans, seeks, joins, sorts, spills, conversiones implícitas y estimaciones incorrectas.

Analizar estadísticas como base de estimación de cardinalidad y toma de decisiones del optimizador.

Diseñar índices alineados con filtros, joins, ordenaciones, agregaciones y consultas críticas.

Evitar crear índices por cada consulta sin medir impacto en escritura, mantenimiento y almacenamiento.

Detectar consultas que no usan índices por funciones sobre columnas, tipos incompatibles o condiciones no sargables.

Usar índices filtrados cuando una consulta trabaja frecuentemente con subconjuntos estables de datos.

Revisar fragmentación, mantenimiento, actualización de estadísticas y efectos sobre rendimiento.

Medir antes y después de cualquier cambio de índice con datos representativos.

Optimizar una consulta lenta usando plan de ejecución, cambios de consulta, índices y validación de resultados.

Priorizar soluciones set-based frente a procesamiento fila a fila cuando el motor puede resolver operaciones completas eficientemente.

Reescribir cursores o bucles innecesarios como joins, agregaciones, `MERGE`, CTEs o operaciones por conjunto.

Detectar patrones no sargables, conversiones implícitas, funciones en filtros y predicados que impiden uso de índices.

Reducir lecturas lógicas, sorts, spools, scans innecesarios y operaciones repetidas mediante reescritura controlada.

Analizar coste real de consultas usando estadísticas de IO, tiempo, planes y métricas de ejecución.

Evitar optimizaciones prematuras sin evidencia, especialmente cambios que hacen la consulta menos legible sin mejora medible.

Diseñar consultas por etapas cuando una única sentencia se vuelve opaca y difícil de diagnosticar.

Revisar impacto de parámetros, sniffing, cardinalidad y distribución de datos sobre planes reutilizados.

Documentar optimizaciones relevantes con problema, evidencia, cambio, resultado y riesgo.

Mejorar una consulta empresarial compleja reduciendo tiempo, lecturas, duplicados y coste de mantenimiento.

Diseñar permisos con mínimos privilegios usando usuarios, roles, esquemas y grants controlados.

Conceder acceso a vistas o procedimientos en lugar de acceso directo a tablas cuando el consumidor no necesita el modelo interno.

Aplicar seguridad por filas cuando distintos usuarios deben ver subconjuntos diferentes del mismo dataset.

Usar enmascaramiento, clasificación o vistas controladas cuando hay datos sensibles, personales o confidenciales.

Evitar credenciales compartidas, usuarios genéricos, permisos excesivos y cuentas técnicas sin trazabilidad.

Revisar quién puede crear objetos, modificar datos, ejecutar procedimientos, consultar auditoría o administrar permisos.

Proteger scripts, logs, errores y exportaciones para no revelar datos sensibles o secretos.

Documentar accesos concedidos con finalidad, owner, entorno, fecha de revisión y criterio de revocación.

Integrar seguridad de T-SQL con políticas corporativas, auditoría, IAM, aplicaciones y gobierno del dato.

Construir un modelo de permisos de laboratorio con roles de lectura, escritura, reporting, administración y auditoría.

Diseñar auditoría para registrar operaciones críticas, cambios de datos, ejecuciones de procesos y acciones administrativas.

Diferenciar auditoría técnica, auditoría funcional, logging de procesos y evidencias de cumplimiento.

Crear tablas de auditoría con usuario, fecha, operación, clave de negocio, valores relevantes y origen de ejecución.

Evitar auditar datos sensibles completos cuando basta con registrar identificadores, hash, resumen o metadatos.

Registrar versiones de scripts y despliegues para saber qué cambió, cuándo, quién lo aprobó y cómo se validó.

Crear consultas de seguimiento sobre cambios, accesos, fallos, procesos batch y anomalías operativas.

Diseñar trazabilidad de extremo a extremo entre aplicación, procedimiento, job, tabla y reporte final.

Gestionar retención, particionado, limpieza y acceso a tablas de auditoría.

Revisar auditoría en procesos regulados, financieros, datos personales o cambios de permisos.

Construir un sistema de auditoría T-SQL para operaciones sensibles con consultas de revisión y reporte.

Diseñar scripts T-SQL para tareas repetibles de mantenimiento, carga, validación, reporting y soporte.

Programar procesos mediante SQL Server Agent o herramientas corporativas equivalentes cuando el entorno lo permita.

Definir pasos, horarios, dependencias, alertas, reintentos y responsables de procesos programados.

Evitar jobs sin owner, sin documentación, sin logging, sin alertas y sin criterio de recuperación.

Crear procesos reejecutables que registran estado, progreso, filas procesadas, errores y resultado final.

Separar lógica de proceso en procedimientos versionados en lugar de pegar scripts largos directamente en jobs.

Gestionar parámetros por entorno para no mezclar rutas, bases, credenciales o destinos productivos.

Monitorizar duración, fallos, bloqueos, crecimiento y variación de resultados en procesos recurrentes.

Documentar runbooks de ejecución manual, diagnóstico, reinicio y rollback de procesos críticos.

Construir un job de laboratorio que ejecuta un procedimiento, registra auditoría y notifica fallos simulados.

Crear datasets de reporting con granularidad clara, nombres de columnas entendibles y reglas de cálculo documentadas.

Preparar vistas, tablas resumen o consultas parametrizadas para herramientas BI como Power BI, Excel o soluciones corporativas.

Evitar consultas BI que bloquean sistemas transaccionales o ejecutan cálculos pesados repetidamente.

Diseñar preagregaciones, snapshots y modelos de consumo cuando los informes requieren rapidez y estabilidad.

Resolver métricas comunes: ventas, margen, recurrencia, cohortes, incidencias, SLA, productividad, inventario o facturación.

Gestionar dimensiones de tiempo, cliente, producto, canal, departamento y estado con criterios consistentes.

Evitar duplicidad de reglas entre T-SQL, modelo semántico, DAX, ETL y aplicaciones.

Validar métricas con usuarios de negocio, totales de control, muestras y conciliaciones.

Documentar datasets certificados con owner, finalidad, refresco, filtros, restricciones y sensibilidad.

Construir una capa de consumo analítica con vistas, agregaciones, métricas y validación de resultados.

Diferenciar SQL Server local, SQL Server en Azure VMs, Azure SQL Database, Azure SQL Managed Instance y SQL database en Fabric.

Entender qué funcionalidades T-SQL son comunes y cuáles pueden variar por plataforma, compatibilidad o nivel de servicio.

Diseñar consultas y objetos pensando en portabilidad cuando una organización trabaja en entornos híbridos.

Revisar limitaciones de administración, jobs, cross-database queries, linked servers, CLR o funcionalidades específicas según plataforma.

Aplicar buenas prácticas de seguridad cloud: identidades, firewall, private endpoints, roles, auditoría y cifrado.

Evaluar costes de consultas, almacenamiento, compute, consumo serverless y patrones analíticos en Azure SQL o Fabric.

Usar T-SQL para trabajar con datos operacionales y analíticos dentro del ecosistema Microsoft Data Platform.

Evitar asumir que un script probado en SQL Server local funcionará igual en Azure SQL sin validar compatibilidad.

Documentar diferencias por entorno en scripts de despliegue, pruebas y operación.

Construir una matriz de compatibilidad T-SQL para decisiones entre SQL Server, Azure SQL y Fabric.

Versionar scripts T-SQL en Git con estructura clara, convenciones de nombres y trazabilidad de cambios.

Separar DDL, DML, datos maestros, procedimientos, funciones, vistas, permisos, pruebas y rollback.

Crear scripts idempotentes cuando conviene, sin ocultar errores reales ni dejar estados inconsistentes.

Diseñar migraciones de base de datos con orden, dependencias, validaciones previas y plan de reversión.

Integrar ejecución de scripts en pipelines CI/CD con compilación, validación, pruebas y revisión de objetos afectados.

Evitar cambios manuales en producción que no quedan reflejados en repositorio ni en proceso de aprobación.

Usar herramientas de comparación o migración de esquema cuando la organización las tenga aprobadas.

Revisar permisos, datos sensibles y scripts destructivos como parte obligatoria de pull requests.

Generar documentación de release con objetos modificados, riesgos, pruebas, rollback y responsables.

Construir un flujo CI/CD de laboratorio para desplegar vistas, procedimientos, permisos y pruebas T-SQL.

Crear pruebas para consultas críticas, vistas, procedimientos, funciones, triggers, cargas y reglas de negocio.

Preparar datos sintéticos con casos de éxito, error, duplicados, nulos, límites, permisos y escenarios de rollback.

Validar resultados con tablas esperadas, recuentos, sumas de control, diferencias y reglas funcionales.

Automatizar pruebas de regresión para evitar que cambios en consultas rompan informes, APIs o procesos batch.

Probar permisos y seguridad verificando qué puede consultar o ejecutar cada rol de laboratorio.

Diseñar pruebas de rendimiento básicas para consultas críticas antes de publicar cambios.

Evitar pruebas que dependen de datos productivos cambiantes, fechas actuales no controladas o ejecución en orden concreto.

Integrar pruebas T-SQL en pipelines o procesos de validación antes de despliegues.

Documentar escenarios cubiertos y huecos pendientes en reglas de negocio complejas.

Construir una suite de pruebas para un conjunto de vistas, procedimientos y procesos de carga.

Definir estándares de formato, alias, indentación, comentarios, nombres, joins, filtros, CTEs y manejo de errores.

Revisar consultas por legibilidad, rendimiento, seguridad, duplicados, tratamiento de nulos y efectos transaccionales.

Crear checklist de pull request para scripts T-SQL con validación de permisos, rollback, pruebas y datos afectados.

Evitar scripts improvisados con nombres ambiguos, `SELECT *`, filtros incompletos o DML sin transacción.

Documentar consultas críticas con finalidad, owner, consumidores, frecuencia, riesgos y criterios de validación.

Detectar deuda T-SQL: procedimientos enormes, vistas anidadas, lógica duplicada, cursores innecesarios y SQL dinámico inseguro.

Revisar cambios de esquema considerando impacto sobre aplicaciones, informes, jobs, permisos y dependencias.

Establecer Definition of Done para cambios T-SQL: versionado, prueba, revisión, rendimiento, seguridad y documentación.

Usar herramientas de análisis, formateo o revisión cuando la empresa las tenga aprobadas.

Construir una guía corporativa de T-SQL con ejemplos correctos, anti-patrones y criterios de revisión.

Auditar bases legacy con procedimientos grandes, vistas opacas, cursores lentos, triggers ocultos y scripts manuales.

Identificar objetos críticos por uso, dependencias, frecuencia de fallos, rendimiento, consumidores y riesgo de negocio.

Crear pruebas de caracterización antes de modificar consultas cuyo comportamiento no está documentado.

Separar lógica duplicada en vistas, funciones, procedimientos o capas de aplicación según convenga.

Reescribir cursores y bucles innecesarios como operaciones set-based cuando el rendimiento y claridad mejoran.

Reducir SQL dinámico inseguro, permisos excesivos, errores silenciados y dependencias sobre usuarios personales.

Documentar objetos legacy con propósito, entradas, salidas, tablas afectadas, jobs, consumidores y riesgos.

Modernizar por fases pequeñas, con validación, métricas, rollback y comunicación a consumidores.

Priorizar refactorización por impacto operativo, coste de mantenimiento, problemas de rendimiento y cambios frecuentes.

Ejecutar una modernización guiada de un módulo T-SQL legacy con pruebas, documentación y mejora de rendimiento.

Diseñar una base de datos de laboratorio con esquemas, tablas, relaciones, constraints, datos sintéticos y modelo de seguridad.

Crear consultas avanzadas con joins, CTEs, funciones de ventana, agregaciones, filtros, paginación y validación de resultados.

Implementar una capa de vistas de consumo para reporting, APIs internas, seguridad de lectura y contratos estables.

Crear procedimientos almacenados con parámetros, transacciones, manejo de errores, logging y validación de filas afectadas.

Implementar funciones reutilizables para reglas de negocio, clasificación, normalización y transformación de datos.

Diseñar un proceso de carga con staging, validación, errores por fila, publicación, auditoría y resumen final.

Aplicar índices y optimizaciones basadas en planes de ejecución, lecturas lógicas y métricas antes/después.

Incorporar JSON, expresiones regulares o vectores cuando el caso de negocio lo justifique y el entorno lo soporte.

Versionar todos los scripts en Git con despliegue, rollback, pruebas, documentación y checklist de revisión.

Presentar la solución final con modelo, consultas, procedimientos, seguridad, rendimiento, auditoría, pruebas y plan de mantenimiento.