BotGauge
Freemium
Startups and fast-moving engineering teams
Sqlsure
FreeOpen SourceAPISelf-Hosted
A query runs clean, returns a number, and that number is wrong — revenue double-counted by a bad join, an average where a sum was needed, a patient identifier silently exposed. sqlsure is the static check that catches those errors before the query executes.
Similar tools
BotGaugeFreemiumThe core loop is: probe the agent with adversarial and real-world scenarios, trace every…
AxonQAFreemiumThe core loop: bring in a Jira ticket or let the AI explore your app, review the tests it…
Before Users DoPaidThe tool connects to MCP-compatible clients like Cursor or Claude Desktop, so the QA loop runs…
Bypass LabsPaidThe workflow is boundary-in, proof-out: you approve targets, exclusions, and stop conditions…
Get This Tool
License: Apache-2.0 Any use incl. commercial
Local-run terms: Install via pip and run locally with provided model files; full source available under Apache-2.0
Pricing
- Model
- Free
Summary
sqlsure inspects SQL for semantic violations — fan-out double-counting, additivity errors, wrong join keys, policy breaches — none of which a database engine will flag because the SQL is syntactically valid. It installs via pip, exposes an API, and is licensed Apache-2.0, so it drops into a CI pipeline or a text-to-SQL agent without negotiating with a vendor. The maintainers report finding real bugs in the BIRD and Spider benchmarks, which means the checks are specific enough to catch what polished evaluation suites missed. The tool performs one-shot deterministic checks — it is not an agent and does not plan or self-correct, so the intelligence is in your schema modeling, not the tool's reasoning.
Bottom line: Pull this into your dbt CI gate or text-to-SQL agent to stop silent numeric errors before they reach a dashboard — but if your SQL generation failures are ambiguity problems rather than join-key or additivity problems, sqlsure's deterministic checks will miss them and you will need an LLM-as-judge eval layer instead.
Find your fit
Before you choose Sqlsure
More options in Test Generation. Compare pricing, platforms, and features side by side.
AxonQA
Freemium
QA engineers and teams shipping software
Pros
- Catches fan-out double-counting and additivity violations before execution, so a bad join in a generated query fails the CI gate rather than silently inflating a revenue metric on a dashboard.
- Deterministic, schema-aware checks rather than probabilistic scoring, which means a violation either fires or it doesn't — no threshold to tune and no false-negative rate to accept on individual rule classes.
- Apache-2.0 license with pip install and self-hosted deployment, so it drops into a private data environment without data leaving the network — a hard requirement for teams under financial or healthcare data policy.
- Exposes an API and includes integration scaffolding, so it connects as a pre-execution step inside a text-to-SQL agent without requiring the agent to be rebuilt around the tool.
- Validated against BIRD and Spider benchmark queries, meaning the rules are specific enough to surface errors that established evaluation suites did not flag — giving teams a calibration point beyond synthetic test data.
Cons
- The rule library covers the violations the maintainers have encoded — fan-out, additivity, join keys, policy. Any semantic error outside those categories passes through without a flag. Teams whose biggest failure mode is hallucinated table names or ambiguous aggregation logic will hit this ceiling immediately and add an LLM-as-judge layer, at which point they are running two eval systems in parallel.
- The schema model the tool reasons against must be constructed and kept in sync with the actual database schema. For teams with schemas that change frequently — new dbt models, column renames, type changes — maintaining that model file becomes an ongoing engineering task that scales with schema complexity, not query volume. At sufficient schema churn, teams switch to approaches that infer schema context dynamically rather than from a maintained artifact.
- The project has a small commit history and no listed community integrations beyond the repository's own scaffolding, which means operational questions — edge case behavior, schema model format ambiguities, rule extension — land on the maintainer or on reading source code. Teams that need guaranteed response SLAs on blocking issues move to tools with active commercial support.
About
- Platforms
- Python
- API Available
- Yes
- Self-Hosted
- Yes
- Last Updated
- July 13, 2026
Best For
Who it's for
- Teams using dbt for data modeling
- AI agents generating SQL queries
- Benchmark validation of text-to-SQL systems
- Preventing silent data errors in analytics pipelines
What it does well
- CI gate blocking merges with semantically invalid SQL
- Pre-execution validation inside text-to-SQL agents
- Auditing dbt repositories for semantic issues
- Embedding as a semantic eval metric for NL2SQL output
Integrations
Frequently Asked Questions
- Is Sqlsure free?
- Sqlsure offers a free option. Hosting, model usage, or optional services may have separate costs; check the pricing details and official terms.
- Is Sqlsure open source?
- Yes. Sqlsure is open source.
- Does Sqlsure have an API?
- Yes. Sqlsure exposes a developer API. See the official documentation at https://github.com/sqlsure/sqlsure for details.
- Can I self-host Sqlsure?
- Yes. Sqlsure supports self-hosting on your own infrastructure.
- What platforms does Sqlsure support?
- Sqlsure is available on: Python.
Text-to-SQL pipelines fail in a specific, painful way: the generated query is valid SQL, the database executes it without complaint, and the returned number is wrong. sqlsure addresses this by running semantic inspection on a query before execution — checking for fan-out double-counting from incorrect joins, additivity violations where a non-additive measure is being summed, wrong join keys that silently multiply or filter rows, and policy breaches where restricted identifiers appear in output. The workflow is a one-shot check: pass in a query and a schema model, get back a pass or a structured list of violations. No query runs until the check clears.
The differentiating claim — and the one worth stress-testing — is that the vendor found real bugs in the BIRD and Spider text-to-SQL benchmarks using these checks. Those benchmarks are the standard by which text-to-SQL systems are evaluated, so catching issues there suggests the semantic rules are not superficial pattern matching. For teams running NL2SQL agents against production schemas, this positions sqlsure as an eval metric for output quality rather than just a linting pass.
The tool fits tightest in three scenarios: blocking merges in CI when a dbt model change introduces a semantically invalid query, running as a pre-execution guard inside a text-to-SQL agent, and auditing existing dbt repositories for latent semantic issues. Where it breaks: the checks are deterministic and schema-aware, which means violations the tool is not programmed to detect pass through silently. Teams dealing with hallucinated table references, ambiguous business logic, or novel query patterns not covered by the rule set will find the checks necessary but not sufficient — and will add an LLM-based evaluation layer alongside it. The project is early-stage by commit count, so the rule library is not yet broad.
Installation is via pip. The repository includes an API, an integrations directory, and a skills layer suggesting structured extension points for agents. A model.example.json file describes the schema model format the tool expects, which is the artifact teams will spend real time constructing and maintaining for production use. Self-hosting is the only deployment mode — the vendor states no paid or hosted offering.
Contribute
- Work on Sqlsure? Claim this listing.
- Embed a badge for your README or site.
Sign in to rate this tool or suggest an edit.