N+1 Query Problem

N+1 detection and fix with eager loading in Rails

# N+1 PROBLEM: 1 query for orders, then 1 query per order for customer
# Total: 1 + N queries
def orders_with_customers_bad
  orders = Order.where(status: 'confirmed').limit(50)
  orders.map do |order|
    { id: order.id, customer_name: order.customer.name } # N queries here
  end
end

# FIXED: eager load associations upfront
# Total: 2 queries (1 for orders, 1 for all customers)
def orders_with_customers_good
  orders = Order.includes(:customer).where(status: 'confirmed').limit(50)
  orders.map do |order|
    { id: order.id, customer_name: order.customer.name } # No query; loaded in memory
  end
end

# DEEPER: eager load nested associations
def orders_with_full_details
  Order
    .includes(customer: :address, line_items: :product)
    .where(status: 'confirmed')
    .limit(50)
    .map do |order|
      {
        id: order.id,
        customer: order.customer.name,
        city: order.customer.address.city,
        items: order.line_items.count
      }
    end
end

includes in ActiveRecord uses either a separate IN query (for simple associations) or a LEFT OUTER JOIN (when includes is combined with references or joins). For large association sets, joins + select is more efficient than includes which loads full models into Ruby objects.

DataLoader for N+1 prevention in GraphQL with TypeScript

import DataLoader from 'dataloader';
import { db } from '../database';

// Batch function: receives array of keys, returns array of values in the same order
async function batchLoadUsers(userIds: readonly string[]) {
  const users = await db.users.findMany({
    where: { id: { in: [...userIds] } },
  });
  const userMap = new Map(users.map(u => [u.id, u]));
  return userIds.map(id => userMap.get(id) ?? new Error('User not found: ' + id));
}

const userLoader = new DataLoader(batchLoadUsers, {
  maxBatchSize: 100,
  cache: true, // Within a single request, same ID returns cached result
});

// GraphQL resolver: no N+1 - DataLoader batches all load() calls within one tick
const resolvers = {
  Order: {
    customer: async (order: { customerId: string }) => {
      return userLoader.load(order.customerId);
    },
  },
  Query: {
    orders: async () => db.orders.findMany({ where: { status: 'confirmed' } }),
  },
};

// Requesting 50 orders with customer names:
// Without DataLoader: 51 queries
// With DataLoader: 2 queries (1 for orders, 1 batched for all customers)

DataLoader collects all load() calls within a single event loop tick and fires the batch function once. The cache ensures the same userId in one request is only fetched once. Create a fresh DataLoader per request, not as a singleton, to prevent cross-request data leakage.