DEV Community: Andres Daza

Evita el problema N+1 en validaciones de Laravel

Andres Daza — Thu, 06 Nov 2025 14:56:39 +0000

El problema oculto detrás de las validaciones masivas

Cuando validamos arrays de datos en Laravel usando reglas como unique, el framework realiza una consulta por cada elemento del array.

Por ejemplo, si validas una lista de correos electrónicos con la regla unique:users,email, Laravel ejecutará una consulta por cada email.

Esto genera lo que conocemos como el problema N+1, un clásico enemigo del rendimiento en bases de datos.

¿Qué es el problema N+1 en validaciones?

El problema ocurre así:

Tienes un array con N elementos.
Laravel ejecuta N consultas SQL para validar cada uno.
A medida que el tamaño del array crece, también lo hace el número de consultas.

Esto puede pasar desapercibido en pequeños formularios, pero en procesos masivos (importaciones, APIs, migraciones de datos) se convierte en un cuello de botella enorme.

Solución

Validaciones por lotes con laravel-batch-validation

dazza-dev/laravel-batch-validation soluciona este problema optimizando el flujo de validación de Laravel.

En lugar de validar cada elemento de forma individual, tu paquete agrupa las validaciones y ejecuta una sola consulta WHERE IN por lote.

De esta forma:

Reduces cientos de consultas a solo una o unas pocas.
Mantienes la sintaxis y el sistema de validación nativo de Laravel.
Mejoras radicalmente el rendimiento sin complicaciones adicionales.

Instalación

composer require dazza-dev/laravel-batch-validation

Laravel detectará automáticamente el paquete gracias al auto-discovery, así que no es necesario registrar nada manualmente.

Validando arrays sin N+1

Imagina que recibes un array con varios contactos a validar:

use Illuminate\Support\Facades\Validator;

$data = [
    ['name' => 'User 1', 'email' => 'user1@example.com'],
    ['name' => 'User 2', 'email' => 'user2@example.com'],
    ['name' => 'User 3', 'email' => 'user3@example.com'],
];

// Crear una instancia del validador
$validator = Validator::make($data, [
    '*.name' => 'required',
    '*.email' => 'email:strict|unique:contacts,email',
]);

// Validar por lotes (evita el problema N+1)
$validator->validateInBatches();

// Si hay errores de validación
if ($validator->fails()) {
    throw new \Exception(json_encode($validator->errors()->messages()));
}

Con este enfoque, en lugar de ejecutar una consulta por cada email, el paquete agrupa todos los valores y ejecuta una sola consulta con WHERE IN.

Controla el tamaño del lote

En algunos escenarios puede ser útil definir el tamaño del lote para balancear carga y consumo de memoria.

Esto lo haces fácilmente pasando el parámetro batchSize al método validateInBatches:

$validator->validateInBatches(batchSize: 20);

Esto significa que el validador procesará los datos en grupos de 20 registros a la vez. Ideal para validaciones sobre conjuntos muy grandes de datos.

Integración con FormRequests

El paquete también funciona perfectamente con las clases FormRequest de Laravel, manteniendo una integración limpia y natural.

Por ejemplo:

use Illuminate\Foundation\Http\FormRequest;
use Illuminate\Support\Facades\Validator;

class StoreContactRequest extends FormRequest
{
    public function rules(): array
    {
        return [
            '*.name' => 'required',
            '*.email' => 'email:strict|unique:contacts,email',
        ];
    }

    public function withValidator(Validator $validator)
    {
        if (method_exists($validator, 'validateInBatches')) {
            $validator->validateInBatches(batchSize: 100);
        }
    }
}

De esta manera, tus validaciones en FormRequest también se ejecutan en lotes, sin alterar las reglas ni la lógica de tu aplicación.

Resultado

Antes

Despues

Conclusión

dazza-dev/laravel-batch-validation una optimización elegante y transparente para proyectos Laravel que necesitan validar grandes cantidades de datos.

Menos consultas. Más velocidad. Misma sintaxis Laravel.

Una herramienta imprescindible si trabajas con importaciones, APIs masivas o validaciones en bucles grandes.

Avoid the N+1 Problem in Laravel Validations

Andres Daza — Thu, 06 Nov 2025 14:39:06 +0000

The Hidden Problem Behind Massive Validations

When we validate arrays of data in Laravel using rules like unique, the framework executes one query per element in the array.

For example, if you validate a list of emails using the rule unique:users,email, Laravel will run a query for each email.

This results in what’s known as the N+1 problem, a classic performance bottleneck in database operations.

What Is the N+1 Problem in Validations?

Here’s what happens:

You have an array with N elements.
Laravel executes N SQL queries to validate each one.
As the array grows, the number of queries grows too.

This might not be noticeable for small datasets, but in massive operations (imports, APIs, data migrations), it quickly becomes a serious performance issue.

The Solution

Batch Validations with laravel-batch-validation

dazza-dev/laravel-batch-validation solves this problem by optimizing how Laravel handles database-dependent validation rules.

Instead of validating each element individually, this package groups validations and performs a single WHERE IN query per batch.

This means:

Hundreds of queries become just one or a few.
You keep Laravel’s native validation syntax.
You gain massive performance improvements with zero code complexity.

Installation

composer require dazza-dev/laravel-batch-validation

Laravel will automatically detect the package thanks to auto-discovery,
so you don’t need to register anything manually.

Practical Example: Validating Arrays Without N+1

Imagine you receive an array of contacts to validate:

use Illuminate\Support\Facades\Validator;

$data = [
    ['name' => 'User 1', 'email' => 'user1@example.com'],
    ['name' => 'User 2', 'email' => 'user2@example.com'],
    ['name' => 'User 3', 'email' => 'user3@example.com'],
];

// Create the Validator instance
$validator = Validator::make($data, [
    '*.name' => 'required',
    '*.email' => 'email:strict|unique:contacts,email',
]);

// Validate in batches (this prevents the N+1 problem)
$validator->validateInBatches();

// Validation fails
if ($validator->fails()) {
    throw new \Exception(json_encode($validator->errors()->messages()));
}

With this approach, instead of executing one query per email,
the package groups all values and runs a single WHERE IN query.

Control the Batch Size

In some cases, you may want to adjust the batch size to balance performance and memory usage.

You can do this by passing the batchSize parameter to validateInBatches:

$validator->validateInBatches(batchSize: 20);

This means the validator will process the data in groups of 20 records at a time perfect for handling very large datasets efficiently.

Integration with FormRequests

The package also integrates seamlessly with Laravel’s FormRequest classes, keeping your validation flow clean and native.

For example:

use Illuminate\Foundation\Http\FormRequest;
use Illuminate\Support\Facades\Validator;

class StoreContactRequest extends FormRequest
{
    public function rules(): array
    {
        return [
            '*.name' => 'required',
            '*.email' => 'email:strict|unique:contacts,email',
        ];
    }

    public function withValidator(Validator $validator)
    {
        if (method_exists($validator, 'validateInBatches')) {
            $validator->validateInBatches(batchSize: 100);
        }
    }
}

This ensures that even your FormRequest validations are executed in batches, without changing any of your existing rules.

Result

Before

After

Conclusion

dazza-dev/laravel-batch-validation is a smart and transparent optimization for Laravel projects that need to validate large datasets.

Fewer queries. Faster validations. Same Laravel syntax.

A must-have tool for imports, massive APIs, and large-scale data validations.