How does Atlas handle large `pgTAP` test output in SQL?

Atlas's `bash` tool truncates terminal output at 2000 lines or 50 KB but writes the complete `pgTAP` log to a retained file, providing SQL developers full context for triage.

Can Atlas help me find the root cause of multiple `pgTAP` failures in SQL?

Yes, Atlas's `grep` tool allows you to search the complete `pgTAP` log file for patterns, helping SQL developers group failures by distinct root causes rather than just test names.

How do I track fixes for `pgTAP` failures in SQL with Atlas?

Use Atlas's `todowrite` tool to create a pending task for each distinct root cause identified from your `pgTAP` test failures, ensuring all SQL fixes are tracked.

Does Atlas support editing `Flyway migrations` and `pgTAP` test files?

Absolutely. Atlas's `edit` tool allows SQL developers to modify any `.sql` file, including `Flyway migrations` and `pgTAP` test scripts, directly within the terminal.

How does Atlas ensure I review my SQL changes before applying them?

Atlas computes a unified diff for every file edit, including SQL schema or test changes, and surfaces it for your approval before writing, integrating with Git for robust review.

Can Atlas run specific `pgTAP` tests after I make a SQL change?

Yes, after using `atlas edit` to modify a SQL file, you can use `atlas bash "pg_prove -v t/specific_test.sql"` to re-run only the relevant `pgTAP` tests.

What SQL tools does Atlas integrate with for testing and development?

Atlas integrates directly with `pgTAP` for testing, `Flyway migrations` for package management, and `sqlfluff format` for formatting, recognizing the real SQL toolchain.

Is my SQL code sent to third-party servers when using Atlas?

No, Atlas can build its code index with local Ollama embeddings, keeping your SQL code off third-party servers and ensuring data privacy.

Run the pgTAP Test Suite and Triage SQL Failures with Atlas in 2026

Atlas helps SQL developers in 2026 transform a wall of red `pgTAP` test output into a prioritized list of distinct root causes by leveraging its `bash` tool to run tests, `grep` to identify patterns in full logs, and `todowrite` to track fixes. This workflow ensures efficient debugging and resolution of issues within `Flyway migrations` and other SQL codebases.

How to Run pgTAP Tests with Atlas's Bash Tool for SQL

Atlas's `bash` tool in 2026 executes `pgTAP` tests, handling extensive output by truncating at 2000 lines or 50 KB and saving the complete log to a retained file. This ensures SQL developers always have the full context for debugging complex `t/*.sql` test suites.

When a SQL developer needs to run their `pgTAP` test suite, Atlas's `bash` tool provides the execution environment. For instance, to run all `pgTAP` tests located in the `t/` directory, the command would be `atlas bash "pg_prove -v t/*.sql" --timeout 60000`. The `--timeout` flag is crucial for slow-running SQL test suites, preventing Atlas from prematurely killing the process. A key capability for SQL developers is Atlas's handling of verbose output: while the terminal display is truncated at 2000 lines or 50 KB, Atlas writes the complete `pgTAP` log to a separate file. The path to this file is provided in the `...output truncated...` header, allowing SQL developers to access the entire test output for thorough analysis, which is essential when debugging intricate database logic or `Flyway migrations`.

Grouping SQL Test Failures by Root Cause with Atlas Grep

To efficiently triage SQL test failures, Atlas leverages the `grep` tool to group distinct root causes from the complete `pgTAP` log file, rather than relying on truncated terminal output. This method is vital for identifying patterns across many failing `t/*.sql` tests in 2026.

