TechPrufer
Get started
PlanetScale
PlanetScale logoPlanetScale · Feature trail

N+1 Query Detection and Resolution

5 posts · Aug 2022 – Jan 2023

What this trail covers

PlanetScale offers robust solutions for detecting and mitigating N+1 queries in Rails applications. This includes leveraging gems like Bullet for proactive discovery and utilizing Rails 6.1+'s `strict_loading` feature, which can be applied globally or selectively in development environments to raise errors on lazy loading. Additionally, the platform supports asynchronous association destruction (`dependent: :destroy_async`) to handle callbacks for dependent records without blocking the main thre

All PlanetScale trails
  1. What is the N+1 Query Problem and How to Solve it?This post defines the N+1 query problem, illustrates it with PHP code examples, and demonstrates how to solve it using JOIN clauses. It also highlights PlanetScale Insights as a tool for identifying N+1 queries by analyzing query execution counts, rows read, and performance metrics.
  2. Solving N+1’s with Rails `exists?` queriesThis post addresses a performance issue in a Rails application caused by multiple N+1 `.exists?` queries on a single API endpoint. It explains why `includes` does not work with `exists?` queries and presents a solution by preloading records and checking them in memory. It also introduces an alternative approach using a new association to preload only necessary records.
  3. Rails’ safety mechanismsThis post details Rails' built-in safety mechanisms for developers, focusing on mass assignment protection via strong parameters and N+1 query prevention using `includes` and `strict_loading`. It also introduces asynchronous association destruction (`dependent: :destroy_async`) as a way to handle callbacks for dependent records in background jobs. The post provides code examples and explanations for each mechanism, highlighting their importance for application security and performance.
  4. Laravel’s safety mechanismsThis post details how Laravel's Eloquent ORM provides built-in safety mechanisms to prevent common development mistakes. It specifically covers N+1 prevention by disabling lazy loading and recommending eager loading, partially hydrated model protection by preventing access to missing attributes, attribute typo and renamed column detection, mass assignment protection, model strictness, polymorphic mapping enforcement, and long-running event monitoring. The primary recommendation is to enable `Model::preventLazyLoading()` and `Model::preventAccessingMissingAttributes()` in production environments to catch these issues explicitly rather than silently failing.
  5. Ruby on Rails: 3 tips for deleting data at scaleThis post provides three tips for safely deleting data at scale in Rails applications: 1. Use `dependent: :destroy_async` to move deletions to background jobs, preventing request timeouts and database strain, and recommending replacing foreign key `ON DELETE CASCADE` with this approach. It also warns about potential validation failures with `destroy_async`. 2. Differentiates between `delete` (skips callbacks) and `destroy` (triggers callbacks), advising `delete_all` for bulk cleanup to skip callbacks. 3. Recommends batching mass deletions of old data using a Sidekiq job with a `limit` and self-requeuing mechanism to avoid locking tables and impacting application performance. It also provides testing examples for these jobs.