How does Atlas find SQL functions without exact keyword matches?

Atlas indexes SQL code by AST declarations using tree-sitter, allowing it to understand the structure and meaning of your functions and procedures, not just blind line windows. This enables semantic retrieval even when your search terms don't appear verbatim in the source, making it effective for `Flyway migrations` and complex `.sql` files.

How does Atlas ensure my SQL code changes are safe?

Atlas employs several safety mechanisms: every tool call is permission-gated, plans are drafted in a read-only agent for approval, and all proposed SQL edits generate a unified diff for your review. Additionally, Atlas snapshots file changes as git patches for easy rollback, protecting your `Flyway migrations` and `.sql` files.

Does Atlas integrate with my existing SQL development tools?

Absolutely. Atlas is designed to work with your current SQL toolchain. It understands `Flyway migrations`, can help optimize queries, and you can use it alongside `pgTAP` for testing and `sqlfluff format` for code formatting, all within your terminal.

What if Atlas suggests a wrong SQL file or symbol?

Atlas's `read` tool provides immediate feedback. If you attempt to open a non-existent SQL file, it will loudly report 'File not found' and offer a 'Did you mean' list based on similar paths in your repository, preventing you from wasting time on incorrect guesses.

Can Atlas help me understand the call graph of a SQL stored procedure?

Yes, using the `lsp` tool, you can leverage `findReferences` on a specific stored procedure or function name within a `.sql` file. This will show you every location where that SQL symbol is invoked, helping you map out its call path and dependencies across your codebase.

Does Atlas keep my SQL code private?

Yes, Atlas prioritizes privacy. It can build its code index with local Ollama embeddings, ensuring that your sensitive SQL schema, `Flyway migrations`, and query files remain entirely on your local machine and are not sent to third-party servers.

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

In 2026, Atlas empowers SQL developers to pinpoint where a behavior is implemented by combining hybrid semantic and keyword retrieval with exact text matching and symbol graph navigation. It direct integrates with your existing SQL toolchain, from `Flyway migrations` to `pgTAP` tests, allowing you to describe a behavior and find its source without knowing the code's exact name.

How Atlas Finds SQL Behavior with Semantic Search

Atlas leverages its hybrid semantic and keyword retrieval to locate SQL behavior, even if your query doesn't match exact code. In 2026, this means you can describe a complex database operation, and Atlas will return relevant declarations from your `V1__initial_schema.sql` or other migration files.

When you need to find the implementation of a SQL behavior but only know what it does, Atlas begins by attacking the problem from a semantic angle. The `codebase_search` tool uses hybrid semantic and keyword retrieval fused by reciprocal rank fusion to understand your intent. Unlike simple text searches, Atlas indexes SQL code by AST declarations using tree-sitter, not blind line windows. This allows it to return candidate declarations from your `Flyway migrations` or `.sql` files even when your descriptive words do not appear verbatim in the source code. For instance, if you search for 'calculate user loyalty points,' Atlas can identify a stored procedure named `sp_update_customer_rewards` in `src/main/resources/db/migration/V10__add_loyalty_program.sql` because it understands the underlying meaning of the code, not just keywords. Atlas can build its code index with local Ollama embeddings, ensuring your sensitive SQL schema and query files remain off third-party servers.

Confirming SQL Behavior with Exact Text and File Filters

After an initial semantic search, Atlas confirms potential SQL behavior implementations using `grep`, which offers precise regex matching and file filtering. This step, crucial in 2026, ensures you validate semantic results against the exact text within your `pgTAP` tests or `sqlfluff format` configurations.

Once Atlas provides candidate declarations from its semantic index, the next step is to confirm these findings with exact text matching. The `grep` tool, powered by ripgrep, allows you to run real regular expressions across your SQL codebase. This is particularly useful for verifying specific string literals, table names, or function calls that might be unique to the behavior you're investigating. You can refine your search with `include` and `path` filters, targeting specific directories like `src/main/resources/db/migration/` or files ending in `.sql`. For example, if Atlas suggested a migration file, you could then `grep` for a specific column name or a `CREATE FUNCTION` statement within that file. This dual approach ensures that you not only find semantically relevant code but also confirm its presence with precise textual evidence, bridging the gap between conceptual understanding and concrete code.

Navigating SQL Code with LSP and Symbol Graphs

Atlas integrates with Model Context Protocol servers to expose powerful LSP tools, enabling SQL developers in 2026 to navigate complex database schemas and stored procedures. This allows you to jump directly to a declaration or find every callsite of a function defined in your `V2__create_procedures.sql` file.

To fully understand a SQL behavior, you often need to explore its dependencies and callers. Atlas's `lsp` tool provides robust capabilities for navigating the symbol graph of your SQL codebase. Once you've identified a promising candidate file, such as `functions/calculate_order_total.sql`, you can use `read` to open it. If you make a wrong guess, Atlas fails loudly with 'File not found' and a 'Did you mean' list, preventing wasted time. With the file open, you can then use `lsp findReferences` on a specific function or procedure name to see every location where it's called throughout your `Flyway migrations` or application queries. Conversely, `lsp workspaceSymbol` allows you to jump directly to the declaration of a symbol by its name, even if you're not currently viewing its definition. This deep integration with the language server protocol provides a powerful way to trace the execution flow and understand the full impact of a SQL behavior.

Reviewing and Approving SQL Code Changes with Atlas

Atlas prioritizes safety and transparency in 2026 by requiring explicit approval for all SQL code modifications, from `sqlfluff format` adjustments to schema changes. Every Atlas tool call is permission-gated, and all proposed edits are presented as a unified diff for your review before writing to disk.

