Ver Consultas SQL en Laravel: todas las formas de inspeccionar y depurar tus queries

Cuando desarrollamos aplicaciones en Laravel, gran parte de la magia ocurre gracias a Eloquent y el Query Builder. Escribimos código limpio, expresivo… pero bajo el capó Laravel está generando consultas SQL reales que impactan directamente en el rendimiento.

En mi experiencia, el primer paso para optimizar una aplicación Laravel no es tocar índices ni caché, sino algo mucho más básico: ver exactamente qué consultas SQL se están ejecutando y cuándo.

En este post, te traigo todas las formas prácticas de ver consultas SQL en Laravel realizadas por petición, cuando creamos una app en Laravel, muchas peticiones pueden ser realizadas por nosotros o internas por Laravel, al tener una gran libertad al momento de crear nuestras peticiones, es muy probable que nos equivoquemos en algunas partes y hagamos consultas mal optimizadas y el primer paso para corregir estos problemas, es ver la consulta.

Todo esto forma parte de una tarea CRUCIAL en nuestras aplicaciones como lo es, hacer el debug de nuestras apps en Laravel mediante un debugbar

¿Por qué es importante ver las consultas SQL en Laravel?

Problemas comunes: consultas N+1, rendimiento y sobrecarga innecesaria

Uno de los escenarios más habituales es cargar una vista aparentemente simple y descubrir que:

• Se ejecutan decenas de consultas
• Muchas son repetidas
• Otras acceden a relaciones que no necesitas

Cuando esto me ocurre, casi siempre hay detrás un problema N+1, una relación mal cargada o una lógica de acceso a datos poco clara.

Eloquent y Query Builder: qué pasa realmente por la base de datos

Aunque Eloquent nos abstrae del SQL, la base de datos sigue recibiendo consultas crudas. Verlas te permite:

• Entender cómo Laravel traduce tu código
• Detectar consultas lentas
• Validar que los with() funcionan como esperas

Usando Laravel Debugbar para ver consultas SQL por petición (recomendado)

Si tuviera que recomendar una sola herramienta para desarrollo, sería esta.

En mi día a día, cuando noto que una página empieza a ir lenta, activo Debugbar y reviso las queries del request. Es inmediato y muy visual.

Qué información muestra Debugbar sobre las consultas SQL

Laravel Debugbar te permite ver:

• Todas las consultas SQL ejecutadas
• Tiempo de ejecución de cada query
• Bindings
• Número total de consultas por petición

Método 1: Sistema de Registro Incorporado de Laravel

Mediante el método DB::listen puedes escuchar los eventos de consulta a la base de datos y hacer lo que quieras con esto, como registrar las consultas en un log o verlos por pantalla.

Implementación básica con DB::listen en un ServiceProvider

use Illuminate\Support\Facades\DB;

public function boot()
{
    DB::listen(function ($query) {
        \Log::info($query->sql, ['bindings' => $query->bindings, 'time' => $query->time]);
    });
}

O en las rutas:

routes/web.php

DB::listen(function ($query){
    echo $query->sql;
  //  Log::info($query->sql, ['bindings' => $query->bindings, 'time' => $query->time]);
});

Registrar consultas SQL en logs personalizados

Esto te permite:

• Revisar todas las consultas ejecutadas
• Analizar patrones
• Auditar rendimiento

Yo lo uso solo de forma temporal, cuando necesito investigar algo concreto.

Por qué nunca deberías usar DB::listen en producción

Porque:

• Se ejecuta en cada consulta
• Genera sobrecarga
• Puede producir logs gigantes

Método 2: Paquete Laravel Debugbar

Laravel Debugbar es una herramienta por excelencia para hacer debug en la app, nos da muchos información sobre lo que está pasando y entre ellas, la consultas SQL, también nos da el tiempo de ejecución:

composer require barryvdh/laravel-debugbar

Método 3: Utilizando Laravel Telescope

Laravel Telescope es la oficial del equipo de Laravel para realizar depuración y monitoreo, viene siendo el paquete anterior, pero, con vitaminas:

composer require laravel/telescope

Luego, ejecuta el comando de instalación y migración de Telescope:

