97 preguntas de entrevista de MySQL que deberías hacer para contratar a los mejores ingenieros

Las habilidades de SQL son fundamentales en muchos roles técnicos, desde analistas de datos hasta administradores de bases de datos. Por lo tanto, evaluar eficazmente las habilidades de SQL de un candidato es clave para garantizar que pueda satisfacer las demandas del puesto; al igual que identificar las habilidades adecuadas para un ingeniero de datos.

Esta publicación de blog proporciona una gama de preguntas de entrevista de SQL, categorizadas por nivel de habilidad: básico, intermedio, avanzado y experto, además de preguntas de opción múltiple (MCQ). Encontrará preguntas cuidadosamente seleccionadas diseñadas para evaluar la competencia de SQL y las habilidades de resolución de problemas de los candidatos.

Al usar estas preguntas, evaluará con confianza el conocimiento de SQL y las habilidades prácticas de los candidatos, y reducirá el tiempo de contratación al usar las evaluaciones de SQL de Adaface antes de la entrevista.

Tabla de contenido

Preguntas de entrevista de consultas SQL básicas

Preguntas de entrevista de consultas SQL intermedias

Preguntas de entrevista de consultas SQL avanzadas

Preguntas de entrevista de consultas SQL expertas

MCQ de consultas SQL

¿Qué habilidades de consultas SQL debe evaluar durante la fase de entrevista?

3 consejos para usar preguntas de entrevista de consultas SQL

Contrate al mejor talento de SQL con evaluaciones específicas

Descargue la plantilla de preguntas de entrevista de consultas SQL en múltiples formatos

Preguntas de entrevista de consultas SQL básicas

1. Imagina que tienes una tabla de juguetes. ¿Cómo le pides a la computadora que te muestre todos los juguetes que son rojos?

Suponiendo que estamos usando SQL, usarías una declaración SELECT con una cláusula WHERE para filtrar por color. Se vería algo así:

SELECT * FROM juguetes WHERE color = 'rojo';

Esta consulta SQL selecciona todas las columnas (*) de la tabla juguetes, pero solo incluye las filas donde la columna color tiene el valor 'rojo'.

2. Digamos que tienes una lista de estudiantes y sus edades. ¿Cómo encontrarías al estudiante mayor?

Para encontrar al estudiante mayor, iteraría a través de la lista, haciendo un seguimiento del estudiante mayor encontrado hasta ahora y su edad. Para cada estudiante, compararía su edad con la edad del estudiante mayor actual. Si el estudiante actual es mayor, actualizaría al estudiante mayor. Al final de la iteración, la variable contendría al estudiante mayor.

En Python, esto se puede hacer usando un bucle:

estudiantes = [{"nombre": "Alicia", "edad": 20}, {"nombre": "Bob", "edad": 22}, {"nombre": "Carlos", "edad": 19}] estudiante_mayor = estudiantes[0] for estudiante in estudiantes: if estudiante["edad"] > estudiante_mayor["edad"]: estudiante_mayor = estudiante print(estudiante_mayor)

3. Si tiene una tabla de libros, ¿cómo puede encontrar todos los libros escritos por 'Autor X'?

Para encontrar todos los libros escritos por 'Autor X' de una tabla de libros, usaría una consulta SQL con una cláusula WHERE. Suponiendo que su tabla se llama libros y tiene una columna llamada autor, la consulta se vería así:

SELECT * FROM libros WHERE autor = 'Autor X';

Esta consulta selecciona todas las columnas (*) de la tabla libros donde el valor de la columna autor es igual a 'Autor X'. El resultado será una lista de todos los libros escritos por ese autor.

4. Suponga que tiene una tabla de pedidos de clientes. ¿Cómo enumeraría todos los pedidos realizados ayer?

Para enumerar todos los pedidos realizados ayer, usaría una consulta SQL similar a la siguiente:

SELECT * FROM Pedidos WHERE FechaPedido = CURRENT_DATE - INTERVAL '1 day';

Esta consulta asume que OrderDate es la columna que almacena la fecha del pedido. La parte CURRENT_DATE - INTERVAL '1 day' calcula la fecha de ayer. Si el sistema de base de datos utiliza una función de fecha diferente (por ejemplo, DATE() en MySQL o GETDATE() en SQL Server), la consulta deberá ajustarse en consecuencia. Además, la consulta anterior devuelve solo la fecha, pero es posible que deba ajustar el formato de la columna de fecha y hora a solo fecha para la comparación, dependiendo de su sistema de base de datos.

5. Tiene una tabla de productos con precios. ¿Cómo encuentra el producto con el precio más alto?

Para encontrar el producto con el precio más alto, normalmente usaría SQL. Suponiendo que su tabla se llama productos y tiene las columnas nombre_producto y precio, la consulta se vería así:

SELECT nombre_producto, precio FROM productos ORDER BY precio DESC LIMIT 1;

Esta consulta ordena la tabla por la columna precio en orden descendente y luego limita el resultado a la primera fila, que contiene el producto con el precio más alto. Algunas bases de datos pueden ofrecer formas alternativas de lograr el mismo resultado, como el uso de una función MAX() en una subconsulta, pero el enfoque anterior es generalmente eficiente y legible.

6. Si tiene una tabla de empleados, ¿cómo los enumera en orden alfabético por apellido?

Suponiendo que su tabla de empleados tiene columnas como nombre y apellido, puede usar una consulta SQL como esta:

SELECT * FROM empleados ORDER BY apellido ASC;

Esta consulta selecciona todas las columnas (*) de la tabla empleados y ordena los resultados alfabéticamente en orden ascendente (ASC) en función de los valores de la columna apellido.

7. Imagine una tabla de canciones. ¿Cómo encuentra todas las canciones de más de 3 minutos?

Suponiendo que la tabla se llama canciones y tiene una columna duracion_segundos que representa la duración de la canción en segundos, la siguiente consulta SQL recuperaría todas las canciones de más de 3 minutos (180 segundos):

SELECCIONA * DE canciones DONDE duración_segundos > 180;

Esta consulta selecciona todas las columnas (*) de la tabla canciones donde la columna duración_segundos es mayor que 180.

8. Si hay una tabla con detalles del cliente y otra con información de pedidos, ¿cómo recuperaría el nombre del cliente junto con lo que pidió el cliente?

Para recuperar el nombre del cliente junto con los detalles del pedido de dos tablas, una con detalles del cliente y otra con información de pedidos, normalmente usaría una operación SQL JOIN. Suponiendo que las tablas se llaman Clientes y Pedidos, y comparten una columna común como IDCliente, la consulta sería así:

SELECCIONA c.NombreCliente, o.DetallesPedido DE Clientes c UNE Pedidos o EN c.IDCliente = o.IDCliente;

Esta consulta une la tabla Clientes (alias c) con la tabla Pedidos (alias o) basada en el IDCliente. Luego selecciona el NombreCliente de la tabla Clientes y los DetallesPedido de la tabla Pedidos para cada fila coincidente.

9. Tiene una tabla de transacciones. ¿Cómo encuentra la cantidad total de todas las transacciones?

Para encontrar la cantidad total de todas las transacciones en una tabla, usaría la función agregada SUM() en SQL.

SELECCIONA SUM(cantidad_transacción) COMO cantidad_total DE transacciones;

Reemplace cantidad_transacción con el nombre real de la columna que contiene las cantidades de transacción en su tabla transacciones. La parte COMO cantidad_total es opcional; solo da un nombre a la suma resultante.

10. Dada una tabla de eventos con horas de inicio y finalización, ¿cómo puede listar todos los eventos que ocurren en una fecha específica?

Para listar todos los eventos que ocurren en una fecha específica, necesita consultar la tabla y filtrar los resultados en función de las horas de inicio y finalización del evento. Suponiendo que su tabla tiene las columnas start_time y end_time (ambas con tipos de datos de fecha y hora apropiados), y quiere encontrar eventos que ocurren en una fecha, digamos '2024-03-15', puede usar la siguiente lógica similar a SQL:

SELECT * FROM events WHERE start_time <= '2024-03-15 23:59:59' AND end_time >= '2024-03-15 00:00:00';

Esta consulta selecciona todos los eventos donde el start_time es anterior al final de la fecha dada, y el end_time es posterior al inicio de la fecha dada. Esto asegura que los eventos que comienzan antes, terminan después o ocurren completamente dentro de la fecha especificada se incluyan en los resultados. Reemplace '2024-03-15' con la fecha deseada.

11. Supongamos que tiene una lista de productos con sus precios y cantidades. ¿Cómo calcula el valor total de cada producto (precio por cantidad)?

Para calcular el valor total de cada producto, simplemente multiplique el precio del producto por su cantidad. Por ejemplo, si un producto tiene un precio de $10 y una cantidad de 5, el valor total es $10 * 5 = $50.

Si está trabajando con una lista o matriz de productos, iteraría a través de la lista y aplicaría este cálculo a cada producto. En Python, esto podría verse así:

products = [{"name": "A", "price": 10, "quantity": 5}, {"name": "B", "price": 20, "quantity": 2}] for product in products: total_value = product["price"] * product["quantity"] print(f"Valor total de {product['name']}: ${total_value}")

12. Si tienes una tabla de ciudades y sus poblaciones, ¿cómo puedes encontrar la población promedio de todas las ciudades?

Para encontrar la población promedio de todas las ciudades, sumarías la población de cada ciudad y luego dividirías por el número total de ciudades. Esto se puede hacer usando SQL con los siguientes pasos:

• Usa la función agregada SUM() para calcular la población total de todas las ciudades.
• Usa la función agregada COUNT(*) para contar el número total de ciudades.
• Divide la población total por el número total de ciudades para obtener el promedio. Por ejemplo:

SELECT SUM(population) / COUNT(*) AS average_population FROM cities;

13. Imagina una tabla de entradas de blog. ¿Cómo seleccionas todas las columnas de datos de las entradas del blog?

Para seleccionar todas las columnas de una tabla llamada blogposts, usarías la siguiente consulta SQL:

SELECT * FROM blogposts;

El símbolo * es un comodín que representa todas las columnas de la tabla. Esta consulta recupera cada columna (por ejemplo, id, title, content, author, date_published) para cada fila de la tabla blogposts.

14. ¿Cómo recuperarías datos de la tabla 'employees', pero solo incluirías los registros donde el 'department' es 'Sales'?

Para recuperar datos de la tabla 'employees' donde el 'department' es 'Sales', usarías una consulta SQL con una cláusula WHERE. Aquí hay un ejemplo:

SELECT * FROM employees WHERE department = 'Sales';

Esta consulta selecciona todas las columnas (*) de la tabla 'employees', pero filtra los resultados para incluir solo las filas donde el valor en la columna 'department' es igual a 'Sales'.

15. Si deseas ordenar la tabla 'products' por 'price' en orden descendente, ¿qué consulta SQL usarías?

Para ordenar la tabla 'products' por 'price' en orden descendente, usarías la siguiente consulta SQL:

SELECT * FROM products ORDER BY price DESC;

La cláusula ORDER BY se utiliza para ordenar el conjunto de resultados. La palabra clave DESC especifica que la ordenación debe ser descendente. Si quisiera orden ascendente (que es la predeterminada), usaría ASC o omitiría la palabra clave.

16. Si tiene una tabla de elementos con una columna de categoría, ¿cómo encuentra cuántos elementos hay en cada categoría?

Para encontrar cuántos elementos hay en cada categoría en una tabla, usaría una cláusula GROUP BY en SQL. Esta cláusula agrupa las filas que tienen el mismo valor en una columna especificada en filas de resumen, como contar las apariciones de cada categoría.

Por ejemplo, si su tabla se llama items y tiene una columna llamada category, la consulta se vería así:

SELECT category, COUNT(*) AS item_count FROM items GROUP BY category;

Esta consulta selecciona la category y el conteo de elementos (COUNT(*)) para cada categoría. La cláusula GROUP BY category asegura que el conteo se calcule por separado para cada categoría distinta.

17. Explique cómo encontraría el segundo salario más alto de una tabla de empleados.

Para encontrar el segundo salario más alto de una tabla de empleados, puede usar SQL. Un enfoque común implica el uso de una subconsulta o funciones de ventana. Usando una subconsulta, primero encontraría el salario máximo y luego seleccionaría el salario máximo que es menor que el salario máximo.

SELECCIONA MAX(salario) DE empleado DONDE salario < (SELECCIONA MAX(salario) DE empleado);

Alternativamente, usando funciones de ventana:

SELECCIONA salario DE (SELECCIONA salario, DENSE_RANK() OVER (ORDER BY salario DESC) AS rank_num DE empleado) AS salarios_clasificados DONDE rank_num = 2 LÍMITE 1;

Este enfoque clasifica los salarios en orden descendente y selecciona el salario con rango 2.

18. Dadas dos tablas, 'clientes' y 'pedidos', ¿cómo las combinarías para mostrar la información de cada cliente junto con los detalles de sus pedidos?

Para combinar las tablas clientes y pedidos y mostrar la información del cliente junto con los detalles del pedido, normalmente se utiliza una operación JOIN en SQL. Específicamente, un LEFT JOIN o INNER JOIN son opciones comunes dependiendo del resultado deseado. Un INNER JOIN solo devolverá filas donde haya una coincidencia en ambas tablas. Un LEFT JOIN devolverá todas las filas de la tabla clientes y las filas coincidentes de la tabla pedidos. Si no hay un pedido coincidente para un cliente, las columnas de detalles del pedido contendrán valores NULL.

Aquí hay un ejemplo de consulta SQL asumiendo que ambas tablas tienen una columna común llamada customer_id:

SELECCIONA clientes., pedidos. DE clientes LEFT JOIN pedidos EN clientes.customer_id = pedidos.customer_id;

19. ¿Cómo se escribe una consulta para recuperar solo las entradas únicas de una columna particular en una tabla?

Para recuperar solo las entradas únicas de una columna particular en una tabla, puedes usar la palabra clave DISTINCT en SQL. La sintaxis básica es:

SELECCIONA DISTINCT nombre_columna DE nombre_tabla;

Esta consulta devolverá una lista de todos los valores distintos presentes en la columna especificada, eliminando efectivamente cualquier entrada duplicada. Por ejemplo, si tiene una tabla llamada 'Clientes' y desea recuperar todas las ciudades únicas de la columna 'Ciudad', la consulta sería SELECT DISTINCT City FROM Clientes;

20. Si tiene una columna de fecha, ¿cómo puede recuperar registros de entradas solo en los últimos 7 días?

Para recuperar registros de una columna de fecha solo para entradas en los últimos 7 días, normalmente usaría una cláusula WHERE en su consulta SQL que compara la columna de fecha con la fecha actual menos 7 días.

Por ejemplo, suponiendo que su columna de fecha se llama columna_fecha y su tabla se llama su_tabla, la consulta SQL se vería así:

SELECT * FROM su_tabla WHERE columna_fecha >= DATE('now', '-7 days');

Esta consulta selecciona todos los registros de su_tabla donde la columna_fecha está dentro de los últimos 7 días, incluido hoy.

21. Tiene datos de clientes en una tabla y datos de pedidos en otra. ¿Cómo encontraría a todos los clientes que han realizado al menos un pedido?

Para encontrar todos los clientes que han realizado al menos un pedido, usaría una operación JOIN entre las tablas de clientes y pedidos. Asumiendo que la tabla de clientes tiene un customer_id y la tabla de pedidos tiene un customer_id que hace referencia al cliente, una consulta SQL se vería así:

SELECT DISTINCT c.customer_id FROM customers c JOIN orders o ON c.customer_id = o.customer_id;

Esta consulta une las dos tablas basándose en el customer_id. La palabra clave DISTINCT asegura que cada cliente solo se enumere una vez, incluso si ha realizado múltiples pedidos. Si no tiene SQL, también puede usar pandas/spark o cualquier otra herramienta de procesamiento de datos para lograr el mismo resultado usando una lógica similar.

Preguntas de entrevista sobre consultas SQL intermedias

1. ¿Cómo encontraría todos los empleados que ganan más que el salario promedio en su departamento?

Para encontrar todos los empleados que ganan más que el salario promedio en su departamento, puede usar SQL. El enfoque general implica usar una subconsulta o una función de ventana.

Aquí hay un ejemplo usando una subconsulta:

SELECT employee_name, salary, department FROM employees e WHERE salary > ( SELECT AVG(salary) FROM employees WHERE department = e.department );

