The Bolton Scale

Instant feedback on your SQL query quality

Understand Your Queries

Every query you write in SQLizm gets a Bolton Score—a simple 1-10 rating that explains how well your SQL performs and why. No more fumbling in the darkness wondering if that JOIN is slowing things down or if you've accidentally created a Cartesian product. You'll understand exactly what's happening.

The Bolton Scale

From 10 Boltons (perfect) to 1 Bolton (problematic)—here's what each score means

10

Well-Optimized Query

Your query uses indexes effectively and follows best practices. You understand exactly why it performs well. No more fumbling in the darkness.

  • Proper index usage
  • Efficient JOINs
  • No redundant operations
  • Optimal WHERE clauses
7-9

Pretty Good

Minor optimizations possible, but your query is solid. Small tweaks could make it even better.

  • Mostly indexed queries
  • Could benefit from covering indexes
  • Some minor inefficiencies
4-6

Needs Attention

Your query works, but there are performance concerns. Review our suggestions to improve it.

  • Missing indexes on JOIN columns
  • SELECT * where specific columns would be better
  • Suboptimal JOIN order
2-3

Performance Issues

This query has serious performance problems. It might work on small datasets but will struggle at scale.

  • Table scans on large tables
  • Nested subqueries without optimization
  • Missing critical indexes
1

Major Problems

Stop! This query has critical issues like cross joins without conditions or massive Cartesian products. Refactor needed.

  • Unintended cross joins
  • No WHERE clause on large tables
  • Multiple table scans
  • Cartesian product detected

How The Bolton Scale Works

1

Real-Time Analysis

As you write your query, SQLizm analyzes the structure, table relationships, and execution plan in real-time.

2

Heuristic Evaluation

Our intelligent heuristics check for common performance pitfalls: missing indexes, inefficient JOINs, SELECT *, table scans, and more.

3

Instant Feedback

Get your Bolton Score immediately with specific suggestions for improvement. Click on any issue to learn why it matters and how to fix it.

4

Understand & Improve

Each suggestion explains not just what to fix, but why it matters. No more wondering why a query is behaving badly—you'll understand the root cause.

What We Check For

Common query issues that affect your Bolton Score

⚠️

Missing Indexes

JOINs or WHERE clauses on columns without indexes cause slow table scans.

SELECT *

Selecting all columns when you only need a few wastes bandwidth and memory.

🔄

Cross Joins

Joins without conditions create Cartesian products—exponentially more rows than intended.

📊

Table Scans

Querying large tables without WHERE clauses or indexes forces full table scans.

🔍

Subquery Inefficiency

Nested subqueries that could be rewritten as JOINs often perform poorly.

🎯

Non-Sargable Queries

Functions on indexed columns (e.g., WHERE UPPER(name) = 'JOHN') prevent index usage.

Real Examples

Score: 1 Bolton

Before Optimization

SELECT *
FROM users, orders
WHERE users.created_at > '2023-01-01'
Issues:
  • Unintended cross join (no JOIN condition)
  • SELECT * fetches unnecessary columns
  • No index on created_at
Score: 10 Boltons

After Optimization

SELECT u.id, u.name, o.order_id, o.total
FROM users u
INNER JOIN orders o ON u.id = o.user_id
WHERE u.created_at > '2023-01-01'
  AND u.created_at < '2024-01-01'
Improvements:
  • Explicit JOIN with proper condition
  • Only selected needed columns
  • Added upper bound for better index usage

Ready to Score 10 Boltons?

Start writing better SQL with instant feedback

Launch SQLizm