Even when your primary goal is to locate behavior, understanding how Atlas handles potential modifications is crucial for SQL developers. Atlas operates with a strong emphasis on safety and user control. Every Atlas tool call is permission-gated against allow, ask, and deny rules before it runs, ensuring you maintain full control over your codebase. When Atlas drafts a plan, it does so in a read-only plan agent and asks for your approval before switching to a build agent that can make changes. For any proposed edit, whether it's optimizing a query, writing a new `Flyway migration`, or even applying `sqlfluff format` to a `.sql` file, Atlas computes a unified diff. This diff is surfaced for your approval, allowing you to review every line change before it's written. Atlas also snapshots file changes as git patches, so edits can be easily diffed and rolled back, providing an additional layer of security and auditability for your critical SQL assets.

Step by step

011. Describe the SQL behavior to Atlas: Use `atlas codebase_search` to articulate what the SQL code does, not what it's called. For example: `atlas codebase_search "find the stored procedure that calculates customer loyalty points"`
022. Review semantic candidates: Atlas will return candidate SQL declarations from your `Flyway migrations` or `.sql` files, even if your words don't appear directly in the source. Examine these for relevance.
033. Confirm with exact text: Use `atlas grep` with a regex and path filters to validate semantic results. For instance: `atlas grep "UPDATE customer_rewards SET" --include "V10__add_loyalty_program.sql"`
044. Open the best candidate: Use `atlas read` to view the most promising SQL file. If you guess wrong, Atlas will suggest alternatives. Example: `atlas read src/main/resources/db/migration/V10__add_loyalty_program.sql`
055. Explore symbol references: With the file open, use `atlas lsp findReferences` on a function or procedure name (e.g., `sp_update_customer_rewards`) to see all its callsites across your SQL codebase.
066. Jump to declarations: If you know a symbol's name, use `atlas lsp workspaceSymbol "calculate_order_total"` to jump directly to its definition in a `.sql` file.
077. Summarize the call path: Atlas will help you summarize the call path with concrete file and line references, providing a clear understanding of the SQL behavior's implementation.

Frequently asked questions

How does Atlas find SQL functions without exact keyword matches?: Atlas indexes SQL code by AST declarations using tree-sitter, allowing it to understand the structure and meaning of your functions and procedures, not just blind line windows. This enables semantic retrieval even when your search terms don't appear verbatim in the source, making it effective for `Flyway migrations` and complex `.sql` files.
Can Atlas search within specific SQL migration files?: Yes, Atlas's `grep` tool supports `path` and `include` filters, allowing you to target specific directories like `src/main/resources/db/migration/` or file patterns like `V*.sql`. This ensures your search is highly focused on relevant `Flyway migrations`.
How does Atlas ensure my SQL code changes are safe?: Atlas employs several safety mechanisms: every tool call is permission-gated, plans are drafted in a read-only agent for approval, and all proposed SQL edits generate a unified diff for your review. Additionally, Atlas snapshots file changes as git patches for easy rollback, protecting your `Flyway migrations` and `.sql` files.
Does Atlas integrate with my existing SQL development tools?: Absolutely. Atlas is designed to work with your current SQL toolchain. It understands `Flyway migrations`, can help optimize queries, and you can use it alongside `pgTAP` for testing and `sqlfluff format` for code formatting, all within your terminal.
What if Atlas suggests a wrong SQL file or symbol?: Atlas's `read` tool provides immediate feedback. If you attempt to open a non-existent SQL file, it will loudly report 'File not found' and offer a 'Did you mean' list based on similar paths in your repository, preventing you from wasting time on incorrect guesses.
Can Atlas help me understand the call graph of a SQL stored procedure?: Yes, using the `lsp` tool, you can leverage `findReferences` on a specific stored procedure or function name within a `.sql` file. This will show you every location where that SQL symbol is invoked, helping you map out its call path and dependencies across your codebase.
Does Atlas keep my SQL code private?: Yes, Atlas prioritizes privacy. It can build its code index with local Ollama embeddings, ensuring that your sensitive SQL schema, `Flyway migrations`, and query files remain entirely on your local machine and are not sent to third-party servers.

Try Atlas in your terminal

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

Install Atlas

Related guides

Locate Where a Behavior Is Implemented with Atlas in 2026

How to locate where a behavior is implemented with Atlas in 2026: codebase_search for meaning, grep for exact text, and the lsp tool for the symbol graph.

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.

Audit a SQL Repo with Parallel Subagents in 2026 using Atlas

In 2026, SQL developers use Atlas to audit entire repositories for specific problems, leveraging parallel subagents to sweep code without context window limits. Integrate with pgTAP, Flyway migrations, and sqlfluff

Onboard to an Unfamiliar SQL Codebase with Atlas in 2026

Rapidly build a mental model of any SQL repository in 2026 using Atlas. Leverage semantic search, explore Flyway migrations, and understand pgTAP tests without reading every file.

Add a Regression Test for a SQL Bug Fix with Atlas in 2026

Lock in SQL bug fixes with Atlas in 2026. Learn to add a regression test that fails before the fix and passes after, using pgTAP and Flyway migrations.

Document a SQL Module with a README using Atlas in 2026

In 2026, Atlas helps SQL developers generate accurate READMEs for modules by analyzing live code, not outdated specs. It leverages pgTAP, Flyway migrations, and sqlfluff format to ensure documentation reflects the

Migrate a Deprecated API Across Every Callsite in SQL with Atlas in 2026

In 2026, Atlas helps SQL developers migrate deprecated functions or modules across an entire codebase, ensuring no callsite is missed and changes are validated with pgTAP and Flyway migrations.

Browse this resource hub