Performance measurement

[chbister]

During my mass invoice import (approx. 40000 invoices) I experienced that the save() method takes longer and longer the more invoices are stored (90 seconds and even more).

Now I am curous: is it my setup or is it something else that I am not aware of?

Any feedback is appreciated.

These are my benchmark results:

This is my command to do the benchmark:

<?php

namespace App\Console\Commands;

//use App\Models\Invoice;
use Elegantly\Invoices\Models\Invoice;
use Elegantly\Invoices\Database\Factories\InvoiceFactory;
use Illuminate\Console\Command;
use Illuminate\Support\Str;
use Symfony\Component\Stopwatch\Stopwatch;

class DummyCommand extends Command
{
    /**
     * The name and signature of the console command.
     *
     * @var string
     */
    protected $signature = 'myb:benchmark-invoice-save
                            {--runs=5 : Number of runs}
                            {--perRun=10 : Invoices to create per run}';

    /**
     * The console command description.
     *
     * @var string
     */
    protected $description = 'Benchmark Invoice::save() performance using the package InvoiceFactory';

    /**
     * Execute the console command.
     */
    public function handle()
    {
        $runs = (int) $this->option('runs');
        $perRun = (int) $this->option('perRun');

        $this->warn('WARNING: Do not run this in production!');
        $this->info("Runs: {$runs}, invoices per run: {$perRun}");
        $this->newLine();

        $stopwatch = new Stopwatch();

        for ($run = 1; $run <= $runs; $run++) {
            $this->line("=== Run {$run} ===");

            // 1) Create new invoices with Factory
            $this->line("Creating {$perRun} invoices via factory...");
            $eventName = "invoice_create_run_{$run}";
            $stopwatch->start($eventName);
            //Invoice::factory()->count($perRun)->create();
            $if = InvoiceFactory::new();
            $if->count($perRun)->create();
            $event = $stopwatch->stop($eventName);
            $durationMs = $event->getDuration(); // Millisekunden
            $memoryBytes = $event->getMemory();

            $this->info(sprintf(
                'Run %d: save() duration = %d ms, memory = %d bytes',
                $run,
                $durationMs,
                $memoryBytes
            ));

            $this->newLine();

            $totalCount = Invoice::count();
            $this->line("Total invoice count in DB after creation: {$totalCount}");

            // 2) Get any invoice
            /** @var \App\Models\Invoice $invoice */
            $invoice = Invoice::inRandomOrder()->first();

            if (! $invoice) {
                $this->error('No invoice found, aborting.');
                return Command::FAILURE;
            }

            // 3) Change field – anything that is sure to become dirty
            $invoice->description = 'REF-' . Str::uuid()->toString();

            // 4) Measurement for save()
            $eventName = "invoice_save_run_{$run}";
            $stopwatch->start($eventName);
            $invoice->save();
            $event = $stopwatch->stop($eventName);

            $durationMs = $event->getDuration();
            $memoryBytes = $event->getMemory();

            $this->info(sprintf(
                'Run %d: save() duration = %d ms, memory = %d bytes (invoices in DB: %d)',
                $run,
                $durationMs,
                $memoryBytes,
                $totalCount
            ));

            $this->newLine();
        }

        $this->info('Performance test finished.');

        return Command::SUCCESS;
    }
}

[QuentinGab]

Hi @chbister,

The delay you’re seeing when saving a new invoice is likely due to how the next sequential serial number is generated.

To determine the next serial number, the system runs this query:

public function getPreviousInvoice(): ?static
{
    /** @var ?static $invoice */
    $invoice = static::query()
        ->withoutGlobalScopes()
        ->where('serial_number_prefix', $this->serial_number_prefix)
        ->where('serial_number_serie', $this->serial_number_serie)
        ->where('serial_number_year', $this->serial_number_year)
        ->where('serial_number_month', $this->serial_number_month)
        ->latest('serial_number_count')
        ->first();

    return $invoice;
}

If you have only one series, adding an index on these columns can significantly improve performance:

$table->index([
    'serial_number_prefix',
    'serial_number_serie',
    'serial_number_year',
    'serial_number_month',
]);

This should make generating the next invoice number much faster.

Let me know if it helps

[chbister]

Hi @QuentinGab

I did try this. Still my results look same:

Then I tried this:

Schema::table('invoices', function (Blueprint $table) {
            $table->dropIndex([
                'serial_number_format',
                'serial_number_prefix',
                'serial_number_serie',
                'serial_number_year',
                'serial_number_month',
                'serial_number_count'
            ]);
        });

Still same long runtime.

[chbister]

Hello @QuentinGab

I also did a test with Tinker with the above query for my case and without applying any additional indexes:
Invoice::query()->withoutGlobalScopes()->where('serial_number_prefix', null)->where('serial_number_serie', null )->where('serial_number_year', 2025)->where('serial_number_month', null)->latest('serial_number_count')->first();

No delay here...

Regards
Chrisitan