Alternativamente, usando una función de ventana:

SELECT employee_name, salary, department FROM ( SELECT employee_name, salary, department, AVG(salary) OVER (PARTITION BY department) as avg_dept_salary FROM employees ) AS subquery WHERE salary > avg_dept_salary;

Ambas consultas logran el mismo objetivo, pero el enfoque de la función de ventana a veces puede ser más eficiente para conjuntos de datos más grandes.

2. Escriba una consulta para identificar a los clientes que han realizado pedidos en días consecutivos.

Para identificar a los clientes que han realizado pedidos en días consecutivos, puede usar una auto-unión o funciones de ventana. Aquí hay un ejemplo usando SQL con funciones de ventana:

SELECT DISTINCT customer_id FROM ( SELECT customer_id, order_date, LAG(order_date, 1, order_date) OVER (PARTITION BY customer_id ORDER BY order_date) as prev_order_date FROM orders ) sub WHERE DATEDIFF(order_date, prev_order_date) = 1;

Esta consulta usa la función de ventana LAG para obtener la fecha del pedido anterior para cada cliente. Luego, filtra las filas donde la diferencia entre la fecha del pedido actual y la fecha del pedido anterior es exactamente 1 día. El SELECT DISTINCT externo asegura que cada cliente solo se enumere una vez.

3. ¿Puede explicar cómo usar las funciones de ventana para calcular un promedio móvil de ventas durante un período de 7 días?

Para calcular un promedio móvil de ventas de 7 días utilizando funciones de ventana, normalmente usaría SQL. La clave es la función agregada AVG() combinada con la cláusula OVER() para definir la ventana. Dentro de OVER(), especifica ORDER BY para definir el orden y ROWS BETWEEN para definir el marco de la ventana, en este caso, 6 días anteriores y el día actual.

Aquí tienes un ejemplo de consulta SQL:

SELECT sale_date, sales_amount, AVG(sales_amount) OVER (ORDER BY sale_date ASC ROWS BETWEEN 6 PRECEDING AND CURRENT ROW) AS rolling_avg FROM sales_table;

Esta consulta calcula el promedio de sales_amount para cada sale_date, considerando el día actual y los 6 días anteriores.

4. ¿Cómo recuperarías los 3 productos principales en cada categoría según sus cifras de ventas?

Para recuperar los 3 productos principales en cada categoría según las cifras de ventas, normalmente usaría una función de ventana en SQL. Suponiendo que tienes una tabla llamada products con columnas como category_id, product_id, y sales, la consulta se vería así:

SELECT category_id, product_id, sales FROM ( SELECT category_id, product_id, sales, RANK() OVER (PARTITION BY category_id ORDER BY sales DESC) as sales_rank FROM products ) ranked_products WHERE sales_rank <= 3;

Esta consulta primero clasifica los productos dentro de cada categoría basándose en las ventas en orden descendente, utilizando la función de ventana RANK(). Luego, selecciona solo aquellos productos donde el rango es menor o igual a 3, dándote efectivamente los 3 productos principales por categoría. La cláusula PARTITION BY asegura que la clasificación se realice por separado para cada categoría.

5. Describe una consulta SQL para encontrar el segundo salario más alto en una empresa.

Para encontrar el segundo salario más alto, puedes usar una subconsulta o funciones de ventana.

Usando una subconsulta:

SELECT MAX(salario) FROM empleado WHERE salario < (SELECT MAX(salario) FROM empleado);

Usando funciones de ventana (más robusto para manejar casos extremos como empates):

SELECT salario FROM ( SELECT salario, DENSE_RANK() OVER (ORDER BY salario DESC) as rango_salario FROM empleado ) AS salarios_clasificados WHERE rango_salario = 2;

El enfoque de la función de ventana generalmente se prefiere porque puede manejar escenarios donde múltiples empleados podrían tener el mismo salario más alto, asegurando que aún recuperes el segundo salario distinto.

6. Explica cómo identificar registros duplicados en una tabla basándose en columnas específicas.

Para identificar registros duplicados en una tabla basándose en columnas específicas, puedes usar consultas SQL. La idea básica es agrupar los datos por las columnas que quieres verificar para duplicados y luego contar las ocurrencias de cada grupo. Si algún grupo tiene un conteo mayor a 1, indica registros duplicados.

Aquí hay un enfoque SQL general:

SELECT columna1, columna2, COUNT() FROM nombre_tabla GROUP BY columna1, columna2 HAVING COUNT() > 1;

Reemplaza columna1, columna2 con los nombres de las columnas que quieres verificar para duplicados. La cláusula HAVING COUNT(*) > 1 filtra los resultados para mostrar solo aquellos grupos (combinaciones de valores de columna1 y columna2) que aparecen más de una vez en la tabla.

7. Escribe una consulta para pivotar una tabla, transformando valores de filas en encabezados de columna.

Pivotar datos transforma valores de filas en encabezados de columna. La sintaxis exacta varía dependiendo del sistema de base de datos.

Por ejemplo, en SQL Server, podrías usar el operador PIVOT:

SELECT * FROM ( SELECT categoría, producto, ventas FROM TablaVentas ) AS TablaFuente PIVOT ( SUM(ventas) FOR categoría IN ([Categoría1], [Categoría2], [Categoría3]) -- especifica todas las categorías posibles ) AS TablaPivot;

En otras bases de datos como MySQL, podrías necesitar usar agregación condicional:

SELECT producto, SUM(CASE WHEN categoria = 'Category1' THEN ventas ELSE 0 END) AS Category1, SUM(CASE WHEN categoria = 'Category2' THEN ventas ELSE 0 END) AS Category2, SUM(CASE WHEN categoria = 'Category3' THEN ventas ELSE 0 END) AS Category3 FROM TablaDeVentas GROUP BY producto;

8. ¿Cómo se puede calcular la distribución acumulada de los salarios dentro de una empresa?

Para calcular la distribución acumulada de los salarios, se necesita un conjunto de datos de todos los salarios. Primero, se ordenan los salarios en orden ascendente. Luego, para cada salario, se calcula la probabilidad acumulada dividiendo su rango (posición en la lista ordenada) por el número total de salarios. Este resultado representa la proporción de empleados que ganan igual o menos que ese salario. El resultado es la distribución acumulada.

Por ejemplo, si se tienen 100 salarios, el empleado con el salario más bajo tiene una probabilidad acumulada de 1/100 = 0,01, lo que significa que el 1% de los empleados gana igual o menos que ese salario. El empleado en el medio (50ª posición) tiene una probabilidad acumulada de 50/100 = 0,5, o el 50%. El empleado mejor pagado tendría una probabilidad acumulada de 1,0 (100%). Esto se puede visualizar fácilmente con un gráfico de función de distribución acumulada (CDF).

9. Diseñe una consulta para encontrar todos los departamentos donde el salario promedio es superior al promedio de la empresa.

SELECT departamento FROM empleados GROUP BY departamento HAVING AVG(salario) > (SELECT AVG(salario) FROM empleados);

Esta consulta primero calcula el salario promedio para cada departamento utilizando GROUP BY y AVG(salario). Luego, la cláusula HAVING filtra estos departamentos, manteniendo solo aquellos donde el salario promedio es mayor que el salario promedio general de la empresa (calculado por la subconsulta SELECT AVG(salario) FROM empleados).

10. ¿Cómo recuperaría registros que existen en una tabla pero no en otra, basándose en una clave común?

Para recuperar registros que existen en una tabla (Tabla A) pero no en otra (Tabla B) basándose en una clave común, se puede usar un LEFT JOIN o una cláusula NOT EXISTS en SQL. Un LEFT JOIN incluye todas las filas de la tabla izquierda (Tabla A) y las filas coincidentes de la tabla derecha (Tabla B). Al filtrar las filas donde la columna de unión de la tabla derecha es NULL, se pueden identificar los registros presentes solo en la Tabla A.

Alternativamente, la cláusula NOT EXISTS verifica la ausencia de registros coincidentes en la Tabla B para cada registro en la Tabla A. Este enfoque es a menudo más eficiente, especialmente con la indexación adecuada.

Ejemplo usando LEFT JOIN:

SELECT A.* FROM TablaA A LEFT JOIN TablaB B ON A.ClaveComún = B.ClaveComún WHERE B.ClaveComún IS NULL;

Ejemplo usando NOT EXISTS:

SELECT A.* FROM TablaA A WHERE NOT EXISTS (SELECT 1 FROM TablaB B WHERE A.ClaveComún = B.ClaveComún);

11. Explique cómo usar las Expresiones de Tabla Común (CTEs) para resolver un problema de datos jerárquicos, como encontrar todos los descendientes de un nodo en una estructura de árbol.

Las CTEs proporcionan una forma limpia y eficiente de recorrer datos jerárquicos. Para encontrar todos los descendientes de un nodo, se puede usar una CTE recursiva. La CTE consta de dos partes: un miembro ancla y un miembro recursivo. El miembro ancla selecciona el nodo inicial (el nodo raíz para encontrar todos los descendientes). El miembro recursivo luego une la CTE con la tabla original para encontrar los hijos de los nodos seleccionados previamente.

Aquí hay un ejemplo general:

WITH RECURSIVE Descendientes AS ( SELECT id, parent_id, nombre FROM tu_tabla WHERE id = 'id_nodo_objetivo' -- Miembro ancla: comenzar desde el nodo objetivo UNION ALL SELECT t.id, t.parent_id, t.nombre FROM tu_tabla t INNER JOIN Descendientes d ON t.parent_id = d.id -- Miembro recursivo: encontrar hijos ) SELECT * FROM Descendientes;

tu_tabla contiene los datos jerárquicos, id es el identificador del nodo, y parent_id representa el padre de un nodo dado. La sentencia SELECT inicial recupera el nodo objetivo. El UNION ALL combina la selección inicial con los resultados del paso recursivo. El paso recursivo une tu_tabla con el CTE (Descendants) para encontrar nodos hijos. La recursión continúa hasta que no se encuentren más descendientes.

12. Escriba una consulta para identificar la racha más larga de días consecutivos que un cliente ha realizado pedidos.

Para identificar la racha más larga de días consecutivos en que un cliente ha realizado pedidos, puede usar SQL. Aquí hay un enfoque general:

WITH RankedOrders AS ( SELECT customer_id, order_date, ROW_NUMBER() OVER (PARTITION BY customer_id ORDER BY order_date) AS rn FROM orders GROUP BY customer_id, order_date -- gestiona múltiples pedidos en el mismo día ), ConsecutiveDays AS ( SELECT customer_id, order_date, DATE(order_date, '-' || (rn - 1) || ' days') AS date_group FROM RankedOrders ), Streaks AS ( SELECT customer_id, date_group, COUNT(*) AS streak_length FROM ConsecutiveDays GROUP BY customer_id, date_group ) SELECT customer_id, MAX(streak_length) AS longest_streak FROM Streaks GROUP BY customer_id ORDER BY longest_streak DESC;

Primero, asignamos una clasificación a cada fecha de pedido para cada cliente. Luego, calculamos un grupo_de_fechas restando la clasificación menos uno de la fecha del pedido. Las fechas consecutivas tendrán el mismo grupo_de_fechas. Finalmente, agrupamos por customer_id y grupo_de_fechas para calcular la longitud_de_la_racha y encontrar la racha máxima para cada cliente.

13. ¿Cómo implementaría la paginación en una consulta SQL para recuperar registros en lotes?

La paginación en SQL se implementa típicamente utilizando las cláusulas LIMIT y OFFSET. LIMIT especifica el número máximo de filas a devolver, mientras que OFFSET especifica el número de filas a omitir desde el principio del conjunto de resultados.

Por ejemplo, para recuperar los registros 11-20 (un lote de 10 registros a partir del registro 11), la consulta se vería así:

SELECT * FROM nombre_de_la_tabla ORDER BY id LIMIT 10 OFFSET 10;

En esta consulta LIMIT 10 restringe el número de filas devueltas a 10, y OFFSET 10 omite las primeras 10 filas. Esto es adecuado para una sola base de datos. Use un método de paginación keyset si desea escalar a múltiples fragmentos de base de datos.

14. Describa un escenario donde usaría una CTE recursiva y proporcione una consulta de ejemplo.

Una CTE recursiva es útil cuando necesita consultar datos jerárquicos o estructurados en árbol. Por ejemplo, imagine una tabla de empleados donde cada empleado puede reportar a otro empleado (formando una jerarquía de gestión). Si necesita encontrar todos los subordinados de un gerente dado, una CTE recursiva es un enfoque eficiente.

CON RECURSIVIDAD JerarquíaEmpleados AS ( SELECT id, nombre, manager_id, 0 AS nivel FROM Empleados WHERE id = 'specific_manager_id' -- Comienza con el gerente específico UNION ALL SELECT e.id, e.nombre, e.manager_id, eh.nivel + 1 FROM Empleados e INNER JOIN JerarquíaEmpleados eh ON e.manager_id = eh.id -- Encuentra subordinados ) SELECT id, nombre, nivel FROM JerarquíaEmpleados;

15. Explique cómo optimizar una consulta SQL de ejecución lenta. ¿Qué herramientas y técnicas usaría?

Para optimizar una consulta SQL de ejecución lenta, comenzaría por identificar el cuello de botella. Usaría herramientas como el analizador del plan de ejecución de consultas de la base de datos (por ejemplo, EXPLICAR en MySQL o PostgreSQL) para comprender cómo la base de datos está ejecutando la consulta y señalar operaciones lentas, como escaneos completos de tablas o uniones ineficientes. Las técnicas comunes incluyen:

• Optimización de índices: Asegurar que existan índices apropiados en las columnas utilizadas en las cláusulas WHERE, las condiciones JOIN y las cláusulas ORDER BY. Agregar, eliminar o modificar índices basados en el plan de ejecución de la consulta puede mejorar significativamente el rendimiento.
• Reescritura de consultas: Reestructurar la consulta para que sea más eficiente. Esto podría implicar simplificar las cláusulas WHERE complejas, evitar SELECT *, usar JOIN en lugar de subconsultas (o viceversa, dependiendo del contexto) y optimizar las operaciones GROUP BY y ORDER BY.
• Particionamiento de datos: Para tablas grandes, la partición de datos puede reducir la cantidad de datos escaneados por la consulta.
• Almacenamiento en caché: Implementar mecanismos de almacenamiento en caché (por ejemplo, usando almacenamiento en caché a nivel de base de datos o una capa de almacenamiento en caché externa como Redis) para almacenar datos a los que se accede con frecuencia.
• Actualizaciones de hardware: Si el servidor de la base de datos está limitado en recursos (CPU, memoria, E/S de disco), la actualización del hardware puede mejorar el rendimiento general.
• Actualizaciones de estadísticas: Asegurar que el optimizador de la base de datos tenga estadísticas actualizadas sobre la distribución de datos en las tablas. Estas estadísticas se utilizan para generar planes de ejecución eficientes.
• Analizar patrones de consulta: Identificar consultas lentas comunes y optimizarlas o rediseñar la funcionalidad relacionada.

También utilizaría herramientas de monitoreo de bases de datos para observar el rendimiento de las consultas a lo largo del tiempo e identificar cualquier problema recurrente. Perfilaría la consulta con el plan de ejecución con frecuencia para observar las diferencias a medida que implementaba nuevos índices o reescribía la consulta.

16. ¿Cómo se puede encontrar el cambio porcentual en las ventas de un mes a otro para cada producto?

Para encontrar el cambio porcentual en las ventas de un mes a otro para cada producto, se puede utilizar la siguiente fórmula:

• Cambio Porcentual = ((Ventas del Mes Actual - Ventas del Mes Anterior) / Ventas del Mes Anterior) * 100

Esta fórmula se aplicaría a cada producto individualmente. Por ejemplo, si el Producto A tuvo ventas de 100 en enero y 120 en febrero, el cambio porcentual sería ((120 - 100) / 100) * 100 = 20%. Este cálculo se repetiría para cada producto y cada comparación de mes a mes.

17. Escribe una consulta que determine si dos rangos de fechas se superponen.

Para determinar si dos rangos de fechas se superponen, puedes usar la siguiente lógica. Digamos que tenemos dos rangos, Rango A (inicio_a, fin_a) y Rango B (inicio_b, fin_b). Los rangos se superponen si y solo si: inicio_a <= fin_b AND inicio_b <= fin_a. Esta condición verifica que el punto de inicio de cualquier rango caiga antes del punto final del otro rango.

