NovaSQL Query Analyser
A slow query is rarely a mystery — you just have to see where the time goes.
NovaSQL Query Analyser takes your statement, fetches the execution plan and
answers the questions you would otherwise scroll through ShowPlan XML for: which
operator costs the most, where the optimizer's estimate was wrong, and which
index is genuinely missing — and whether it is worth creating next to the indexes
already on the table.
**The plan, readable**
The plan diagram shows every operator with its share of the cost, its own elapsed
time and the number of rows that actually went through it. Arrow weight follows
row counts, and operators whose estimate was far off are marked. Prefer reading to
looking? Switch to the tree view.
**Estimated or measured — the difference is the point**
Work from the estimated plan, from the plan in the cache, or run the query once
for the actual plan: real row counts, elapsed times, reads per table and the
memory SQL Server reserved against what it actually used. Only reading statements
are executed — the statement is parsed first and anything else is refused,
including SELECT … INTO.
**Advice you can act on**
The plan becomes optimization hints with benefit and urgency: scans reading far
more than the query returns, sorts spilling to tempdb, implicit conversions that
make an index useless, parameters that do not match the plan. Missing indexes come
as a ready CREATE INDEX — and can be compared against the table's existing
indexes: create it, extend one that is already there, or skip it.
**The causes behind them**
Check statistics (stale, thin, never updated), look at the histogram for your
actual predicate, compare parameter sniffing between the cached plan and a fresh
compilation, read wait statistics and per-table reads for the executed statement.
**Structure instead of guesswork**
The structure tree shows which columns the query returns and where each one comes
from — through CTEs, derived tables and subqueries. It needs no connection, so it
works on a query pulled from a log file.
**Built for everyday use**
SQL editor with syntax highlighting, search and a formatter. History of every
analysis with its score, and a side-by-side comparison of two runs (before/after,
including what changed in the plan). Open, save or paste .sqlplan files with no
connection at all. Save an analysis report as HTML. Pull the costliest statements
straight from the server's plan cache and analyse them.
**Your data stays with you**
Connections go straight from your machine to the server. There is no account and
no cloud service. Connection profiles are stored locally and encrypted with
Windows DPAPI for your user account, so a copied file does not decrypt elsewhere.
Sign in with Windows authentication, a SQL Server login or Microsoft Entra ID
(interactive with MFA, integrated or default).
Interface in English and German, switchable while the app is running.
## Product features
- Execution plan as a diagram: cost share, own elapsed time and rows per operator
- Actual plan with measured rows — and a mark where the estimate was wrong
- Executes reading statements only; anything else is refused before it runs
- Optimization hints with benefit and urgency instead of raw plan XML
- Missing indexes as a ready CREATE INDEX, compared against existing ones
- Check statistics and the histogram for your actual predicate
- Parameter sniffing: cached plan against a fresh compilation
- Reads per table, wait statistics and memory grant of the execution
- Column provenance through CTEs, derived tables and subqueries
- Compare two analyses: duration, CPU, reads, plan cost, plan change
- Open, save and paste .sqlplan files — works with no connection
- Pull the costliest statements from the plan cache and analyse them
- SQL editor with syntax highlighting, search and a formatter
- Save the analysis as an HTML report
- Windows, SQL Server and Microsoft Entra ID sign-in (including MFA)
- Profiles stored locally, encrypted with DPAPI — no account, no cloud