Achieving True Asynchronous Database Queries in Perl with Mojolicious

Background

The author previously used the Dancer framework, which makes it difficult to perform fully asynchronous database operations, and switched to Mojolicious, discovering that true async queries can be implemented with far less effort.

What Ideal Asynchronous Database Access Looks Like

Imagine a web page that needs five SQL queries, each taking one second. With a single‑process worker, one user should see the page in one second, and ten concurrent users should also receive the page within the same second under ideal async conditions.

Two Approaches to Asynchronous Database Queries

Multi‑process simulation : When multiple blocking queries are needed, the program forks new processes, waits for each query, and then returns the results. This method is clean and does not slow down the server, but it consumes a lot of resources because each request may spawn many processes.

Socket‑level true async : Uses the asynchronous capabilities built into the database driver itself (e.g., the async features of DBD::mysql). This provides real non‑blocking I/O at the socket level; the only blocking part is the final data‑fetch phase, which is usually negligible compared to query execution time.

Perl Asynchronous Database Modules

The author lists several modules, illustrated with screenshots (kept as images because the source code is shown in the pictures). The modules fall into the two categories described above:

AnyEvent::DBI::MySQL – first‑type (process‑based) implementation, but the author prefers the second‑type approach.

Other AnyEvent‑based modules – also first‑type.

Modules that support true async (second type), including a high‑quality module that integrates well with Mojolicious, a Japanese experimental module, and the native MySQL driver itself.

Setting Up a Non‑Blocking Mojolicious Application

Generate a full Mojolicious project with the command: mojo generate app MyApp The generated project contains lib/MyApp.pm with a startup subroutine. This is the only place that needs modification to add the asynchronous database connection pool.

Example startup function (illustrated in the original image):

sub startup {
    my $self = shift;
    # Load AnyEvent::DBI::MySQL and create a connection pool
    $self->helper(db => sub {
        state $dbh = AnyEvent::DBI::MySQL->new(
            dsn => 'DBI:mysql:database=yourdb;host=localhost',
            user => 'user',
            password => 'pass',
        );
        return $dbh;
    });
    # Define routes as usual
    $self->routes->get('/')->to('example#welcome');
}

In lib/Example.pm (or another controller), perform a non‑blocking query:

sub welcome {
    my $c = shift;
    $c->db->query('SELECT NOW(), SLEEP(5)')->cb(sub {
        my $result = shift->fetchrow_arrayref;
        $c->render(text => "Result: @$result");
    });
}

Start the application with morbo script/my_app or hypnotoad script/my_app. When testing with a tool like ab or by opening several browsers simultaneously, all requests complete after roughly five seconds instead of the 25 seconds that would be required if the queries were executed sequentially.

Conclusion

Using Mojolicious together with a true asynchronous MySQL driver (such as AnyEvent::DBI::MySQL) enables Perl web applications to handle many concurrent database queries efficiently, turning a potentially linear 5‑second per‑query workload into a truly parallel response time.