Aquí hay un ejemplo de consulta SQL que lo ilustra:

SELECT CASE WHEN inicio_a <= fin_b AND inicio_b <= fin_a THEN 'Superposición' ELSE 'Sin Superposición' END AS EstadoSuperposición FROM TuTabla;

18. ¿Cómo encontrarías a los empleados que nunca han completado un curso de capacitación?

Para encontrar a los empleados que no han completado un curso de capacitación específico, normalmente consultarías una base de datos con información de empleados y capacitación. Suponiendo que tienes una tabla empleados y una tabla completados_capacitacion, puedes usar un LEFT JOIN y verificar los valores NULL en la tabla completados_capacitacion.

Por ejemplo, en SQL:

SELECT e.employee_id, e.employee_name FROM empleados e LEFT JOIN completados_capacitacion tc ON e.employee_id = tc.employee_id AND tc.course_id = 'specific_course_id' WHERE tc.employee_id IS NULL;

Esta consulta recupera todos los empleados de la tabla employees e intenta emparejarlos con registros en la tabla training_completions para el curso especificado. La cláusula WHERE filtra los casos donde no hay registros coincidentes en training_completions (es decir, tc.employee_id IS NULL), lo que indica que el empleado no ha completado el curso.

19. Explique cómo manejar valores NULL en funciones agregadas y comparaciones.

Las funciones agregadas (como SUM, AVG, COUNT, MIN, MAX) típicamente manejan los valores NULL excluyéndolos del cálculo. Por ejemplo, SUM(columna_con_nulos) sumará solo los valores no NULL en esa columna. COUNT(*) cuenta todas las filas, incluyendo aquellas con NULLs, mientras que COUNT(nombre_columna) cuenta solo las filas donde nombre_columna no es NULL.

Las comparaciones con NULL siempre se evalúan como UNKNOWN (que se trata como ni verdadero ni falso en SQL). Por lo tanto, no se puede usar =, !=, <, >, etc. para comparar directamente con NULL. En cambio, use IS NULL e IS NOT NULL para verificar valores NULL. Por ejemplo, WHERE nombre_columna IS NULL seleccionará las filas donde nombre_columna contiene un valor NULL.

20. Escriba una consulta para calcular el salario promedio de los empleados en cada departamento.

Calcular la mediana salarial requiere diferentes enfoques dependiendo del sistema de base de datos. Aquí hay un esquema general usando SQL y algunos enfoques comunes:

CON DepartmentSalaries AS ( SELECT department_id, salary, ROW_NUMBER() OVER (PARTITION BY department_id ORDER BY salary) AS row_num, COUNT(*) OVER (PARTITION BY department_id) AS total_employees FROM empleados ), CalculadoraMediana AS ( SELECT department_id, AVG(salary) AS salario_mediana FROM DepartmentSalaries WHERE row_num BETWEEN (total_employees + 1) / 2 AND (total_employees + 2) / 2 GROUP BY department_id ) SELECT mc.department_id, mc.salario_mediana FROM CalculadoraMediana mc;

Este código SQL calcula el salario mediano para cada departamento asignando primero un número de fila a cada empleado dentro de su departamento en función del salario. Luego, calcula la mediana promediando el salario del empleado o los dos empleados centrales (dependiendo de si el número total de empleados es impar o par). Este enfoque proporciona una solución general que se puede adaptar a varias bases de datos SQL.

21. ¿Cómo usaría una función de ventana para clasificar a los clientes en función de su gasto total?

Para clasificar a los clientes en función de su gasto total mediante una función de ventana, normalmente usaría las funciones RANK(), DENSE_RANK() o ROW_NUMBER() en SQL. Estas funciones le permiten asignar una clasificación a cada fila dentro de una partición de su conjunto de resultados, sin agrupar las filas.

Por ejemplo, suponiendo que tiene una tabla llamada pedidos con las columnas customer_id y order_amount, y desea clasificar a los clientes en función de su gasto total, podría usar la siguiente consulta SQL:

SELECT customer_id, SUM(order_amount) AS total_spending, RANK() OVER (ORDER BY SUM(order_amount) DESC) AS spending_rank FROM pedidos GROUP BY customer_id;

Esta consulta calcula la suma de order_amount para cada customer_id, y luego la función RANK() asigna una clasificación basada en el gasto total, con el cliente que tiene el gasto más alto obteniendo la clasificación 1. DENSE_RANK() asignaría clasificaciones consecutivas sin huecos, incluso si hay empates en total_spending. ROW_NUMBER() asigna una clasificación única a cada fila.

22. Describa cómo identificar y corregir inconsistencias de datos en una base de datos.

Identificar y corregir inconsistencias de datos implica varios pasos. Primero, el perfilado de datos ayuda a comprender los patrones de datos e identificar anomalías como valores fuera de rango o distribuciones inusuales. Las inconsistencias de datos también pueden detectarse implementando reglas de validación de datos a nivel de la aplicación o la base de datos (por ejemplo, usando restricciones, disparadores) para evitar la entrada de datos no válidos. Luego, realizar auditorías de calidad de datos, comparando datos entre diferentes fuentes o dentro de la misma base de datos usando consultas SQL, herramientas de informes o software dedicado a la calidad de datos. Esto implica buscar registros duplicados, registros huérfanos y valores conflictivos. Finalmente, usar herramientas o scripts personalizados para realizar la limpieza y transformación de datos y corregir discrepancias, como la deduplicación de datos, la estandarización de formatos y la resolución de valores conflictivos basados en reglas de negocio o la fuente de verdad.

Corregir inconsistencias requiere elegir el enfoque correcto basado en el problema específico. Esto podría implicar actualizar registros manualmente, usar scripts SQL para actualizar datos por lotes o crear tuberías de transformación de datos más complejas. Siempre haga una copia de seguridad de los datos antes de realizar cualquier cambio y documente el proceso de corrección.

23. Explique cómo auditar los cambios de datos en una tabla.

Auditar los cambios de datos en una tabla implica rastrear quién hizo qué cambios y cuándo. Un enfoque común es usar disparadores. Crea un disparador que se activa en las operaciones INSERT, UPDATE o DELETE en la tabla que desea auditar. Este disparador luego inserta un registro en una tabla de auditoría.

La tabla de auditoría normalmente incluye las siguientes columnas:

• table_name: El nombre de la tabla que se está auditando.
• column_name: El nombre de la columna modificada.
• primary_key_value: La clave primaria de la fila afectada.
• old_value: El valor antes del cambio.
• new_value: El valor después del cambio.
• changed_by: El usuario que realizó el cambio.
• changed_at: La marca de tiempo del cambio.

Aquí hay un ejemplo de un disparador:

CREATE TRIGGER audit_employee AFTER UPDATE ON employee FOR EACH ROW BEGIN INSERT INTO employee_audit ( table_name, column_name, primary_key_value, old_value, new_value, changed_by, changed_at ) VALUES ( 'employee', 'salary', OLD.id, OLD.salary, NEW.salary, USER(), NOW() ); END;

Algunas bases de datos también ofrecen funciones de auditoría integradas que pueden simplificar este proceso.

24. Escriba una consulta para transformar datos JSON almacenados en una columna en datos relacionales.

La consulta específica depende en gran medida del sistema de base de datos que esté utilizando y de la estructura de sus datos JSON. Sin embargo, el enfoque general implica el uso de funciones JSON específicas de la base de datos para extraer valores de la columna JSON y asignarlos a columnas relacionales.

Por ejemplo, en PostgreSQL:

SELECT json_data ->> 'field1' AS column1, json_data ->> 'field2' AS column2 FROM your_table;

Donde json_data es el nombre de la columna que contiene JSON, y field1, field2 son claves dentro del objeto JSON. El operador ->> extrae el valor como texto. Funciones similares existen en otras bases de datos como MySQL (JSON_EXTRACT), SQL Server (JSON_VALUE), y otras. Consulte la documentación de su base de datos específica para conocer las funciones y sintaxis correctas.

25. Explique la diferencia entre subconsultas correlacionadas y no correlacionadas, y proporcione un ejemplo de cada una.

Una subconsulta correlacionada depende de la consulta externa para sus valores. La consulta interna se ejecuta una vez por cada fila procesada por la consulta externa. En contraste, una subconsulta no correlacionada es independiente y se ejecuta solo una vez. Su resultado es luego utilizado por la consulta externa.

Ejemplo:

• No correlacionada: SELECT * FROM employees WHERE salary > (SELECT AVG(salary) FROM employees); - La subconsulta calcula el salario promedio una vez.
• Correlacionada: SELECT * FROM employees e WHERE salary > (SELECT AVG(salary) FROM departments WHERE department_id = e.department_id); - La subconsulta calcula el salario promedio para cada departamento del empleado.

26. Escriba una consulta para identificar a los 5 principales clientes que contribuyeron al 80% de las ventas totales.

CON CustomerSales AS ( SELECT customer_id, SUM(sale_amount) AS total_sales FROM sales_table GROUP BY customer_id ), VentasClasificadas AS ( SELECT customer_id, total_sales, SUM(total_sales) OVER (ORDER BY total_sales DESC) AS ventas_acumuladas, SUM(total_sales) OVER () AS ventas_totales_generales FROM CustomerSales ), VentasPorcentaje AS ( SELECT customer_id, total_sales, ventas_acumuladas, ventas_totales_generales, (ventas_acumuladas * 1.0 / ventas_totales_generales) * 100 AS porcentaje_acumulado FROM VentasClasificadas ) SELECT customer_id, total_sales FROM VentasPorcentaje WHERE porcentaje_acumulado <= 80 ORDER BY total_sales DESC LIMIT 5;

Esta consulta SQL identifica a los 5 principales clientes que contribuyen al 80% de las ventas totales. Calcula las ventas totales de cada cliente y luego suma acumulativamente las ventas en orden descendente para determinar el porcentaje de contribución. Finalmente, filtra a los clientes cuyo porcentaje acumulativo es menor o igual al 80% y selecciona a los 5 principales por ventas totales.

27. ¿Cómo diseñarías una consulta SQL para encontrar todos los pares posibles de empleados que trabajan en el mismo departamento?

Para encontrar todos los pares posibles de empleados que trabajan en el mismo departamento, puedes usar una auto-unión. Aquí está la consulta SQL:

SELECT e1.employee_id, e2.employee_id FROM empleados e1 JOIN empleados e2 ON e1.department_id = e2.department_id AND e1.employee_id < e2.employee_id;

Esta consulta une la tabla empleados consigo misma (e1 y e2) basándose en la condición de que sus valores de department_id sean iguales. La condición e1.employee_id < e2.employee_id evita pares duplicados (por ejemplo, (A, B) y (B, A)) y también evita emparejar a un empleado consigo mismo.

Preguntas de entrevista sobre consultas SQL avanzadas

1. ¿Cómo identificarías los 3 productos principales en cada categoría basándote en las ventas, utilizando funciones de ventana?

Para identificar los 3 productos principales en cada categoría en función de las ventas utilizando funciones de ventana en SQL, puedes usar la función RANK() o DENSE_RANK(). Primero, particiona los datos por categoría. Luego, ordena los productos dentro de cada categoría por ventas en orden descendente. Asigna una clasificación a cada producto según sus ventas dentro de su categoría. Finalmente, filtra el resultado para incluir solo aquellos productos con una clasificación menor o igual a 3.

Por ejemplo, si estás usando SQL:

WITH RankedSales AS ( SELECT category, product_name, sales, RANK() OVER (PARTITION BY category ORDER BY sales DESC) AS sales_rank FROM sales_table ) SELECT category, product_name, sales FROM RankedSales WHERE sales_rank <= 3;

2. ¿Puedes explicar cómo optimizar una consulta de bajo rendimiento que involucra múltiples uniones y subconsultas?

Para optimizar una consulta lenta con múltiples uniones y subconsultas, comienza analizando el plan de ejecución de la consulta utilizando herramientas como EXPLAIN. Identifica las operaciones más costosas, como escaneos completos de tablas o uniones mal indexadas. Concéntrate en optimizar primero a los peores infractores. Indexa las columnas relevantes utilizadas en las condiciones JOIN y las cláusulas WHERE. Reescribe las subconsultas como uniones cuando sea posible o considera usar tablas temporales para almacenar resultados intermedios. Verifica las estadísticas y actualízalas para asegurar que el optimizador de consultas tenga la mejor información.

Optimizaciones adicionales pueden incluir reescribir la consulta para minimizar la cantidad de datos procesados, filtrar datos lo antes posible o usar tipos de datos apropiados. La partición de tablas grandes también puede mejorar el rendimiento. Finalmente, considere desnormalizar el esquema de la base de datos si el rendimiento de lectura es crítico y el rendimiento de escritura es menos preocupante. Por ejemplo, si usa MySQL, verifique slow_query_log y también performance_schema para detectar cuellos de botella e información específica sobre consultas.

3. Describa un escenario donde usaría una expresión de tabla común (CTE) recursiva y proporcione un ejemplo.

Una CTE recursiva es útil cuando necesita recorrer una estructura de datos jerárquica, como un organigrama, una lista de materiales o un gráfico de relaciones. Por ejemplo, imagine que tiene una tabla Empleado con las columnas IDEmpleado y IDGerente. Desea encontrar a todos los empleados que reportan, directa o indirectamente, a un gerente específico.

Aquí hay un ejemplo:

WITH RECURSIVE JerarquíaEmpleados AS ( -- Miembro de anclaje: seleccione el gerente inicial SELECT IDEmpleado, IDGerente, IDEmpleado AS IDGerenteRaíz FROM Empleado WHERE IDGerente ES NULL -- Suponiendo que el IDGerente del gerente principal es NULL UNION ALL -- Miembro recursivo: encuentre los subordinados del nivel actual SELECT e.IDEmpleado, e.IDGerente, eh.IDGerenteRaíz FROM Empleado e INNER JOIN JerarquíaEmpleados eh ON e.IDGerente = eh.IDEmpleado ) SELECT IDEmpleado FROM JerarquíaEmpleados WHERE IDGerenteRaíz = 123; --Ejemplo: Encuentra a todos bajo el IDGerente 123

4. ¿Cómo maneja datos duplicados en una tabla y asegura la integridad de los datos?

Para manejar datos duplicados y asegurar la integridad, primero identificaría los duplicados. Esto se puede hacer usando consultas SQL con las cláusulas GROUP BY y HAVING COUNT(*) > 1 para encontrar filas con valores idénticos en columnas clave. Luego, elegiría una estrategia para tratar con ellos. Las opciones incluyen:

• Eliminación de duplicados: Utilice ROW_NUMBER() y una expresión de tabla común (CTE) para particionar los datos, asigne un número único a cada fila dentro de la partición y luego elimine las filas con row_number > 1.
• Prevención de duplicados: Implemente restricciones o índices únicos en las columnas relevantes durante la creación o modificación de la tabla. Esto evitará la futura inserción de filas duplicadas.
• Validación de datos: Implemente reglas de validación en la capa de la aplicación o utilizando disparadores de base de datos para detectar y manejar posibles duplicados antes de que se inserten. Otro enfoque es implementar sentencias MERGE para la lógica de upsert donde los registros existentes se actualizan o se crean nuevos.

5. Explique la diferencia entre los índices agrupados y no agrupados y su impacto en el rendimiento de las consultas.

Los índices agrupados determinan el orden físico de los datos en una tabla. Una tabla solo puede tener un índice agrupado. Debido a que los datos se ordenan físicamente de acuerdo con el índice agrupado, las consultas que utilizan el índice agrupado para recuperar datos son generalmente muy rápidas. Piense en ello como una guía telefónica, donde los datos están físicamente ordenados por apellido.

Los índices no agrupados, por otro lado, son como una tabla de búsqueda separada que contiene un puntero a las filas de datos reales. Una tabla puede tener múltiples índices no agrupados. Cuando una consulta usa un índice no agrupado, el motor de la base de datos primero encuentra la fila en el índice, y luego usa el puntero para recuperar los datos reales de la tabla. Esto puede ser más lento que usar un índice agrupado debido al paso adicional necesario para recuperar los datos. Sin embargo, los índices no agrupados aún pueden mejorar significativamente el rendimiento de las consultas, especialmente para las consultas que solo necesitan recuperar algunas columnas de datos. Por ejemplo, imagine un catálogo de biblioteca; puede indicarle rápidamente la ubicación de un libro sin tener que escanear cada libro en los estantes.