php artisan telescope:install
php artisan migrate

Método 4: Ver el SQL generado por Eloquent con el método toSql()

El método toSql convierte la consulta de Eloquent en un texto en SQL para que podamos ver como traduce internamente laravel una consulta a SQL y poder analizarla, es ideal para hacer debug:

$sql = DB::table('posts')->where('posted', true)->toSql();

Qué muestra realmente toSql y sus limitaciones

• Muestra solo la query base
• No ejecuta la consulta
• No incluye valores reales (bindings)

Por qué toSql no es suficiente para relaciones Eloquent

Un error común es pensar que toSql() muestra todo. No lo hace cuando hay relaciones with(). Por eso, rara vez lo uso como única herramienta.

Método 5: Utilizando el Método DB::getQueryLog

Otro esquema es empleando el DB::getQueryLog para obtener todas las consultas SQL ejecutadas durante la solicitud actual. Por ejemplo:

DB::enableQueryLog();
// Realiza algunas operaciones de consulta
$queries = DB::getQueryLog();

Esto devolverá un arreglo con todas las consultas SQL ejecutadas.

Cómo habilitar y leer el Query Log

Devuelve un array con:

• Query
• Bindings
• Tiempo de ejecución

Casos en los que este método sí tiene sentido

• Scripts puntuales
• Tests
• Debug muy controlado

Cómo ver el SQL de las relaciones Eloquent y detectar problemas N+1

Aquí es donde suelen aparecer los verdaderos problemas.

Qué ocurre internamente al usar with()

Cuando usas:

Post::with('comments')->get();

Laravel genera:

• Una query principal
• Una o varias queries adicionales por relación

Cómo identificar consultas duplicadas o innecesarias

Con Debugbar o QueryLog puedes ver rápidamente:

• Consultas repetidas
• Accesos innecesarios
• Relaciones mal cargadas

Cuando veo muchas queries similares, sé que algo se puede optimizar.

Inspeccionar consultas SQL de forma interactiva con Tinkerwell

Para depuración puntual, Tinkerwell es muy útil.

Cuándo usar Tinkerwell frente a Debugbar

• Pruebas rápidas
• Análisis de una query concreta
• Sin afectar la aplicación

Depuración puntual sin afectar la aplicación

Puedes ejecutar Eloquent, Query Builder y ver el SQL sin necesidad de cargar una vista completa.

Errores comunes al depurar consultas SQL en Laravel

• Confiar solo en toSql
  • No muestra relaciones ni valores reales.
• Dejar herramientas de debug activas en producción
  • Un error grave que impacta rendimiento y seguridad.
• Interpretar mal los bindings y tiempos de ejecución
  • El SQL puede parecer rápido, pero el número de queries también importa.

Qué método usar según el escenario (guía rápida)

• Debug rápido en desarrollo
  • Laravel Debugbar
• Análisis de rendimiento
  • Laravel Pulse / Telescope
• Logging y auditoría de consultas
  • DB::listen() (solo en local)

Preguntas frecuentes sobre ver consultas SQL en Laravel

• ¿Cómo ver el SQL que genera Eloquent?
  • Con Debugbar, QueryLog o toSql() (según el caso).
• ¿Cuál es la mejor forma de ver consultas SQL en Laravel?
  • Para desarrollo, Debugbar. Para rendimiento, Pulse.
• ¿Es seguro usar Debugbar en producción?
  • No, nunca.
• ¿Cómo detectar consultas N+1 en Laravel?
  • Revisando el número de queries por request con Debugbar o Telescope.

Conclusión

Ver las consultas SQL en Laravel no es opcional si te importa el rendimiento. En mi experiencia, dedicar unos minutos a inspeccionar las queries suele ahorrar horas de optimización innecesaria.

Usa la herramienta adecuada según el contexto, entiende qué está pasando bajo el capó y deja que Laravel haga su trabajo… pero con los ojos bien abiertos.

Estas son solamente algunas formas que puedes implementar en tu código para ver el SQL de las consultas realizadas.

Ahora, aprende a utilizar las Colas o Queues y los Trabajos o Jobs para posponer Tareas en Laravel.