PlanetScale Insights: Analyze Slow Queries (2026)

PlanetScale Insights identifies slow database queries by analyzing query execution times and resource consumption.

Let’s see it in action. Imagine a typical web application interacting with a PlanetScale database. A user requests a list of their recent orders. The application code constructs a SQL query:

SELECT
    o.order_id,
    o.order_date,
    p.product_name,
    oi.quantity,
    oi.price
FROM
    orders o
JOIN
    order_items oi ON o.order_id = oi.order_id
JOIN
    products p ON oi.product_id = p.product_id
WHERE
    o.customer_id = 12345
ORDER BY
    o.order_date DESC
LIMIT 50;

Normally, this query might execute in milliseconds. However, if the customer_id 12345 has thousands of orders, or if the products table is massive and the join conditions aren’t optimized by indexes, this query can start to crawl. PlanetScale Insights is designed to catch these slow-downs.

When a query takes longer than a predefined threshold (e.g., 5 seconds, configurable in PlanetScale settings), Insights flags it. It doesn’t just tell you that it’s slow; it provides a wealth of data to help you pinpoint why. This includes:

Execution Plan: The actual plan the database used to execute the query. This is the most crucial piece of information, showing which indexes were used (or not used), the order of table scans, and join strategies.
Query Text: The exact SQL statement that was executed.
Execution Time: The total time the query took, broken down into phases (e.g., parsing, planning, execution).
Rows Examined vs. Rows Returned: A key indicator of inefficiency. If the database examines millions of rows but only returns a few, it’s often a sign of a missing or ineffective index.
Resource Consumption: CPU, memory, and I/O usage attributed to the query.
Frequency: How often this specific slow query is being executed. A frequently executed slow query can have a disproportionately large impact on overall database performance.

The core problem Insights helps solve is performance degradation caused by inefficient SQL queries. As data volumes grow and application logic becomes more complex, queries that were once performant can become bottlenecks. Without a tool like Insights, diagnosing these issues can be like finding a needle in a haystack, requiring manual log analysis, slow query log parsing, and educated guesswork.

Insights works by instrumenting the database’s query execution. Every query that runs is monitored. When a query exceeds the configured latency threshold, its metadata, execution plan, and resource usage are captured and stored. This data is then presented in a user-friendly interface within the PlanetScale dashboard.

The main levers you control are:

The Latency Threshold: You can set how "slow" a query needs to be before it’s flagged. A lower threshold catches issues earlier but might generate more noise. A higher threshold focuses on truly problematic queries but might miss gradual degradations.
Indexing Strategy: Insights doesn’t directly create indexes, but the information it provides is vital for deciding where to add them. By looking at the execution plan and "rows examined" vs. "rows returned," you can identify columns used in WHERE clauses, JOIN conditions, and ORDER BY clauses that would benefit from an index.
Query Rewriting: Sometimes, the problem isn’t just an index. The query itself might be structured inefficiently. Insights helps identify these by showing what the database is actually doing to fulfill the request. You might discover a subquery that could be a JOIN, or a SELECT * that could be more specific.

A common misconception is that slow query analysis is only about adding indexes. While indexes are frequently the solution, the execution plan can reveal other issues. For instance, a query might be performing a full table scan on a large table because a WHERE clause condition is applied to a column that is part of a composite index but not the leading column, or because the condition uses a function on the indexed column (e.g., WHERE YEAR(order_date) = 2023 instead of WHERE order_date >= '2023-01-01' AND order_date < '2024-01-01'). Insights will show this scan and the resulting high row examination count, guiding you to rewrite the condition or adjust the index.

Once you’ve addressed the slow queries highlighted by Insights, the next challenge is monitoring for new performance regressions.