6. ¿Cómo diseñaría un esquema de base de datos para almacenar y recuperar eficientemente datos jerárquicos, como un organigrama?

Hay algunas formas comunes de modelar datos jerárquicos en una base de datos relacional. Un modelo de lista de adyacencia usa una clave externa simple autorreferencial. Una tabla contendría columnas como id, nombre y parent_id. parent_id haría referencia al id del nodo padre, o sería nulo para la raíz. La recuperación es sencilla para los hijos directos, pero se vuelve compleja para jerarquías más profundas que requieren consultas recursivas o procedimientos almacenados.

Alternativamente, un modelo de ruta materializada almacena la ruta completa a un nodo como una cadena (por ejemplo, '1/5/12'). Esto permite una recuperación eficiente de los descendientes usando cláusulas LIKE. Sin embargo, las actualizaciones (inserciones/eliminaciones) requieren la actualización de muchas filas para mantener la integridad de la ruta. Otro enfoque es el modelo de conjuntos anidados que utiliza valores left y right para representar la estructura del árbol. La recuperación de descendientes es eficiente (por ejemplo, WHERE left BETWEEN node.left AND node.right), pero las inserciones/eliminaciones son complejas y computacionalmente costosas. La elección óptima depende de la frecuencia de las lecturas frente a las escrituras y la profundidad de la jerarquía.

7. Describa cómo usar la partición para mejorar el rendimiento de las consultas en una tabla muy grande.

La partición de una tabla grande la divide en piezas más pequeñas y manejables basadas en una clave de partición elegida (por ejemplo, fecha, región). Esto mejora el rendimiento de las consultas al permitir que la base de datos escanee solo las particiones relevantes en lugar de toda la tabla. Esto reduce drásticamente las operaciones de E/S y el uso de la CPU. Por ejemplo, una tabla de pedidos de clientes particionada por fecha de pedido permite que las consultas de pedidos en un mes específico solo escaneen la partición de ese mes.

Existen diferentes estrategias de particionamiento (rango, lista, hash), cada una adecuada para diferentes casos de uso. El particionamiento por rango (por ejemplo, por fecha) es común para datos de series temporales. La selección adecuada de la clave de partición es crucial; las columnas consultadas con frecuencia son buenas candidatas. Los predicados de consulta deben incluir la clave de partición para lograr beneficios óptimos de rendimiento. También recuerde considerar el mantenimiento (añadir/eliminar particiones), lo cual puede afectar el rendimiento.

8. Explique cómo implementar la seguridad a nivel de fila en una base de datos.

La seguridad a nivel de fila (RLS) restringe el acceso a los datos a nivel de fila, lo que permite a los usuarios ver solo los datos relevantes para ellos. La implementación generalmente implica la creación de políticas de seguridad asociadas con las tablas de la base de datos. Estas políticas definen predicados de filtro que determinan a qué filas puede acceder un usuario en función de atributos como la identificación de usuario, la membresía en un grupo u otros criterios relevantes.

Los métodos comunes incluyen el uso de vistas de base de datos con cláusulas WHERE basadas en el contexto del usuario (menos seguro, más difícil de gestionar), o la implementación de características RLS dedicadas (si están disponibles) como en PostgreSQL con CREATE POLICY. Las políticas RLS son generalmente más eficientes y robustas ya que el filtrado es gestionado por el motor de la base de datos durante la ejecución de la consulta. Por ejemplo, en PostgreSQL:

CREATE POLICY user_policy ON my_table FOR SELECT TO app_user USING (user_id = current_user);

9. ¿Cómo se auditarían los cambios realizados en tablas específicas de una base de datos?

Para auditar los cambios en tablas específicas, se pueden utilizar varios enfoques. Un método común es utilizar desencadenadores de base de datos (triggers). Un desencadenador se puede configurar para ejecutar automáticamente una función cada vez que se insertan, actualizan o eliminan datos en la tabla objetivo. Esta función de desencadenador captura los valores antiguos y nuevos de la fila modificada y los inserta en una tabla de auditoría. La tabla de auditoría típicamente incluye columnas para el nombre de la tabla, el tipo de operación (insertar, actualizar, eliminar), la marca de tiempo del cambio, el usuario que realizó el cambio y los datos modificados en sí.

Otro método implica el uso de funciones de auditoría específicas de la base de datos. Muchas bases de datos modernas ofrecen capacidades de auditoría integradas que permiten rastrear los cambios en los datos y los objetos de la base de datos. Por ejemplo, en PostgreSQL, se pueden usar extensiones como pgaudit. Estas funciones ofrecen una auditoría más robusta y eficiente en comparación con los disparadores. La elección entre disparadores y auditoría nativa depende del sistema de base de datos específico, el nivel de detalle requerido y las consideraciones de rendimiento.

10. ¿Puede describir el proceso de normalización de bases de datos y sus beneficios?

La normalización de bases de datos es el proceso de organizar los datos en una base de datos para reducir la redundancia y mejorar la integridad de los datos. Normalmente, implica dividir las bases de datos en dos o más tablas y definir las relaciones entre ellas. Esto se logra siguiendo una serie de formas normales (1FN, 2FN, 3FN, etc.), cada una con reglas específicas para eliminar diferentes tipos de redundancia.

Los beneficios de la normalización incluyen la reducción de la redundancia de datos, la mejora de la consistencia de los datos, la facilitación de la modificación de datos y un rendimiento de consulta más rápido en algunos casos. Al minimizar los datos redundantes, las actualizaciones solo deben realizarse en un lugar, lo que evita inconsistencias. Esto también conduce a un tamaño de base de datos más pequeño y una mejor integridad de los datos, ya que los datos se almacenan de forma lógica y coherente en toda la base de datos.

11. ¿Cómo se manejan los interbloqueos en un entorno de base de datos?

Los interbloqueos ocurren cuando dos o más transacciones se bloquean indefinidamente, esperando que la otra libere los recursos que posee. Podemos manejar los interbloqueos utilizando varias estrategias, incluyendo:

• Prevención de interbloqueos: Esto implica diseñar el sistema para evitar que los interbloqueos ocurran en primer lugar. Esto puede incluir ordenar el acceso a los recursos, adquirir todos los bloqueos necesarios a la vez o usar tiempos de espera para liberar los bloqueos.
• Detección y recuperación de interbloqueos: Este enfoque permite que ocurran interbloqueos, pero luego los detecta y toma medidas para resolverlos. Las bases de datos a menudo tienen un mecanismo de detección de interbloqueos que identifica ciclos en el gráfico de 'esperas-por'. Una vez que se detecta un interbloqueo, una de las transacciones involucradas (la 'víctima') se revierte, liberando sus bloqueos y permitiendo que otras transacciones continúen. La transacción víctima puede ser reintentada. Este enfoque puede conducir a 'interbloqueo dinámico' donde una transacción se revierte y reintenta repetidamente. En la práctica, las bases de datos suelen emplear esta detección y recuperación porque la prevención puede ser restrictiva e impactar el rendimiento. Establecer tiempos de espera de bloqueo apropiados también es vital.

12. Explique el uso de diferentes niveles de aislamiento en la gestión de transacciones.

Los niveles de aislamiento de transacciones controlan el grado en que las transacciones están aisladas de las modificaciones de las demás. Los niveles de aislamiento más bajos permiten una mayor concurrencia, pero aumentan el riesgo de fenómenos como lecturas sucias, lecturas no repetibles y lecturas fantasma. Los niveles de aislamiento comunes incluyen: Read Uncommitted (nivel más bajo, permite lecturas sucias), Read Committed (evita lecturas sucias), Repeatable Read (evita lecturas sucias y lecturas no repetibles) y Serializable (nivel más alto, evita todos los fenómenos mencionados al esencialmente serializar las transacciones).

13. ¿Cómo implementaría una función de búsqueda de texto completo en una base de datos?

Para implementar la búsqueda de texto completo, normalmente usaría un motor de búsqueda dedicado como Elasticsearch o Solr junto con la base de datos. Estos motores indexan los datos de texto, lo que permite una búsqueda eficiente basada en palabras clave, stemming y otras técnicas de análisis de texto. La base de datos se utilizaría entonces para almacenar los datos principales, con el motor de búsqueda gestionando las consultas basadas en texto. Cuando se recibe una consulta de búsqueda, se envía al motor de búsqueda, que devuelve los ID de los documentos relevantes. Estos ID se utilizan entonces para recuperar los registros completos de la base de datos.

Alternativamente, algunas bases de datos ofrecen capacidades de búsqueda de texto completo integradas. Por ejemplo, PostgreSQL tiene los tipos tsvector y tsquery junto con funciones para indexar y consultar datos de texto. MySQL tiene índices FULLTEXT. Si bien son más sencillas de configurar inicialmente, es posible que estas funciones integradas no ofrezcan el mismo nivel de rendimiento o características avanzadas que los motores de búsqueda dedicados para conjuntos de datos grandes o requisitos de búsqueda complejos.

14. Describa cómo usar los disparadores de base de datos para hacer cumplir reglas de negocio complejas.

Los disparadores de base de datos se pueden usar para hacer cumplir reglas de negocio complejas al ejecutar automáticamente código SQL en respuesta a eventos específicos de la base de datos, como operaciones INSERT, UPDATE o DELETE en una tabla. Por ejemplo, podría usar un disparador para evitar que se cree un pedido si se excede el límite de crédito del cliente, o para actualizar automáticamente el recuento de inventario cuando se realiza un nuevo pedido.

Para implementar una regla compleja, normalmente definiría un disparador que se activa antes de la modificación de datos relevante. La lógica del disparador luego verifica si el cambio propuesto viola la regla de negocio. Si lo hace, el disparador puede ROLLBACK la transacción, evitando el cambio. Ejemplo de código SQL:

CREATE TRIGGER check_credit_limit BEFORE INSERT ON Orders FOR EACH ROW BEGIN IF (SELECT credit_limit FROM Customers WHERE customer_id = NEW.customer_id) < NEW.order_total THEN SIGNAL SQLSTATE '45000' SET MESSAGE_TEXT = 'Límite de crédito excedido'; END IF; END;

15. ¿Cómo se pueden optimizar las consultas que utilizan el operador `LIKE` con comodines?

La optimización de las consultas LIKE con comodines depende de la posición del comodín. Los comodines iniciales (%valor) impiden el uso del índice, lo que requiere un escaneo completo de la tabla, lo cual es ineficiente.

Para optimizar:

• Evitar comodines iniciales: Si es posible, reestructure la consulta para evitar % al principio. Por ejemplo, en lugar de LIKE '%valor', considere LIKE 'valor%' que puede usar un índice.
• Búsqueda de texto completo: Para búsquedas complejas con comodines, considere el uso de las capacidades de búsqueda de texto completo ofrecidas por su base de datos (por ejemplo, MATCH AGAINST de MySQL, búsqueda de texto completo de PostgreSQL). Estas están optimizadas para la búsqueda de texto.
• Optimizaciones específicas de la base de datos: Explore las características y estrategias de indexación específicas de la base de datos. Por ejemplo, algunas bases de datos ofrecen índices trigrama u otras técnicas que pueden mejorar el rendimiento de LIKE, independientemente de la posición del comodín.
• Limitar el conjunto de resultados: Agregue la cláusula LIMIT para reducir el número de filas buscadas/devueltas, cuando solo es suficiente un número limitado de resultados.
• Use CONTAINS en lugar de LIKE en ciertos escenarios (por ejemplo, SQL Server proporciona CONTAINS, que puede ser más eficiente para búsquedas de texto completo si está configurado correctamente).

16. Explique la diferencia entre `UNION` y `UNION ALL` y cuándo usar cada uno.

Los operadores UNION y UNION ALL en SQL se utilizan para combinar los conjuntos de resultados de dos o más sentencias SELECT. La diferencia clave es que UNION elimina las filas duplicadas del conjunto de resultados combinado, mientras que UNION ALL incluye todas las filas, incluidas las duplicadas.

Use UNION cuando necesite un conjunto distinto de filas de múltiples fuentes y no desee filas duplicadas. Use UNION ALL cuando desee combinar todas las filas de múltiples fuentes, independientemente de los duplicados, y el rendimiento sea una preocupación, ya que eliminar duplicados puede ser una operación costosa. Por ejemplo, si está archivando datos y desea agregar los valores de una tabla en otra tabla para crear un archivo, entonces se debe usar UNION ALL.

17. ¿Cómo diseñaría un esquema de base de datos para almacenar datos de series temporales?

Un enfoque común es utilizar un almacén de columnas anchas o una base de datos relacional con un esquema específico. Para las bases de datos relacionales, un esquema simple podría incluir una tabla con columnas para timestamp (marca de tiempo), metric_name (nombre de la métrica) y value (valor). La partición de la tabla por metric_name y/o rangos de tiempo (por ejemplo, mensuales) mejora significativamente el rendimiento de las consultas. La indexación de timestamp también es crucial. Para una implementación a mayor escala, considere el uso de bases de datos especializadas de series temporales como InfluxDB o TimescaleDB, que ofrecen capacidades optimizadas de almacenamiento y consulta para datos de series temporales.

Una alternativa, a menudo más escalable, implica un almacén de columnas anchas, como Cassandra o HBase. La clave de fila consistiría en el metric_name y timestamp, y el valor de la columna contendría los datos reales. Esto permite una recuperación eficiente de datos para una métrica específica durante un rango de tiempo. La agregación de datos también se puede realizar utilizando trabajos de map-reduce u otros frameworks de computación distribuida si es necesario.

18. Describa diferentes estrategias para realizar copias de seguridad y restaurar una base de datos.

La copia de seguridad y la restauración de bases de datos son cruciales para la protección de datos y la recuperación ante desastres. Las estrategias comunes de copia de seguridad incluyen: 1. Copias de seguridad completas: Copian toda la base de datos. Son simples pero consumen mucho tiempo. 2. Copias de seguridad diferenciales: Copian solo los cambios desde la última copia de seguridad completa. La restauración requiere la última copia completa y la diferencial más reciente. 3. Copias de seguridad incrementales: Copian solo los cambios desde la última copia de seguridad (completa o incremental). La restauración requiere la última copia completa y todas las copias de seguridad incrementales subsiguientes en orden. 4. Copias de seguridad del registro de transacciones: Capturan todos los registros de transacciones desde la última copia de seguridad completa, diferencial o del registro de transacciones. Se utilizan para la recuperación puntual. La restauración a menudo implica restaurar la copia de seguridad completa y luego reproducir los registros de transacciones. 5. Copias de seguridad de instantáneas: Crean una copia puntual utilizando las capacidades del sistema de almacenamiento; rápidas pero podrían no ser transaccionalmente consistentes.

Las estrategias de restauración dependen del tipo de copia de seguridad y del punto de recuperación deseado. Las copias de seguridad completas ofrecen la restauración más simple, mientras que las copias de seguridad diferenciales e incrementales requieren restaurar múltiples conjuntos de copias de seguridad. Las copias de seguridad del registro de transacciones permiten una recuperación puntual precisa. La frecuencia de las copias de seguridad depende de la tasa de cambio de los datos y de la pérdida de datos aceptable.

19. ¿Cómo se supervisa el rendimiento de la base de datos y se identifican los posibles cuellos de botella?

La supervisión del rendimiento de la base de datos implica el seguimiento de métricas clave y la identificación de desviaciones de las líneas base establecidas. Normalmente utilizo una combinación de herramientas como las funciones integradas de supervisión de bases de datos (por ejemplo, Performance Monitor en SQL Server, Performance Schema en MySQL), soluciones de supervisión de terceros (por ejemplo, Datadog, New Relic) y scripts personalizados para recopilar datos. Las métricas clave a supervisar incluyen la utilización de la CPU, el uso de la memoria, la E/S del disco, los tiempos de ejecución de las consultas, la contención de bloqueos y las tasas de acierto de la caché de búferes. Analizo las consultas lentas utilizando analizadores/generadores de perfiles de consultas para identificar código ineficiente, índices faltantes o esquemas mal diseñados. También comprobaría si hay interbloqueos, bloqueos excesivos y transacciones de larga duración que puedan indicar cuellos de botella.

20. Explique cómo utilizar procedimientos almacenados para encapsular lógica empresarial compleja.

