A little over a month ago, we shipped the first public preview of the SQLMesh Visual Studio Code extension (link to documentation for those who want to jump straight into the product). At the time, it came with a lineage view, basic language server features, and the ability to render a model.

Since then, we’ve been sprinting to expand the extension’s capabilities. Below, I'm taking you on a brief tour of everything that’s changed since the launch, why that matters, and what we have planned for future additions and improvements.

Language Server Updates

The language server is the core of the VS Code extension, and it has seen the most love from our engineering team over the last month. If you’ve ever developed in any other language, you know the power of a good language server: it surfaces the right context, at the right time, to make your development experience frictionless. During the past weeks, we’ve enhanced the SQLMesh language server with autocomplete, go to definition, references and hints, and more - so you don’t have to break flow to find the code you need or toggle from one workflow to the next.

Autocomplete

We have made autocomplete more intelligent and context-aware. It continues to suggest models, as it did from day one, but we’ve added new elements to make writing code in SQLMesh even more intuitive:

  • Common Table Expressions (CTEs) to break complex queries into more digestible steps and make commonly needed logic reusable.
  • SQL keywords to accelerate typing and keep syntax consistent by autocompleting keywords that appear in most queries, like SELECT, JOIN, and GROUP BY.‍
  • Python macros that allow you to write reusable SQL-generating logic in Python and apply them easily across your SQLMesh projects.

In addition to completing what you type, our upgraded language server now adapts to the context of your work. It offers more relevant suggestions based on where you are (and what you intend to do) in your workflow, reduces keystrokes, and minimizes room for error - all of which can add up to serious efficiencies in day-to-day development.

Figure 1. Autocomplete in the language server

Go to definition

Jumping to the source of a definition is immensely handy. The ability to toggle to the original definition of a table, macro, or expression - and back again to the code you’re working on - is something we take for granted in other languages. Now, it’s also the default in SQLMesh.

In our first iteration of the VS Code extension, go to definition worked only for model references. We’ve expanded that functionality: you can now easily navigate to Python macros and CTEs. For external models, rather than just taking you to the file, the extension brings you to the exact line where the definition lives. Particularly for our users with larger projects that feature many models and external references, we believe this will substantially improve speed and clarity in development workflows.

Figure 2. Showcasing go to definition

References

Go-to-definition brings you to the source. But if you want to go the other way, and explore where a definition is used, our VS Code extension now lets you do so for models, CTE, and Python macros as well. Right-click on a definition, hit ‘Go to references’, and you’ll get the following view that expands the instances where the definition is referenced .

Figure 3. Definition references in the language server

Inline type hints

If you look carefully at the image above, you may notice something odd. There are type casts, but they are in a different font. If you’ve written statically typed languages, these might feel familiar. This is another addition we’ve made to the VS Code extension - from this version forward, SQLMesh can infer data types and, where possible, display inline hints directly in your editor, sparing you from tracking down type information elsewhere. We expect these will give your developer experience a nice boost.  

Figure 4. Inline type hints in the language server

Rename

To round up this first batch of language server updates, we are rolling out support for renaming elements within the extension, beginning with CTEs. Using a keyboard shortcut or right-clicking in the editor (as shown below), you can now rename a CTE to your heart’s content, and see that change reflected everywhere it’s used. Support for renaming models and columns is also in the works, and we’re excited to bring that to you soon.

Figure 5. Showcasing renaming feature for CTEs

Linter

While much of our attention has gone into strengthening the language server, we’ve also made meaningful enhancements elsewhere in the extension, starting with the linter. 

We’ve made our linter smarter. It now returns positional information to pinpoint an issue’s exact location - and take you to it for troubleshooting. In some cases, we’re able to go a step further still, and suggest a solution. For example, the `noselectstar` linting rule will highlight asterisks and offer a one-click “Quick Fix”. It’s a subtle change, but a big quality-of-life improvement: we narrow down the source of errors and blockers, so you can resolve them faster - and be on your way to the parts of your work that move things forward. 

Figure 6. Linter improvements & one-click quick-fix

Macros

While macros themselves haven’t seen major changes in this release, they’ve become significantly more intuitive to use when paired with our new autocomplete, go to definition, references, and inline hints. 

At their core, macros are about one thing: reusable code. And I feel it’s worthwhile to again highlight macros because, combined with our other features, they will dramatically change the way you write code. 

If you have conventions you want to standardize, the traditional standard to do so is with Jinja macros - but they are brittle, hard to read, and notoriously complex to wrestle with. SQLMesh offers a delightfully cleaner approach: macros that simply consist of Python functions that modify SQL expressions. That means our macros are:

  • Easy to reason about - because it’s just Python.
  • Easy to test - just use your favourite Python unit testing framework.
  • Easy to use - autocomplete, go to definition, and usage tracking work out of the box.
  • Easy to visualize - you can render models that use macros like you would any other SQLMesh model.

Together, this creates a step-change in developer ease of use. No more fiddly curly brace if and else statements, just good old-fashioned Python. Along with blueprints - another feature we launched earlier this year - macros make ‘repeating’ your models a breeze by comparison with what you’re accustomed to.

Figure 7. Easier developer experience with Python macros

Stability

Last but certainly not least, we have made the extension more stable. With our initial launch last month, we encountered a few teething problems. Historically, SQLMesh has always been a short-lived process: run a command, get a result, and it’s done. The language server, by contrast, is long-lived. That mismatch introduced unanticipated challenges, particularly when handling broken projects, e.g. when users were typing. 

The language server is now much more robust. To further reinforce the extension’s stability, we have implemented a dedicated testing framework, and it has proven very effective at catching issues earlier in development. I’ll share more about that in a future post. 

What’s coming next for the SQLMesh VS Code extension

We’re building toward a more complete, intuitive developer experience, where using SQLMesh in VS Code feels both smooth and powerful, and where data transformation can become easier to reason about, faster to iterate on, and more enjoyable to work with.

With that in mind, we have plenty more features on the way. Here is a preview of what you can expect in the coming weeks:

Load time errors

Some errors stop your project from loading - duplicate model names and bad MODEL blocks come to mind. I like to think of this step as “compiling” your project. At the moment, SQLMesh only returns a notification when these errors become blockers, which makes them tricky to debug - but soon, notifications will become more actionable as we add inline diagnostics.

Columns

We’ve laid out a rich catalogue of improvements to our language server, but we haven’t yet addressed columns. Fortunately, that’s about to change - and when it does, you will also be able to jump to column definition, list their usage, or hover over them to get more information.

Table Diff

You may know this popular feature from our CLI. Whether you're developing, migrating, or just testing your dev environment, “table diff” allows you to compare two tables - their schema and rows. And in the near future, we will incorporate this capability into the SQLMesh extension, so you can make comparisons directly in VS Code.

Tell us what to do build next in the SQLMesh VS Code extension

SQLMesh is proudly open source. We have many more features in store for the extension, and your feedback shapes every update we make. If you haven't already installed our VS Code extension for SQLMesh, I encourage you to try it here. And if you have requests, spot bugs, or would like to bounce ideas for our extension off our team - join our Slack community and let us know. Your engagement keeps us moving!