After running a `pgTAP` test suite, SQL developers often face a 'wall of red' output. Instead of sifting through individual test failures, Atlas encourages grouping by root cause. Using `atlas grep` on the complete `pgTAP` log file (obtained from the `bash` tool's output) allows developers to find common error messages or stack traces. For example, `atlas grep "ERROR: duplicate key value" /tmp/atlas_pgtap_log_12345.txt` can quickly identify all `pgTAP` tests failing due to a specific unique constraint violation, potentially pointing to an issue in a `Flyway migration` like `V3__add_unique_constraint.sql`. This approach helps SQL developers prioritize fixes by addressing the underlying problem that affects multiple tests, rather than fixing symptoms one test at a time.

Tracking SQL Fixes with Atlas's Todowrite Tool

Atlas's `todowrite` tool allows SQL developers to record each distinct root cause identified from `pgTAP` failures as a pending task, ensuring that every fix is tracked and prioritized. This structured approach prevents issues from being forgotten amidst complex `Flyway migrations` in 2026.

Once distinct root causes for `pgTAP` failures have been identified using `atlas grep`, the next step for SQL developers is to create an actionable plan. Atlas's `todowrite` tool is designed for this purpose. For each unique root cause, a new `todowrite` entry can be created with a `pending` status. For example, `atlas todowrite "Fix missing index on users.email in V2__add_email_index.sql" --status pending` creates a clear task. This transforms the overwhelming list of `pgTAP` failures into a manageable, prioritized list of fixes. By tracking these entries, SQL developers ensure that every identified issue, whether it's a bug in a stored procedure or an error in a `Flyway migration`, is addressed systematically and not overlooked.

Reviewing SQL Changes with Atlas's Unified Diff and Git Integration

Atlas ensures safety and transparency for SQL developers by computing a unified diff for every file edit, such as changes to `Flyway migrations` or `t/*.sql` test files, and surfacing it for approval before writing. This process, integrated with Git, allows for meticulous review of all proposed changes in 2026.

Before any changes to SQL files, whether they are `Flyway migrations`, `pgTAP` test scripts, or complex queries, are permanently applied, Atlas provides a crucial safety net. It computes a unified diff for every proposed edit and presents it to the SQL developer for explicit approval. This means that modifications made via `atlas edit` are never written to disk without review. Furthermore, Atlas integrates direct with Git, allowing developers to stage and create commits directly. It also snapshots file changes as Git patches, providing a robust mechanism to diff edits and roll back if necessary. This comprehensive review and version control system is paramount for maintaining the integrity and stability of SQL schemas and applications.

Step by step

01Run your `pgTAP` test suite using Atlas's `bash` tool, providing a generous timeout to accommodate slow SQL tests: `atlas bash "pg_prove -v t/*.sql" --timeout 90000`.
02If the `pgTAP` output was truncated, use `atlas read` to view the complete log file path provided in the `...output truncated...` header for full SQL context.
03Group `pgTAP` failures by distinct root cause using `atlas grep` on the saved log file, focusing on error messages rather than individual test names. Example: `atlas grep "ERROR: foreign key violation" /tmp/atlas_pgtap_log_12345.txt`.
04Record each distinct root cause as a pending task using `atlas todowrite`, creating an actionable list of SQL fixes. Example: `atlas todowrite "Fix missing foreign key in V4__add_orders_table.sql" --status pending`.
05Use `atlas edit` to modify the relevant SQL file, such as a `Flyway migration` (`V4__add_orders_table.sql`) or a `pgTAP` test file (`t/orders_tests.sql`), to implement the fix.
06Re-run only the affected `pgTAP` tests via `atlas bash` to quickly verify your SQL changes. Example: `atlas bash "pg_prove -v t/orders_tests.sql"`.
07Review the unified diff presented by Atlas for your SQL file changes and approve them before writing to disk.
08Once the SQL fix is verified and committed, mark the corresponding `todowrite` entry as complete.

Frequently asked questions

How does Atlas handle large `pgTAP` test output in SQL?: Atlas's `bash` tool truncates terminal output at 2000 lines or 50 KB but writes the complete `pgTAP` log to a retained file, providing SQL developers full context for triage.
Can Atlas help me find the root cause of multiple `pgTAP` failures in SQL?: Yes, Atlas's `grep` tool allows you to search the complete `pgTAP` log file for patterns, helping SQL developers group failures by distinct root causes rather than just test names.
How do I track fixes for `pgTAP` failures in SQL with Atlas?: Use Atlas's `todowrite` tool to create a pending task for each distinct root cause identified from your `pgTAP` test failures, ensuring all SQL fixes are tracked.
Does Atlas support editing `Flyway migrations` and `pgTAP` test files?: Absolutely. Atlas's `edit` tool allows SQL developers to modify any `.sql` file, including `Flyway migrations` and `pgTAP` test scripts, directly within the terminal.
How does Atlas ensure I review my SQL changes before applying them?: Atlas computes a unified diff for every file edit, including SQL schema or test changes, and surfaces it for your approval before writing, integrating with Git for robust review.
Can Atlas run specific `pgTAP` tests after I make a SQL change?: Yes, after using `atlas edit` to modify a SQL file, you can use `atlas bash "pg_prove -v t/specific_test.sql"` to re-run only the relevant `pgTAP` tests.
What SQL tools does Atlas integrate with for testing and development?: Atlas integrates directly with `pgTAP` for testing, `Flyway migrations` for package management, and `sqlfluff format` for formatting, recognizing the real SQL toolchain.
Is my SQL code sent to third-party servers when using Atlas?: No, Atlas can build its code index with local Ollama embeddings, keeping your SQL code off third-party servers and ensuring data privacy.

Try Atlas in your terminal

The terminal-native AI coding agent. Free core, single binary.

Install Atlas

Related guides

Run the Test Suite and Triage the Failures with Atlas in 2026

How to triage a failing test suite with Atlas in 2026: bash truncates at 2000 lines or 50 KB and saves the full log, then grep groups failures by root cause.

Atlas for SQL in 2026

Atlas is a terminal-native AI coding agent for SQL in 2026. Run it in a repo with your migrations or .sql files, optimize a query, and review the diff before applying.

Self-review your working diff before committing in SQL with Atlas in 2026

Catch your own mistakes in uncommitted SQL diffs before they reach review or CI. Atlas helps SQL developers in 2026 self-review changes, run pgTAP tests, and format with sqlfluff.

Locate Where a Behavior is Implemented in SQL with Atlas in 2026

In 2026, Atlas helps SQL developers quickly locate the exact file and symbol responsible for a behavior across Flyway migrations and .sql files, using semantic search and LSP.

Rename a SQL Symbol Across Your Repo with Atlas in 2026

In 2026, Atlas helps SQL developers rename functions, classes, or constants across their entire codebase, integrating with pgTAP, Flyway, and sqlfluff for verified refactoring.

Debug a single failing test in SQL with Atlas in 2026

Debug a single failing SQL test with Atlas in 2026. Use Atlas to pinpoint issues in pgTAP tests, navigate your SQL codebase, and fix production code efficiently. Get precise diffs and approvals.

Automate GitHub Issue and Pull Request Triage in SQL with Atlas in 2026

Streamline GitHub issue and pull request triage for your SQL projects using Atlas. Automate responses, refactor queries, and manage Flyway migrations safely with a terminal-native AI agent.

Review a Pull Request in SQL with Atlas in 2026

In 2026, SQL developers use Atlas to review pull requests, catching subtle bugs beyond line-by-line diffs. Atlas integrates with pgTAP and Flyway migrations for comprehensive SQL code review.

Browse this resource hub