Los procedimientos almacenados son sentencias SQL precompiladas almacenadas dentro de la base de datos. Encapsulan la lógica empresarial compleja proporcionando una forma modular y reutilizable de realizar operaciones en la base de datos. En lugar de incrustar SQL directamente en las aplicaciones, se llama a un procedimiento almacenado, pasando los parámetros según sea necesario. Este enfoque ofrece varias ventajas.

Usando procedimientos almacenados, puede centralizar y mantener una lógica compleja en un solo lugar. Esto simplifica el código de la aplicación, reduce la redundancia y mejora la seguridad al controlar el acceso a los datos. Por ejemplo, un procedimiento almacenado podría manejar una serie de actualizaciones en múltiples tablas cuando se procesa un pedido de cliente. Usted crearía el procedimiento almacenado, por ejemplo en SQL Server:

CREATE PROCEDURE ProcessOrder (@CustomerID INT, @ProductID INT, @Quantity INT) AS BEGIN -- Lógica para actualizar el inventario, crear el registro del pedido, etc. END

Luego, su aplicación simplemente llama a EXEC ProcessOrder @CustomerID = 123, @ProductID = 456, @Quantity = 1.

21. ¿Cómo migraría una base de datos de una plataforma a otra (por ejemplo, de MySQL a PostgreSQL)?

Migrar una base de datos implica varios pasos, desde la planificación hasta la ejecución y validación. Primero, la evaluación es crucial. Analice los esquemas, los tipos de datos, los procedimientos almacenados y las dependencias de la aplicación para comprender el alcance y las posibles incompatibilidades. Luego, la conversión del esquema puede ser necesaria. Herramientas como pgloader (para PostgreSQL) pueden ayudar a convertir el esquema y los datos, pero a menudo se necesitan ajustes manuales debido a diferencias en los tipos de datos o la sintaxis SQL.

Una vez que el esquema está listo, el siguiente paso es la migración de datos. Esto se puede lograr a través de la replicación lógica, volcado y restauración, o herramientas ETL. La replicación lógica proporciona sincronización continua, útil para migraciones con un tiempo de inactividad mínimo. El volcado y la restauración implican exportar datos de la fuente e importarlos al destino. Finalmente, las pruebas y la validación exhaustivas son esenciales para garantizar la integridad de los datos y la funcionalidad de la aplicación en el nuevo entorno. Supervise de cerca el rendimiento después de la migración y tenga un plan de reversión.

22. Describe el concepto de sharding y sus ventajas en un entorno de base de datos a gran escala.

El sharding es un patrón de arquitectura de base de datos donde una base de datos grande se particiona horizontalmente en bases de datos más pequeñas y manejables llamadas shards. Cada shard contiene un subconjunto de los datos generales, y todos residen en servidores de bases de datos separados. Esta distribución permite el procesamiento paralelo y reduce la carga en un solo servidor.

Las ventajas del sharding en un entorno a gran escala incluyen un rendimiento mejorado debido a la localización de datos y la ejecución de consultas paralelas, una mayor capacidad de almacenamiento ya que los datos se distribuyen en múltiples servidores, y una mayor disponibilidad y tolerancia a fallos porque el fallo de un shard no necesariamente derriba todo el sistema. También permite una escalabilidad más fácil, ya que se pueden agregar más shards para manejar el aumento de los volúmenes de datos o el tráfico de usuarios.

23. Explique cómo usar vistas de base de datos para simplificar consultas complejas y mejorar la seguridad.

Las vistas de base de datos son tablas virtuales basadas en el conjunto de resultados de una sentencia SQL. Simplifican las consultas complejas encapsulándolas en un solo objeto con nombre. En lugar de escribir la misma consulta compleja repetidamente, puede consultar la vista como lo haría con una tabla regular. Esto promueve la reutilización del código y hace que las consultas sean más fáciles de entender y mantener.

Las vistas también mejoran la seguridad. Puede otorgar a los usuarios acceso a una vista que solo muestra columnas o filas específicas de las tablas subyacentes, sin otorgarles acceso directo a las tablas en sí. Esto restringe el acceso a datos confidenciales. Por ejemplo, una vista podría solo exponer los nombres de los clientes y las fechas de los pedidos, pero no la información de la tarjeta de crédito. Puede crear vistas usando el comando SQL CREATE VIEW. Por ejemplo:

CREATE VIEW customer_orders AS SELECT customer_name, order_date FROM customers JOIN orders ON customers.customer_id = orders.customer_id;

24. ¿Cómo implementaría una solución de almacenamiento de datos para informes de inteligencia empresarial?

Una solución de almacenamiento de datos típicamente implica estos pasos: Primero, identificar las métricas clave de negocio y las fuentes de datos. Luego, extraer, transformar y cargar (ETL) datos de diversas fuentes (bases de datos, APIs, archivos planos) en un área de preparación. Implementar la lógica de limpieza y transformación de datos, a menudo usando herramientas como Apache Spark o servicios ETL basados en la nube. Finalmente, cargar los datos transformados en un almacén de datos (por ejemplo, Snowflake, Amazon Redshift, Google BigQuery).

Para la generación de informes, construiría un esquema de estrella o un esquema de copo de nieve sobre el almacén de datos. Luego, usaría herramientas de inteligencia empresarial como Tableau, Power BI o Looker para crear informes y paneles. Supervisar regularmente la calidad de los datos y los horarios de actualización para asegurar información precisa y oportuna. Las consideraciones incluyen escalabilidad, seguridad y optimización de costos en todas las etapas.

25. Describa diferentes técnicas para la compresión de datos en una base de datos.

La compresión de datos en bases de datos reduce el espacio de almacenamiento y mejora el rendimiento de E/S. Existen varias técnicas, incluyendo:

• Compresión a nivel de fila/página: Comprime filas o páginas enteras de datos utilizando algoritmos como Lempel-Ziv (LZ77) o Lempel-Ziv-Welch (LZW). Esto es a menudo transparente para las aplicaciones.
• Compresión columnar: Comprime columnas individuales por separado, especialmente efectiva para almacenes de datos donde se almacenan datos similares en columnas. Las técnicas incluyen codificación de longitud de ejecución (RLE), codificación de diccionario y codificación de vector de bits.
• Desduplicación de datos: Identifica y elimina copias de datos redundantes, almacenando solo instancias únicas. A menudo se utiliza para copias de seguridad y datos de archivo.
• Compresión de diccionario: Construye un diccionario de valores que ocurren con frecuencia y los reemplaza con códigos más cortos.
• Compresión delta: Almacena solo las diferencias (deltas) entre versiones sucesivas de datos. Útil para datos de series temporales o registros de auditoría.

26. Explique cómo usar funciones de base de datos para extender la funcionalidad de SQL.

Las funciones de base de datos extienden la funcionalidad de SQL al permitirle crear rutinas personalizadas que realizan tareas específicas dentro de la base de datos. Estas funciones se pueden escribir en una variedad de idiomas, dependiendo del sistema de base de datos (por ejemplo, PL/SQL en Oracle, T-SQL en SQL Server, PL/pgSQL en PostgreSQL). Encapsulan lógica compleja, cálculos o manipulaciones de datos que serían engorrosos o imposibles de expresar directamente en SQL.

Para usarlos:

1. Definir la función: Define una función dentro de la base de datos usando una declaración CREATE FUNCTION, especificando su nombre, parámetros de entrada, tipo de retorno y el código a ejecutar.

CREATE FUNCTION calculate_discount (precio DECIMAL, porcentaje_descuento DECIMAL) RETURNS DECIMAL AS $$ BEGIN RETURN precio * (1 - porcentaje_descuento/100); END; $$ LANGUAGE plpgsql;

2. Llamar a la función: Una vez definida, puede llamar a la función directamente en sus consultas SQL, al igual que las funciones SQL integradas. Por ejemplo:

SELECT nombre_articulo, calculate_discount(precio, 10) AS precio_con_descuento FROM productos;

Preguntas de la entrevista sobre consultas SQL expertas

1. ¿Cómo optimiza una consulta que se ejecuta lentamente debido a una gran cantidad de uniones (joins)?

Para optimizar una consulta lenta con numerosas uniones, considere varias estrategias. Primero, asegúrese de que existan los índices apropiados en las columnas de unión de todas las tablas involucradas. Esto acelera drásticamente el proceso de unión al permitir que la base de datos localice rápidamente las filas coincidentes. En segundo lugar, revise el orden de unión. El orden en que se unen las tablas puede afectar significativamente el rendimiento; unir las tablas más pequeñas primero puede reducir el tamaño de los conjuntos de resultados intermedios. A veces, reescribir la consulta para usar subconsultas, tablas temporales o expresiones de tabla comunes (CTEs) puede ayudar al optimizador de la base de datos a elegir un plan de ejecución más eficiente. Finalmente, analice el plan de ejecución de la consulta proporcionado por el sistema de base de datos (EXPLAIN PLAN en muchas bases de datos SQL) para identificar cuellos de botella y áreas de mejora, como escaneos completos de tablas o algoritmos de unión ineficientes. Actualizar regularmente las estadísticas de las tablas también ayuda al optimizador de consultas a tomar decisiones informadas.

Además, considere la desnormalización como último recurso si el rendimiento de lectura es primordial y el rendimiento de escritura es menos crítico. Reducir el número de uniones incorporando datos relevantes en una sola tabla puede mejorar la velocidad de las consultas, pero conlleva el costo de una mayor redundancia de datos y posibles anomalías en las actualizaciones. Sopesar cuidadosamente las compensaciones antes de optar por la desnormalización. Revise si los tipos de unión son apropiados, por ejemplo, usar LEFT JOIN cuando un INNER JOIN puede ser más apropiado si el registro unido es requerido.

2. Describa un escenario donde el uso de una función de ventana sería más eficiente que el uso de una subconsulta. Proporcione un ejemplo.

Las funciones de ventana a menudo superan a las subconsultas, especialmente para tareas de clasificación y agregación dentro de particiones de datos. Un escenario común es calcular un promedio móvil o un total acumulado. Imagine que tiene una tabla de datos de ventas diarias para diferentes tiendas y necesita calcular un promedio móvil de 7 días de ventas para cada tienda. Usando una subconsulta, necesitaría ejecutar una subconsulta separada para cada fila para calcular el promedio, lo cual es computacionalmente costoso. Una función de ventana puede calcular esto en una sola pasada.

Aquí hay un ejemplo usando SQL:

SELECT store_id, sale_date, daily_sales, AVG(daily_sales) OVER (PARTITION BY store_id ORDER BY sale_date ASC ROWS BETWEEN 6 PRECEDING AND CURRENT ROW) AS moving_average_7_day FROM sales_table;

En este ejemplo, la función AVG() OVER() calcula el promedio de ventas diarias dentro de una ventana de la fila actual y las 6 filas precedentes, particionado por store_id. Este enfoque es típicamente mucho más eficiente que lograr el mismo resultado con subconsultas correlacionadas, especialmente con conjuntos de datos más grandes.

3. Explique cómo diagnosticaría y resolvería una situación de interbloqueo en una base de datos.

Para diagnosticar un interbloqueo, primero identificaría los procesos involucrados. La mayoría de los sistemas de bases de datos ofrecen herramientas o vistas para detectar interbloqueos, mostrando qué procesos están bloqueados y qué recursos están esperando. Por ejemplo, en SQL Server, usaría sp_who2 o consultaría sys.dm_os_waiting_tasks. En PostgreSQL, usaría pg_locks y pg_stat_activity. La salida revelaría las transacciones conflictivas y los recursos (por ejemplo, tablas, filas) por los que están compitiendo.

Para resolver un interbloqueo, el enfoque más común es la detección de interbloqueos y la reversión automática (selección de la víctima). El sistema de base de datos típicamente elige una de las transacciones interbloqueadas como víctima, la revierte y libera sus recursos, permitiendo que la(s) otra(s) transacción(es) continúe(n). Si bien la reversión automática es la solución estándar, es preferible prevenir interbloqueos a través de un diseño cuidadoso de las transacciones. Esto implica ordenar las operaciones dentro de las transacciones de forma consistente, usar estrategias de bloqueo apropiadas y mantener las transacciones cortas. En las aplicaciones, implementar la lógica de reintento después de una excepción de reversión es crucial.

4. ¿Cómo se puede implementar la seguridad a nivel de fila en SQL para restringir el acceso a ciertos datos en función de los roles de usuario?

La seguridad a nivel de fila (RLS) en SQL restringe el acceso a los datos en función de los roles de usuario. Normalmente, esto se logra mediante el uso de políticas de seguridad o vistas. Una política de seguridad es una función de predicado asociada a una tabla que determina a qué filas puede acceder un usuario. Este predicado a menudo comprueba el contexto del usuario (por ejemplo, USER_NAME(), rol de la aplicación) en comparación con una columna de la tabla o una tabla de roles separada.

Por ejemplo, en SQL Server, se utilizaría CREATE SECURITY POLICY para definir un predicado de filtro, que luego se aplica a la tabla. Alternativamente, se pueden crear vistas que filtren datos en función de los roles de usuario; sin embargo, las políticas de seguridad generalmente se prefieren por su mantenibilidad y rendimiento. Otra característica importante es implementar técnicas de enmascaramiento de datos para evitar la exposición de datos confidenciales.

5. Diseñe una consulta SQL para identificar y eliminar registros duplicados de una tabla, conservando solo la entrada más reciente.

Para identificar y eliminar registros duplicados, conservando el más reciente, puede utilizar una combinación de funciones de ventana y una expresión de tabla común (CTE). Suponiendo que tiene una tabla llamada your_table con columnas como id, data y created_at (marca de tiempo), la siguiente consulta SQL puede lograr esto:

WITH RankedRows AS ( SELECT id, data, created_at, ROW_NUMBER() OVER(PARTITION BY data ORDER BY created_at DESC) AS rn FROM your_table ) DELETE FROM your_table WHERE id IN (SELECT id FROM RankedRows WHERE rn > 1);

Esta consulta primero asigna una clasificación a cada fila dentro de las particiones definidas por la columna data, ordenando por created_at en orden descendente. La función ROW_NUMBER() asigna la clasificación 1 a la entrada más reciente. Luego, elimina todos los registros de la tabla original cuyo id está presente en el CTE RankedRows con una clasificación mayor que 1 (entradas duplicadas). Adapte la cláusula PARTITION BY para que coincida con las columnas que definen un duplicado y la cláusula ORDER BY para la columna de marca de tiempo.

6. Explique la diferencia entre los índices agrupados y no agrupados, y cuándo usaría cada uno.

Un índice agrupado determina el orden físico de los datos en una tabla. Solo puede haber un índice agrupado por tabla porque los datos solo se pueden ordenar físicamente de una manera. Un índice no agrupado es como un índice en un libro; almacena una estructura separada que contiene las columnas indexadas y punteros a las filas de datos en la tabla. Puede haber múltiples índices no agrupados por tabla.

Utilice un índice clúster cuando recupere datos con frecuencia en un orden específico o necesite consultas de rango eficientes. Los buenos candidatos para los índices clúster son las columnas que se usan a menudo en las cláusulas ORDER BY o para recuperar datos dentro de un rango de fechas específico. Utilice índices no clúster cuando necesite acelerar las consultas basadas en valores de columna específicos sin afectar el orden físico de los datos, o cuando tenga varias columnas en las que necesite buscar con frecuencia, pero no todas puedan caber en un índice clúster. También son útiles para las columnas que no se utilizan con frecuencia en las consultas de rango.

7. ¿Cómo diseñaría un esquema de base de datos para almacenar y consultar datos de series temporales de manera eficiente?

Para el almacenamiento y las consultas eficientes de datos de series temporales, optaría por un esquema optimizado para cargas de trabajo con mucha escritura y consultas basadas en rangos. Un enfoque común implica una tabla con columnas para la marca de tiempo, el nombre de la métrica y el valor. Indexar la columna de marca de tiempo es crucial. Además, considere usar una base de datos columnar o una base de datos de series temporales (TSDB) como TimescaleDB o InfluxDB. Estas están diseñadas específicamente para manejar datos de series temporales de manera eficiente, ofreciendo funciones como compresión de datos, políticas de retención y motores de consulta optimizados. La partición de la tabla por tiempo (por ejemplo, diaria o semanal) puede mejorar significativamente el rendimiento de las consultas al reducir la cantidad de datos escaneados.

Un esquema de ejemplo podría verse así:

CREATE TABLE métricas ( tiempo TIMESTAMPTZ NOT NULL, nombre_métrica TEXT NOT NULL, valor DOUBLE PRECISION NOT NULL ); CREATE INDEX ON métricas (tiempo);

8. Describa cómo usaría el particionamiento para mejorar el rendimiento de una tabla grande. ¿Cuáles son las consideraciones?

El particionamiento de una tabla grande implica dividirla en partes más pequeñas y manejables basándose en una clave específica. Esto mejora el rendimiento al permitir que las consultas escaneen solo las particiones relevantes en lugar de toda la tabla. Por ejemplo, si tiene una tabla de datos de ventas, podría particionarla por fecha (por ejemplo, mensual o anualmente). Al consultar las ventas de un mes específico, la base de datos solo necesita escanear la partición de ese mes, lo que reduce drásticamente la E/S y mejora la velocidad de la consulta.

Las consideraciones incluyen elegir la clave de partición adecuada (una columna consultada frecuentemente con buena cardinalidad), el número de particiones (demasiadas pueden generar sobrecarga, muy pocas niegan los beneficios) y el tipo de partición (rango, lista, hash). Además, se debe considerar la sobrecarga de mantenimiento, como la gestión de particiones. La asimetría de datos puede afectar el rendimiento si algunas particiones son significativamente más grandes que otras. El mantenimiento adecuado del índice en tablas particionadas también es crucial.

9. Escriba una consulta SQL para calcular un total acumulado o suma acumulativa de una columna en una tabla.

Para calcular un total acumulado en SQL, puede usar funciones de ventana. La cláusula SUM() OVER() es la clave. La cláusula ORDER BY dentro de OVER() especifica el orden en que se calcula el total acumulado. Si no se realiza ninguna partición, el total acumulado se calculará sobre toda la tabla.

SELECT column_to_sum, SUM(column_to_sum) OVER (ORDER BY order_column) AS running_total FROM your_table;

Reemplace column_to_sum con el nombre de la columna que desea sumar, order_column con la columna que define el orden para el cálculo del total acumulado y your_table con el nombre real de la tabla. La cláusula PARTITION BY se puede agregar en OVER() para calcular totales acumulados para cada partición por separado.

10. ¿Cómo puede usar Expresiones de Tabla Común (CTEs) para simplificar consultas complejas? Dé un ejemplo.

Las CTE, o Expresiones de Tabla Común, simplifican las consultas complejas dividiéndolas en conjuntos de resultados con nombre, más pequeños y más manejables. Luego, se puede hacer referencia a estos conjuntos de resultados con nombre dentro de la consulta principal, mejorando la legibilidad y el mantenimiento. Esencialmente, una CTE actúa como una vista temporal que existe solo durante la duración de una sola consulta.

Por ejemplo, considere un escenario en el que desea encontrar empleados que ganan más que el salario promedio de su departamento. Sin CTEs, esta consulta puede ser bastante compleja con subconsultas anidadas. Con CTEs, primero puede definir un CTE para calcular el salario promedio por departamento y luego unirlo con la tabla de empleados para filtrar los empleados. Aquí hay un ejemplo:

WITH AvgSalaries AS ( SELECT departamento, AVG(salario) AS avg_salario FROM empleados GROUP BY departamento ) SELECT e.nombre, e.salario, a.departamento, a.avg_salario FROM empleados e JOIN AvgSalaries a ON e.departamento = a.departamento WHERE e.salario > a.avg_salario;

En este ejemplo, la CTE AvgSalaries primero calcula el salario promedio para cada departamento, y luego se une con la tabla empleados para filtrar los registros.

11. Explique cómo usaría SQL para realizar enmascaramiento o anonimización de datos con fines de privacidad.

SQL puede realizar enmascaramiento y anonimización de datos de varias maneras para proteger la información confidencial. Las técnicas comunes incluyen:

• Sustitución: Reemplazar datos reales con valores realistas pero falsos. Por ejemplo, sustituir nombres con nombres generados aleatoriamente.
• Cifrado: Cifrar columnas sensibles utilizando funciones de cifrado. Solo los usuarios con las claves apropiadas pueden descifrar los datos.
• Hashing: Usar funciones de hashing (por ejemplo, SHA256) para transformar irreversiblemente los datos. Útil cuando no se necesita el valor original, solo su unicidad.
• Redacción: Eliminar partes de los datos. Por ejemplo, enmascarar todos los dígitos de un número de tarjeta de crédito excepto los últimos cuatro.
• Agregación: Reemplazar puntos de datos individuales con valores agregados (por ejemplo, promedios o conteos).

Por ejemplo, para enmascarar direcciones de correo electrónico, se podría usar UPDATE users SET email = CONCAT('user', id, '@example.com');. Para redactar parte de una columna de tarjeta de crédito UPDATE customers SET credit_card = CONCAT('XXXXXXXXXXXX', RIGHT(credit_card, 4));. Estas operaciones generalmente se llevan a cabo en una copia de los datos de producción o en un entorno seguro de desarrollo/prueba.

12. Describa cómo monitorearía y optimizaría el rendimiento de la base de datos. ¿Qué herramientas usaría?

Para monitorear el rendimiento de la base de datos, me centraría en métricas clave como el tiempo de ejecución de la consulta, la utilización de la CPU, el uso de la memoria, la E/S del disco y la contención de bloqueos. Usaría herramientas como el monitor de rendimiento integrado de la base de datos (por ejemplo, Performance Monitor en SQL Server, pg_stat_statements en PostgreSQL o MySQL Performance Schema). Otras herramientas útiles incluyen soluciones de monitoreo dedicadas como Prometheus con Grafana, Datadog o New Relic. Estas herramientas proporcionan paneles y alertas para identificar cuellos de botella en el rendimiento.

Para optimizar el rendimiento, comenzaría por identificar las consultas de ejecución lenta utilizando las herramientas de monitoreo. Luego analizaría los planes de ejecución para comprender cómo la base de datos está procesando la consulta. Las técnicas comunes de optimización incluyen: indexar columnas consultadas con frecuencia, reescribir consultas ineficientes, optimizar los tipos de datos, particionar tablas grandes y almacenar en caché los datos a los que se accede con frecuencia. Actualizar regularmente las estadísticas de la base de datos también es importante para que el optimizador de consultas tome decisiones informadas. Por ejemplo, para obtener el plan de ejecución en postgres:

EXPLAIN ANALYZE SELECT * FROM mytable WHERE column_name = 'some_value';

13. ¿Cómo implementaría una función de búsqueda de texto completo en su base de datos? ¿Cuáles son las opciones y las compensaciones?

La implementación de la búsqueda de texto completo implica varias opciones, cada una con sus propias compensaciones. Un enfoque es utilizar las capacidades integradas de búsqueda de texto completo de la base de datos, como tsvector y tsquery de PostgreSQL o los índices FULLTEXT de MySQL. Esto es conveniente, pero podría ofrecer una personalización y un rendimiento limitados en comparación con los motores de búsqueda dedicados. La compensación es la facilidad de implementación frente al control y la escalabilidad.

Otra opción es integrar un motor de búsqueda dedicado como Elasticsearch o Apache Solr. Estos proporcionan características avanzadas como stemming, sinónimos y clasificación de relevancia, junto con un mejor rendimiento para conjuntos de datos grandes. Sin embargo, esto añade complejidad al sistema, ya que requiere mantener un servicio separado y mantener el índice de búsqueda sincronizado con la base de datos. La compensación aquí es el aumento de la complejidad y los requisitos de recursos para una funcionalidad y un rendimiento de búsqueda mejorados.

14. Explique cómo puede usar SQL para auditar los cambios de datos y rastrear quién los hizo. Proporcione un ejemplo.

La auditoría SQL de los cambios de datos implica el seguimiento de las modificaciones (inserciones, actualizaciones, eliminaciones) realizadas en una tabla y el registro de quién las hizo y cuándo. Esto se puede lograr mediante el uso de desencadenadores (triggers). Un desencadenador es un tipo especial de procedimiento almacenado que se ejecuta automáticamente en respuesta a ciertos eventos en una tabla.

Aquí hay un ejemplo usando una tabla llamada empleados y una tabla de auditoría llamada auditoria_empleados:

-- Tabla de auditoría CREATE TABLE employee_audit ( audit_id INT PRIMARY KEY AUTO_INCREMENT, employee_id INT, old_name VARCHAR(255), new_name VARCHAR(255), updated_by VARCHAR(255), updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP ); -- Disparador para rastrear las actualizaciones a la tabla de empleados CREATE TRIGGER employees_AFTER_UPDATE AFTER UPDATE ON employees FOR EACH ROW BEGIN INSERT INTO employee_audit (employee_id, old_name, new_name, updated_by) VALUES (OLD.id, OLD.name, NEW.name, USER()); END;

Este disparador, employees_AFTER_UPDATE, insertará automáticamente una fila en la tabla employee_audit cada vez que se actualice una fila en la tabla employees. La función USER() captura el nombre de usuario del usuario que realizó la actualización. Se pueden crear disparadores similares para las operaciones INSERT y DELETE para capturar todos los cambios. Las palabras clave OLD y NEW permiten la comparación.

15. Describe un escenario en el que usarías una CTE recursiva y proporciona una consulta de ejemplo.

Una CTE (Expresión de Tabla Común) recursiva es útil para consultar datos jerárquicos o con estructura de árbol. Un ejemplo clásico es un organigrama o una lista de materiales. Imagine una tabla Employee con las columnas EmployeeID y ManagerID. Desea encontrar todos los empleados que reportan (directa o indirectamente) a un gerente específico.

Aquí hay una consulta de ejemplo que usa una CTE recursiva para lograr esto:

CON EmployeeHierarchy RECURSIVO COMO ( -- Miembro de anclaje: Selecciona los informes directos del gerente SELECT EmployeeID, ManagerID, 0 AS Nivel FROM Employee WHERE ManagerID = 'SpecificManagerID' UNION ALL -- Miembro recursivo: Selecciona a los empleados que reportan a los del nivel anterior SELECT e.EmployeeID, e.ManagerID, eh.Level + 1 AS Nivel FROM Employee e INNER JOIN EmployeeHierarchy eh ON e.ManagerID = eh.EmployeeID ) SELECT EmployeeID FROM EmployeeHierarchy;

16. ¿Cómo manejaría una situación en la que una consulta está agotando el tiempo de espera debido a restricciones de recursos? ¿Qué medidas tomaría para resolverlo?

Cuando una consulta agota el tiempo de espera debido a restricciones de recursos, primero identificaría el cuello de botella de recursos, que podría ser CPU, memoria o E/S. Usaría herramientas de monitoreo para identificar qué recurso se está agotando. Luego, me concentraría en optimizar la consulta en sí misma mediante:

• Analizar el plan de la consulta: Usar EXPLAIN (o el equivalente en la base de datos específica) para comprender cómo la base de datos está ejecutando la consulta e identificar posibles cuellos de botella de rendimiento, como exploraciones completas de tablas o índices faltantes.
• Agregar índices: Si la consulta está realizando exploraciones completas de tablas, agregar los índices apropiados a las columnas utilizadas en las cláusulas WHERE, las condiciones JOIN y las cláusulas ORDER BY puede mejorar significativamente el rendimiento.
• Reescribir la consulta: Considerar reescribir la consulta para que sea más eficiente, posiblemente usando estrategias de unión alternativas, subconsultas o dividiendo la consulta en partes más pequeñas y manejables.
• Limitar el conjunto de resultados: Si la consulta devuelve una gran cantidad de filas, considerar usar LIMIT para recuperar solo los datos necesarios.

Si la optimización de la consulta no resuelve completamente el problema, consideraría aumentar los recursos asignados (por ejemplo, más memoria, CPUs más rápidas) al servidor de la base de datos. Como solución temporal, podría aumentar la duración del tiempo de espera de la consulta, pero esta no es una solución a largo plazo. Ajustar las configuraciones de la base de datos, como el tamaño del grupo de búferes, también puede ayudar. Finalmente, si la carga de trabajo excede constantemente los recursos disponibles, consideraría estrategias de particionamiento/segmentación de la base de datos.

17. Explique las propiedades ACID de las transacciones de bases de datos y cómo garantizan la integridad de los datos.

Las propiedades ACID son un conjunto de principios que garantizan que las transacciones de bases de datos se procesen de forma fiable. Son: Atomicidad (todo o nada, una transacción se completa por completo o no se completa en absoluto), Consistencia (la transacción debe mantener las restricciones de integridad de la base de datos, moviendo la base de datos de un estado válido a otro), Aislamiento (las transacciones concurrentes no interfieren entre sí, apareciendo como si se ejecutaran secuencialmente) y Durabilidad (una vez que se confirma una transacción, sus cambios son permanentes, incluso en caso de fallas del sistema).

Estas propiedades garantizan la integridad de los datos al evitar actualizaciones parciales (Atomicidad), hacer cumplir las reglas (Consistencia), evitar conflictos entre usuarios (Aislamiento) y garantizar la supervivencia de los datos (Durabilidad). Por ejemplo, considere una transferencia bancaria. La atomicidad asegura que ocurra la resta de una cuenta y el crédito a otra, o ninguna de las dos. El aislamiento evita problemas si dos transferencias a la misma cuenta ocurren al mismo tiempo.

18. ¿Cómo maneja los valores nulos en las consultas SQL para evitar resultados inesperados? Dé ejemplos.

Para manejar los valores nulos en las consultas SQL, utilizo principalmente los operadores IS NULL e IS NOT NULL para filtrar. Por ejemplo, para seleccionar todas las filas donde la columna email es nula, usaría SELECT * FROM usuarios WHERE email IS NULL;. Por el contrario, para seleccionar filas donde email no es nulo: SELECT * FROM usuarios WHERE email IS NOT NULL;.

Además, la función COALESCE() es valiosa para reemplazar valores nulos con un valor predeterminado especificado. Por ejemplo, SELECT COALESCE(email, 'no_email@example.com') FROM users; devolvería la dirección de correo electrónico si existe, o 'no_email@example.com' si el correo electrónico es nulo. Estas técnicas ayudan a prevenir comportamientos inesperados en comparaciones y cálculos que involucran nulos, asegurando que los resultados de la consulta sean predecibles y precisos. El uso de funciones como NVL() y NULLIF() (dependiendo del sistema de base de datos) tiene un propósito similar.

19. Describa cómo usaría SQL para realizar la validación de datos y garantizar la calidad de los datos.

SQL se puede usar para aplicar la validación de datos a través de varios mecanismos. Se pueden definir restricciones CHECK en las tablas para garantizar que los valores de una columna cumplan con criterios específicos (por ejemplo, una fecha está dentro de un rango válido, una cadena coincide con un patrón determinado). Las restricciones NOT NULL evitan la falta de datos en las columnas requeridas. Las restricciones UNIQUE garantizan que no haya valores duplicados en una columna o conjunto de columnas. Las restricciones de clave externa (FOREIGN KEY) mantienen la integridad referencial entre las tablas, lo que garantiza que las relaciones entre las tablas sean válidas. Además, se pueden crear procedimientos almacenados para realizar una lógica de validación más compleja antes de que se inserten o actualicen los datos.

Para mejorar aún más la calidad de los datos, SQL se puede utilizar para el perfilado de datos con el fin de identificar inconsistencias o anomalías. Por ejemplo, puede usar COUNT(DISTINCT column_name) para comprobar la singularidad de los datos, o funciones agregadas como MIN, MAX, AVG para encontrar valores atípicos y posibles errores de datos. Las consultas SQL también se pueden programar para ejecutarse regularmente con el fin de identificar problemas de calidad de datos y activar alertas. El uso de sentencias CASE ayuda a categorizar y validar los datos basándose en diferentes reglas.

20. ¿Cómo optimizaría las consultas SQL que involucran subconsultas? ¿Cuáles son las alternativas?

Para optimizar las consultas SQL con subconsultas, concéntrese en reescribirlas. Las subconsultas a menudo pueden ser ineficientes, especialmente las subconsultas correlacionadas, porque podrían ejecutarse para cada fila procesada por la consulta externa. Aquí hay algunas alternativas:

• JOINs: Reemplace las subconsultas (especialmente en la cláusula WHERE) con operaciones JOIN. Esto permite que el optimizador de la base de datos combine eficientemente los datos de múltiples tablas.
• Tablas temporales/Expresiones de tabla comunes (CTEs): Para subconsultas complejas, cree una tabla temporal o use un CTE para almacenar el resultado intermedio. Luego, consulte la tabla temporal/CTE. Los CTEs ayudan a mejorar la legibilidad y a veces pueden permitir que el optimizador tome mejores decisiones.
• Índices: Asegúrese de que los índices apropiados estén en su lugar en las columnas involucradas en la subconsulta y en las condiciones de unión o la cláusula WHERE de la consulta externa. Los índices aceleran significativamente la recuperación de datos.
• Reescritura con EXISTS o NOT EXISTS: A veces, las subconsultas IN o NOT IN se pueden reemplazar con EXISTS o NOT EXISTS para un mejor rendimiento, particularmente con grandes conjuntos de datos.

Por ejemplo, en lugar de SELECT * FROM orders WHERE customer_id IN (SELECT customer_id FROM customers WHERE city = 'New York'), podría usar SELECT o.* FROM orders o JOIN customers c ON o.customer_id = c.customer_id WHERE c.city = 'New York'. Además, considere usar el plan de ejecución de consultas de su base de datos para analizar e identificar cuellos de botella. Basado en el plan de ejecución, ajuste los índices o la estructura de la consulta para un rendimiento óptimo.

21. Explique cómo usaría los disparadores de la base de datos para automatizar tareas o hacer cumplir las reglas de negocio.

Los disparadores de base de datos son procedimientos almacenados especiales que se ejecutan automáticamente en respuesta a ciertos eventos en una tabla o vista en particular. Los usaría para automatizar tareas como auditar cambios en los datos, actualizar automáticamente datos derivados o hacer cumplir reglas de negocio complejas. Por ejemplo, podría crear un disparador que se active AFTER INSERT en una tabla Orders para actualizar automáticamente la tabla Customer con el recuento total de pedidos del cliente. Esto elimina la necesidad de actualizar Customer en el código de la aplicación, centralizando la lógica en la base de datos.

Otro caso de uso es hacer cumplir las reglas de negocio. Un disparador puede activarse BEFORE INSERT en una tabla Products para asegurar que el precio del producto esté dentro de un rango aceptable. IF NEW.price < minimum_price THEN SIGNAL SQLSTATE '45000' SET MESSAGE_TEXT = 'Price below minimum'; END IF;. Esto impone una regla de negocio a nivel de la base de datos, evitando que entren datos incorrectos en el sistema, independientemente de la aplicación utilizada para insertar los datos.

22. Diseñe una consulta para encontrar los N registros superiores dentro de cada grupo, como los 3 clientes con las ventas más altas en cada región.

Para encontrar los N registros superiores dentro de cada grupo (por ejemplo, los 3 clientes con las ventas más altas en cada región), puede utilizar funciones de ventana (también conocidas como funciones analíticas) en SQL. Las funciones de ventana ROW_NUMBER(), RANK() o DENSE_RANK() son muy efectivas para esta tarea.

Aquí hay una estructura general de consulta SQL usando ROW_NUMBER():

SELECT * FROM ( SELECT *, ROW_NUMBER() OVER (PARTITION BY region ORDER BY sales DESC) as rn FROM customers ) AS subquery WHERE rn <= 3;

En este ejemplo:

• PARTITION BY region divide los datos en grupos basados en la columna region.
• ORDER BY sales DESC ordena los clientes dentro de cada región por sus sales en orden descendente.
• ROW_NUMBER() OVER (...) asigna un rango único a cada cliente dentro de cada región basado en las ventas.
• La consulta externa filtra los resultados para incluir solo los 3 clientes principales (donde rn <= 3) en cada región.

23. ¿Cómo puede utilizar los planes de explicación para comprender el plan de ejecución de una consulta e identificar posibles cuellos de botella?

Los planes de explicación son herramientas invaluables para comprender cómo una base de datos ejecuta una consulta. Al examinar el plan de explicación, se puede ver la secuencia de operaciones que la base de datos realizará, como exploraciones de tablas, búsquedas de índices, uniones y ordenaciones. Esto permite identificar posibles cuellos de botella, como exploraciones completas de tablas en tablas grandes (donde un índice podría ser más eficiente), algoritmos de unión ineficientes o índices faltantes.

Para usar un plan de explicación, generalmente se antepone la consulta con EXPLAIN (o un equivalente específico de la base de datos, como EXPLAIN ANALYZE para PostgreSQL). La salida detalla cada paso de la ejecución. Las métricas clave para analizar incluyen el costo estimado, el número de filas procesadas y el tipo de método de acceso utilizado (por ejemplo, búsqueda de índice vs. exploración completa de la tabla). Al centrarse en los pasos más caros, se pueden explorar estrategias de optimización como agregar índices, reescribir la consulta o actualizar las estadísticas.

Consultas SQL MCQ

Pregunta 1.

Considere dos tablas: Empleados (EmpID, EmpName, DeptID, Salary) y Departamentos (DeptID, DeptName). ¿Qué consulta SQL recupera los nombres de los empleados que trabajan en el departamento de 'Ventas' y tienen un salario superior a $60,000?

Opciones:

SELECT EmpName FROM Employees WHERE DeptID = (SELECT DeptID FROM Departments WHERE DeptName = 'Sales') AND Salary > 60000;

SELECT EmpName FROM Employees JOIN Departments ON Employees.DeptID = Departments.DeptID WHERE DeptName = 'Sales' AND Salary < 60000;

SELECT EmpName FROM Employees WHERE DeptName = 'Sales' AND Salary > 60000;

SELECT EmpName FROM Employees WHERE DeptID IN (SELECT DeptID FROM Departments WHERE DeptName = 'Sales') OR Salary > 60000;

Pregunta 2.

¿Qué consulta SQL calcula el número total de pedidos realizados por cada cliente y ordena los resultados por el número de pedidos en orden descendente?

Opciones:

SELECT customer_id, COUNT(*) AS total_orders FROM orders GROUP BY customer_id ORDER BY total_orders DESC;

SELECT customer_id, SUM(order_amount) AS total_orders FROM orders ORDER BY total_orders DESC;

SELECT customer_id, COUNT(*) AS total_orders FROM orders ORDER BY total_orders ASC;

SELECT customer_id, MAX(order_id) AS total_orders FROM orders GROUP BY customer_id ORDER BY total_orders DESC;

Pregunta 3.

¿Qué consulta SQL recupera los nombres de todos los productos con un precio superior al precio promedio de los productos en la tabla 'Productos', y ordena los resultados por precio en orden descendente?

Opciones:

Opciones:

SELECCIONAR nombre_producto DE Productos DONDE precio > AVG(precio) ORDENAR POR precio DESC;

SELECCIONAR nombre_producto DE Productos DONDE precio > (SELECCIONAR AVG(precio) DE Productos) ORDENAR POR precio DESC;

SELECCIONAR nombre_producto DE Productos DONDE precio > ALL(SELECCIONAR precio DE Productos) ORDENAR POR precio DESC;

SELECCIONAR nombre_producto DE Productos DONDE precio > ANY(SELECCIONAR precio DE Productos) ORDENAR POR precio DESC;

Pregunta 4.

¿Qué consulta SQL calcula el salario promedio para cada departamento, pero solo incluye los departamentos con más de 5 empleados?

Opciones:

Opciones:

SELECCIONAR departamento, AVG(salario) DE empleados DONDE COUNT(*) > 5 AGRUPAR POR departamento;

SELECCIONAR departamento, AVG(salario) DE empleados AGRUPAR POR departamento TENIENDO COUNT(*) > 5;

SELECCIONAR departamento, AVG(salario) DE empleados AGRUPAR POR departamento DONDE COUNT(*) > 5;

SELECCIONAR departamento, AVG(salario) DE empleados TENIENDO COUNT(*) > 5 AGRUPAR POR departamento;

Pregunta 5.

¿Qué consulta SQL recupera el nombre del cliente que realizó el pedido más reciente, suponiendo que tiene tablas llamadas Clientes (con columnas CustomerID, CustomerName) y Pedidos (con columnas OrderID, CustomerID, OrderDate)?

Opciones:

SELECCIONAR CustomerName DE Clientes DONDE CustomerID EN (SELECCIONAR CustomerID DE Pedidos ORDENAR POR OrderDate DESC LIMIT 1);

SELECCIONAR CustomerName DE Clientes DONDE CustomerID = (SELECCIONAR MAX(CustomerID) DE Pedidos);

SELECT CustomerName FROM Customers JOIN Orders ON Customers.CustomerID = Orders.CustomerID GROUP BY CustomerName ORDER BY MAX(OrderDate) DESC LIMIT 1;

SELECT CustomerName FROM Customers WHERE EXISTS (SELECT * FROM Orders WHERE Customers.CustomerID = Orders.CustomerID AND OrderDate = MAX(OrderDate));

Pregunta 6.

¿Qué consulta SQL recupera los nombres de los departamentos donde el salario máximo de los empleados en ese departamento es mayor que el salario promedio de todos los empleados en todos los departamentos?

Opciones:

SELECT department_name FROM departments WHERE MAX(salary) > (SELECT AVG(salary) FROM employees);

SELECT d.department_name FROM departments d JOIN employees e ON d.department_id = e.department_id GROUP BY d.department_name HAVING MAX(e.salary) > (SELECT AVG(salary) FROM employees);

SELECT department_name FROM departments WHERE salary > AVG(salary);

SELECT d.department_name FROM departments d JOIN employees e ON d.department_id = e.department_id WHERE MAX(e.salary) > AVG(e.salary);

Pregunta 7.

¿Qué consulta SQL recupera los nombres de los empleados que son gerentes y tienen un salario mayor que el salario promedio de todos los empleados que son analistas?

Opciones:

SELECT name FROM employees WHERE job_title = 'Manager' AND salary > (SELECT AVG(salary) FROM employees WHERE job_title = 'Analyst');

SELECT name FROM employees WHERE job_title = 'Manager' AND salary > AVG(salary) FROM employees WHERE job_title = 'Analyst';

SELECT name FROM employees WHERE job_title = 'Manager' AND salary > ALL (SELECT salary FROM employees WHERE job_title = 'Analyst');

SELECT name FROM employees WHERE job_title = 'Analyst' AND salary > (SELECT AVG(salary) FROM employees WHERE job_title = 'Manager');

Pregunta 8.

¿Qué consulta SQL recupera los nombres de los empleados que tienen el mismo salario que el salario más alto dentro de su departamento respectivo?

Opciones:

SELECT employee_name FROM employees WHERE salary = MAX(salary) GROUP BY department_id;

SELECCIONA nombre_empleado DE empleados DONDE (id_departamento, salario) EN (SELECCIONA id_departamento, MAX(salario) DE empleados AGRUPAR POR id_departamento);

SELECCIONA nombre_empleado DE empleados DONDE salario EN (SELECCIONA MAX(salario) DE empleados);

SELECCIONA nombre_empleado DE empleados DONDE salario = (SELECCIONA MAX(salario) DE empleados DONDE id_departamento = empleados.id_departamento);

Pregunta 9.

¿Qué consulta SQL recupera los nombres de los empleados cuyo salario es mayor que el salario de al menos un empleado en el departamento de 'Marketing'?

Opciones:

SELECCIONA nombre DE Empleados DONDE salario > (SELECCIONA MIN(salario) DE Empleados DONDE departamento = 'Marketing');

SELECCIONA nombre DE Empleados DONDE salario > ALL (SELECCIONA salario DE Empleados DONDE departamento = 'Marketing');

SELECCIONA nombre DE Empleados DONDE salario = ANY (SELECCIONA salario DE Empleados DONDE departamento = 'Marketing');

SELECCIONA nombre DE Empleados DONDE salario < (SELECCIONA MAX(salario) DE Empleados DONDE departamento = 'Marketing');

Pregunta 10.

¿Qué consulta SQL recupera los nombres de todos los departamentos que no tienen ningún empleado?

Opciones:

SELECCIONA department_name DE departamentos DONDE NO EXISTE (SELECCIONA 1 DE empleados DONDE empleados.department_id = departamentos.department_id);

SELECCIONA department_name DE departamentos DONDE EXISTE (SELECCIONA 1 DE empleados DONDE empleados.department_id = departamentos.department_id);

SELECCIONA department_name DE departamentos DONDE department_id NO ESTÁ EN (SELECCIONA department_id DE empleados);

SELECCIONA department_name DE departamentos DONDE department_id ESTÁ EN (SELECCIONA department_id DE empleados);

Pregunta 11.

Dada una tabla Productos con las columnas nombre_producto, categoría y precio, ¿qué consulta SQL recupera los nombres de los productos cuyo precio es superior al precio promedio de los productos dentro de la misma categoría?

Opciones:

SELECCIONA nombre_producto DE Productos DONDE precio > AVG(precio) AGRUPAR POR categoría;

SELECCIONA nombre_producto DE Productos DONDE precio > (SELECCIONA AVG(precio) DE Productos);

SELECCIONA nombre_producto DE Productos p1 DONDE precio > (SELECCIONA AVG(precio) DE Productos p2 DONDE p1.categoría = p2.categoría);

SELECCIONA nombre_producto DE Productos DONDE precio > ALL (SELECCIONA precio DE Productos);

Pregunta 12.

¿Qué consulta SQL calcula correctamente el salario total para cada departamento?

Opciones:

SELECCIONA departamento, SUM(salario) DE empleados;

SELECCIONA departamento, AVG(salario) DE empleados AGRUPAR POR departamento;

SELECCIONA departamento, SUM(salario) DE empleados AGRUPAR POR departamento;

SELECCIONA SUM(salario) DE empleados ORDENAR POR departamento;

Pregunta 13.

¿Qué consulta SQL recupera los nombres de los empleados que ganan más que todos los empleados del departamento de 'Finanzas'?

Opciones:

SELECCIONA nombre DE Empleados DONDE salario > (SELECCIONA MAX(salario) DE Empleados DONDE departamento = 'Finanzas');

SELECCIONA nombre DE Empleados DONDE salario > ALL (SELECCIONA salario DE Empleados DONDE departamento = 'Finanzas');

SELECCIONA nombre DE Empleados DONDE salario > ANY (SELECCIONA salario DE Empleados DONDE departamento = 'Finanzas');

SELECCIONAR nombre DE Empleados DONDE salario > (SELECCIONAR salario DE Empleados DONDE departamento = 'Finanzas');

Pregunta 14.

¿Qué consulta SQL recupera los nombres de los empleados que tienen un salario superior al salario de cada empleado en el departamento de 'Marketing'?

Opciones:

SELECCIONAR nombre DE empleados DONDE salario > (SELECCIONAR MAX(salario) DE empleados DONDE departamento = 'Marketing');

SELECCIONAR nombre DE empleados DONDE salario > ALL (SELECCIONAR salario DE empleados DONDE departamento = 'Marketing');

SELECCIONAR nombre DE empleados DONDE salario > ANY (SELECCIONAR salario DE empleados DONDE departamento = 'Marketing');

SELECCIONAR nombre DE empleados DONDE salario > (SELECCIONAR AVG(salario) DE empleados DONDE departamento = 'Marketing');

Pregunta 15.

¿Qué consulta SQL recupera los nombres de los departamentos donde el salario promedio de los empleados en ese departamento es mayor que el salario promedio general de todos los empleados en todos los departamentos?

Opciones:

• A) SELECCIONAR nombre_departamento DE departamentos DONDE AVG(salario) > (SELECCIONAR AVG(salario) DE empleados);
• B) SELECCIONAR d.nombre_departamento DE departamentos d UNIR empleados e EN d.id_departamento = e.id_departamento AGRUPAR POR d.nombre_departamento TENIENDO AVG(e.salario) > (SELECCIONAR AVG(salario) DE empleados);
• C) SELECCIONAR nombre_departamento DE departamentos DONDE salario > (SELECCIONAR AVG(salario) DE empleados);
• D) SELECCIONAR d.nombre_departamento DE departamentos d UNIR empleados e EN d.id_departamento = e.id_departamento DONDE AVG(e.salario) > (SELECCIONAR AVG(salario) DE empleados);

Opciones:

SELECCIONAR nombre_departamento DE departamentos DONDE PROMEDIO(salario) > (SELECCIONAR PROMEDIO(salario) DE empleados);

SELECCIONAR d.nombre_departamento DE departamentos d UNIR empleados e EN d.id_departamento = e.id_departamento AGRUPAR POR d.nombre_departamento TENIENDO PROMEDIO(e.salario) > (SELECCIONAR PROMEDIO(salario) DE empleados);

SELECCIONAR nombre_departamento DE departamentos DONDE salario > (SELECCIONAR PROMEDIO(salario) DE empleados);

SELECCIONAR d.nombre_departamento DE departamentos d UNIR empleados e EN d.id_departamento = e.id_departamento DONDE PROMEDIO(e.salario) > (SELECCIONAR PROMEDIO(salario) DE empleados);

Pregunta 16.

¿Qué consulta SQL recupera el departamento con el salario promedio más alto?

opciones:

Opciones:

SELECCIONAR nombre_departamento DE departamentos ORDENAR POR PROMEDIO(salario) DESC LIMITAR 1;

SELECCIONAR nombre_departamento DE empleados AGRUPAR POR nombre_departamento ORDENAR POR PROMEDIO(salario) DESC LIMITAR 1;

SELECCIONAR MAXIMO(PROMEDIO(salario)), nombre_departamento DE empleados AGRUPAR POR nombre_departamento;

SELECCIONAR nombre_departamento DE empleados DONDE salario = (SELECCIONAR MAXIMO(PROMEDIO(salario)) DE empleados);

Pregunta 17.

¿Qué consulta SQL identifica a los clientes que han realizado un número de pedidos superior al número promedio de pedidos realizados por todos los clientes?

Opciones:

Opciones:

SELECCIONAR id_cliente DE Pedidos AGRUPAR POR id_cliente TENIENDO CONTAR(*) > PROMEDIO(CONTAR(*));

SELECT customer_id FROM Orders GROUP BY customer_id HAVING COUNT(*) > (SELECT AVG(order_count) FROM (SELECT COUNT(*) AS order_count FROM Orders GROUP BY customer_id) AS CustomerOrderCounts);

SELECT customer_id FROM Orders WHERE COUNT(*) > AVG(COUNT(*));

SELECT customer_id FROM Orders WHERE order_quantity > (SELECT AVG(order_quantity) FROM Orders);

Pregunta 18.

¿Qué consulta SQL recupera los nombres de todos los departamentos donde cada salario de empleado es superior a $50,000?

Opciones:

SELECT department_name FROM Departments WHERE ALL (SELECT salary FROM Employees WHERE department_id = Departments.department_id) > 50000;

SELECT d.department_name FROM Departments d WHERE NOT EXISTS (SELECT 1 FROM Employees e WHERE e.department_id = d.department_id AND e.salary <= 50000);

SELECT department_name FROM Departments WHERE MIN(salary) > 50000;

SELECT d.department_name FROM Departments d WHERE (SELECT AVG(salary) FROM Employees e WHERE e.department_id = d.department_id) > 50000;

Pregunta 19.

¿Qué consulta SQL recupera los nombres de los empleados que reportan a un gerente cuyo salario es superior a $80,000? Supongamos que la tabla Employees tiene las columnas employee_id, employee_name, manager_id y salary. La columna manager_id hace referencia al employee_id del gerente.

Opciones:

```sql SELECT E.employee_name FROM Employees E WHERE E.manager_id IN (SELECT employee_id FROM Employees WHERE salary > 80000); ```

```sql SELECT E.employee_name FROM Employees E WHERE E.salary > 80000; ```

```sql SELECT E.employee_name FROM Employees E WHERE E.manager_id = (SELECT employee_id FROM Employees WHERE salary > 80000); ```

SELECT M.employee_name FROM Empleados E JOIN Empleados M ON E.manager_id = M.employee_id WHERE M.salary > 80000;

Pregunta 20.

¿Qué consulta SQL recupera el segundo salario más alto de la tabla 'Empleados'? Asuma que la tabla tiene las columnas 'employee_id', 'nombre' y 'salario'.

Opciones:

Opciones:

SELECT MAX(salary) FROM Employees WHERE salary < (SELECT MAX(salary) FROM Employees);

SELECT TOP 2 salary FROM Employees ORDER BY salary DESC;

SELECT DISTINCT salary FROM Employees ORDER BY salary DESC LIMIT 1 OFFSET 1;

SELECT salary FROM Employees ORDER BY salary DESC LIMIT 2;

Pregunta 21.

¿Qué consulta SQL recupera el(los) departamento(s) con el salario promedio más bajo?

opciones:

Opciones:

SELECT department_name FROM employees GROUP BY department_name ORDER BY AVG(salary) ASC LIMIT 1;

SELECT department_name FROM employees WHERE salary = MIN(salary);

SELECT department_name FROM employees GROUP BY department_name HAVING AVG(salary) = MIN(AVG(salary));

SELECT department_name FROM employees ORDER BY AVG(salary) DESC LIMIT 1;

Pregunta 22.

Escriba una consulta SQL para recuperar los nombres de los empleados que se unieron a la empresa antes que cualquier empleado del departamento de 'Ventas'. Considere la tabla employees con las columnas employee_id, employee_name, department, y join_date.

Opciones:

SELECT employee_name FROM employees WHERE join_date < (SELECT MIN(join_date) FROM employees WHERE department = 'Sales');

SELECT employee_name FROM employees WHERE join_date > (SELECT MAX(join_date) FROM employees WHERE department = 'Sales');

SELECT employee_name FROM employees WHERE join_date < (SELECT AVG(join_date) FROM employees WHERE department = 'Sales');

SELECT employee_name FROM employees WHERE join_date = (SELECT MIN(join_date) FROM employees WHERE department = 'Sales');

Pregunta 23.

¿Qué consulta SQL recupera las ventas totales de cada categoría de producto, pero solo incluye aquellas categorías donde el número total de ventas supera las 100?

Opciones:

Opciones:

SELECT category, SUM(sales) FROM sales_table GROUP BY category WHERE COUNT(*) > 100;

SELECT category, SUM(sales) FROM sales_table WHERE COUNT(*) > 100 GROUP BY category;

SELECT category, SUM(sales) FROM sales_table GROUP BY category HAVING SUM(sales) > 100;

SELECT category, SUM(sales) FROM sales_table WHERE SUM(sales) > 100 GROUP BY category;

Pregunta 24.

¿Qué consulta SQL recupera los nombres de los departamentos donde el salario mínimo de los empleados es superior a $50,000 y el salario promedio es inferior a $70,000?

Opciones:

Opciones:

SELECT department_name FROM departments WHERE MIN(salary) > 50000 AND AVG(salary) < 70000;

SELECT department_name FROM employees GROUP BY department_name HAVING MIN(salary) > 50000 AND AVG(salary) < 70000;

SELECT department_name FROM employees GROUP BY department_name HAVING MIN(salary) > 50000 AND AVG(salary) < 70000 ORDER BY department_name;

SELECT department_name FROM employees GROUP BY department_name HAVING MIN(salary) > 50000 AND AVG(salary) < 70000;

SELECT department_name FROM employees GROUP BY department_name HAVING MIN(salary) > 50000 AND AVG(salary) < 70000;

SELECT department_name FROM employees GROUP BY department_name HAVING MIN(salary) > 50000 AND AVG(salary) < 70000;

Pregunta 25.

¿Qué consulta SQL recupera los nombres de los empleados que comparten el mismo departamento y el mismo puesto de trabajo con al menos otro empleado?

opciones:

Opciones:

SELECT E1.name FROM Employees E1 JOIN Employees E2 ON E1.department_id = E2.department_id AND E1.job_title = E2.job_title WHERE E1.employee_id <> E2.employee_id;

SELECT name FROM Employees WHERE department_id IN (SELECT department_id FROM Employees GROUP BY department_id HAVING COUNT(*) > 1);

SELECCIONA E1.nombre DE Empleados E1, Empleados E2 DONDE E1.salario = E2.salario Y E1.employee_id != E2.employee_id;

SELECCIONA nombre DE Empleados DONDE puesto_de_trabajo EN (SELECCIONA puesto_de_trabajo DE Empleados AGRUPAR POR puesto_de_trabajo TENIENDO EN CUENTA CONTAR(*) > 1);

¿Qué habilidades de consultas SQL deberías evaluar durante la fase de entrevista?

No se puede evaluar todo sobre un candidato en una sola entrevista. Sin embargo, para las consultas SQL, la evaluación de algunas habilidades básicas indicará significativamente las capacidades de un candidato. Estas incluyen la comprensión de los fundamentos de la base de datos, la escritura de consultas efectivas y la optimización del rendimiento.

Fundamentos de SQL

Verifique si los candidatos realmente conocen sus SQL con una evaluación de SQL que haga preguntas específicas. Esto puede ayudarlo a filtrar a los candidatos que tienen una base sólida y a aquellos que no.

Para evaluar su comprensión, pruebe una pregunta que les exija demostrar su entendimiento de los conceptos básicos de SQL.

Escriba una consulta SQL para seleccionar todas las columnas de una tabla llamada 'Empleados' donde el 'Departamento' sea 'Ventas'.

Busque que el candidato use SELECT *, FROM Empleados y WHERE Departamento = 'Ventas' correctamente. También deben entender cómo especificar el nombre de la tabla y la condición en la cláusula WHERE.

Escritura de Consultas

Evalúe a los candidatos sobre sus habilidades de escritura de consultas SQL usando preguntas de opción múltiple (MCQ) relevantes. Esto ayuda a identificar a los candidatos que pueden escribir consultas complejas y manipular datos de manera efectiva.

Puede evaluar esto con una pregunta que les exija unir tablas y usar funciones agregadas.

Dadas dos tablas, 'Pedidos' y 'Clientes', escriba una consulta para encontrar el número total de pedidos realizados por cada cliente.

El candidato debe ser capaz de usar una cláusula JOIN para combinar las tablas, GROUP BY para agrupar por cliente y COUNT() para contar el número de pedidos. Usar correctamente alias para mayor claridad también es un plus.

Optimización de consultas

Identifique candidatos con conocimientos de optimización con preguntas de opción múltiple (MCQ) enfocadas en la indexación y los planes de ejecución de consultas. Estas pruebas ayudan a descartar a los candidatos que solo escriben consultas, pero no entienden el rendimiento.

Haga una pregunta sobre optimización para verificar esta habilidad.

¿Cómo optimizaría una consulta de ejecución lenta que recupera datos de una tabla grande?

Busque respuestas que mencionen la indexación, el análisis del plan de ejecución de la consulta y la reescritura de la consulta para evitar escaneos completos de la tabla. Puntos extra si mencionan técnicas específicas como el uso de cláusulas WHERE con columnas indexadas.

3 consejos para usar preguntas de entrevista sobre consultas SQL

Antes de empezar a poner en práctica lo que ha aprendido, aquí tiene nuestros tres mejores consejos para ayudarle a sacar el máximo partido a las consultas SQL en su proceso de entrevista. Seguir estas sugerencias mejorará sus posibilidades de identificar a los mejores candidatos.

1. Aproveche las pruebas de habilidades SQL para agilizar la selección inicial

Ahorre un valioso tiempo de entrevista utilizando pruebas de habilidades SQL como parte de su proceso de selección inicial. Esto le permitirá evaluar rápidamente las habilidades prácticas de SQL de los candidatos y filtrar a aquellos que no cumplan con sus requisitos.

Considere la posibilidad de utilizar la Prueba en línea de SQL o la Prueba de codificación de SQL de Adaface para evaluar la competencia de los candidatos en la escritura y depuración de consultas SQL. Para aquellos que requieren experiencia en sistemas de bases de datos específicos, también ofrecemos pruebas adaptadas para MySQL, PostgreSQL, MS SQL Server y más. Consulte nuestra completa biblioteca de pruebas para obtener más opciones.

Al integrar estas evaluaciones, puede medir objetivamente las habilidades de SQL de un candidato, asegurando que el tiempo de la entrevista se reserve para discusiones más profundas con individuos calificados. Este enfoque le ayuda a tomar decisiones basadas en datos al principio del proceso de contratación.

2. Esboce estratégicamente preguntas clave de la entrevista de SQL

El tiempo es un bien precioso durante las entrevistas, así que sea estratégico con las preguntas de SQL que seleccione. Elegir un conjunto enfocado de preguntas relevantes le ayuda a maximizar su evaluación de los candidatos en los aspectos más críticos del puesto.

Más allá de las preguntas específicas de SQL, considere explorar áreas relacionadas que complementen las habilidades de base de datos. Las preguntas de la entrevista sobre modelado de datos y análisis de datos pueden revelar la capacidad de un candidato para diseñar e interpretar estructuras de datos, mientras que las preguntas que evalúan las habilidades de comunicación pueden medir su capacidad para explicar conceptos técnicos de manera clara.

Seleccione cuidadosamente su conjunto de preguntas para asegurarse de que cubre los conceptos esenciales de SQL y las habilidades relacionadas, proporcionando una evaluación completa del potencial de cada candidato.

3. Domine el arte de hacer preguntas de seguimiento

Simplemente plantear preguntas de SQL no es suficiente; la verdadera información proviene del seguimiento. Las preguntas de seguimiento reflexivas son clave para comprender verdaderamente la profundidad del conocimiento de un candidato.

Por ejemplo, después de pedirle a un candidato que escriba una consulta SQL para recuperar datos específicos, haga un seguimiento con preguntas como: '¿Cómo funcionaría esta consulta con un conjunto de datos muy grande?' Esto revelará su comprensión de la optimización de consultas y la escalabilidad.

Contrate al mejor talento de SQL con evaluaciones específicas

¿Buscas contratar candidatos con sólidas habilidades en SQL? Evaluar con precisión sus habilidades es clave. El uso de pruebas de habilidades es la forma más efectiva de validar su experiencia. Explora la gama de pruebas de SQL de Adaface, incluidas pruebas para MySQL, PostgreSQL y más.

Una vez que hayas identificado a los mejores candidatos a través de evaluaciones de habilidades, es hora de invitarlos a entrevistas. ¿Listo para comenzar? Regístrate u obtén más información sobre nuestra plataforma de evaluación en línea.

Prueba de SQL en línea

25 minutos | 10 MCQs

La prueba de SQL en línea evalúa la capacidad del candidato para diseñar y construir bases de datos relacionales y tablas desde cero, aplicar opciones CRUD, escribir consultas y subconsultas eficientes para filtrar datos y crear índices eficientes para consultas SQL más rápidas.

[

Prueba de SQL en línea

](https://www.adaface.com/assessment-test/sql-online-test)

Descarga la plantilla de preguntas de entrevista de consultas SQL en múltiples formatos

Preguntas frecuentes sobre preguntas de la entrevista de consultas SQL

Las preguntas básicas de la entrevista de SQL cubren temas como las declaraciones SELECT, las cláusulas WHERE, los JOIN y la comprensión de las claves principales y externas. Evalúan la capacidad de un candidato para recuperar y manipular datos de una base de datos.

Las preguntas intermedias de la entrevista de SQL podrían involucrar subconsultas, funciones agregadas (COUNT, SUM, AVG), GROUP BY, cláusulas HAVING y la comprensión de diferentes tipos de JOIN (LEFT, RIGHT, INNER, OUTER). Estas preguntas evalúan la capacidad de un candidato para realizar análisis de datos más complejos.

Las preguntas avanzadas de la entrevista de SQL podrían cubrir temas como funciones de ventana, expresiones de tabla comunes (CTEs), procedimientos almacenados, desencadenadores, indexación, optimización de consultas y gestión de transacciones. Ponen a prueba la capacidad de un candidato para diseñar y optimizar soluciones de bases de datos.

Las preguntas de la entrevista de SQL para expertos podrían profundizar en la arquitectura de la base de datos, el ajuste del rendimiento a escala, la replicación, el sharding, las mejores prácticas de seguridad y las técnicas avanzadas de modelado de datos. Evalúan el dominio de un candidato en SQL y la administración de bases de datos.

Utilice preguntas de la entrevista de SQL para evaluar la comprensión de un candidato sobre los conceptos de bases de datos, las habilidades de resolución de problemas y la capacidad de escribir código SQL limpio y optimizado. Combine preguntas teóricas con ejercicios prácticos para obtener una visión holística.

Busque candidatos que demuestren sólidas habilidades de comunicación, la capacidad de trabajar en equipo, la pasión por los datos y la voluntad de aprender y adaptarse a las nuevas tecnologías. La aptitud para la resolución de problemas y la atención al detalle también son buenos indicadores.