How to Migrate to Obsidian Bases from Dataview

Dataview has been a popular Obsidian plugin for a very long time, with over 3 million downloads since its initial release back in January of 2021.

This powerful plugin gives users the tools to query the notes in their Obsidian vaults. The most straightforward way to do this is by using a vaguely SQL-looking expression language called Dataview Query Language or DQL. Unfortunately, the learning curve is still a little steep for the non-technical, and it can be a little bit tricky for new users to get the hang of. Fortunately, with the release of the Bases core plugin, you can now do a lot of what Dataview did faster and more efficiently using this new native feature.

Dataview is also currently in the process of being replaced by its work-in-progress successor, Datacore. Datacore has been in development for years, and while the official successor to Dataview brings increased performance and interactive views, it also brings a new syntax and additional complexity.

All the while, Obsidian Bases continues to get better. And the public Obsidian Roadmap lists several features currently in development that will likely eliminate many users' reliance on Dataview altogether.

In short, now is a great time to see how much you can accomplish using the built-in Bases core plugin instead. And in this post, I want to show you how you can update your Dataview queries to take advantage of the new Bases features available in Obsidian.

Why You Might Want to Migrate From Dataview to Bases

Full disclosure, I've never been a real heavy Dataview user.

I could grok the syntax fine, but it always seemed unnecessarily complicated to me, and I never felt great adding Dataview queries to my notes. As a result, while I had (past tense 😉) several Dataview queries in my Obsidian vault, I tried to limit the amount that I relied on them.

And I have since replaced every single one of them with Obsidian bases instead.

(I do still have a few inline expressions and DataviewJS snippets. But the tables I used to roll up notes based on specific queries have all been replaced.)

Now, I know that Obsidian Bases is a bit limited when you compare it side-by-side to everything Dataview can do. If you are a Dataview power user, then you may not fully be able to make the switch.

For most day-to-day Obsidian users, though, I believe Bases provides a better, simpler, and much faster way to query your notes.

In fact, the main reason you might want to move from Dataview to Bases is the speed. Bases results render nearly instantly, even in my vault with over 50,0000 notes. The same cannot be said about Dataview, which has a tendency to seriously degrade your vault performance (especially on mobile).

I can't overstate how incredibly snappy Bases is to use. It's kind of incredible, actually. And since it's a core plugin that ships with the app, if you're new to Obsidian, it's the obvious place to start. I'd personally recommend you only add Dataview if you hit the limit of what you need with Bases first.

I'm guessing most people won't, though. And as a general rule, the less you need to rely on Community plugins, the quicker Obsidian will be (and the fewer bugs you will encounter) as a result.

The Link Between Bases & Properties

One of the big differences between Dataview and Bases is the source of the data that is used for the query.

While Dataview can also use metadata properties to power its views, it also has the ability to use inline key-value pairs. These are usually denoted with syntax of key::value somewhere inside the contents of your notes.

Bases, on the other hand, uses YAML metadata that is stored in the note properties. These are most easily accessible when you toggle on the Properties View core plugin, and appear either in the sidebar or at the top of the note.

Properties have been around for a while, though up until Bases was released, I feel like we really didn't see the whole picture of how these should be used. They're very similar to the properties in Notion and are a very powerful way to add metadata to your notes.

There are several different types of Properties you can use in Obsidian:

• Text - any text characters
• List - multiple text values stored on separate lines
• Number - requires a numerical input
• Checkbox - has a simple true or false state
• Date - uses YYYY-MM-DD formatting
• Date & Time - adds additional HH:MM formatting to a date value

You can tell the type of Property by the icon next to the property name, and you can change the property type by clicking on this icon and selecting a new option from the drop-down list.

These properties are the key to using Bases. You'll want to make sure that you have these configured correctly in your vault and the values are up to date before you start creating Bases views.

If You Use Inline Metadata, Read This!

If you want to use the data you have stored in your notes currently as inline Dataview key value pairs in Obsidian Bases, you'll need to convert those to YAML properties first.

If you currently have something like key::value in the contents of your notes, you'll need to move that data into the YAML frontmatter as key: value instead.

Obviously, you can do this by hand. But if you want to save some time, there are tools you can use to move your Dataview inline key value pairs to metadata in preparation for using Obsidian Bases instead. I've not actually had experience using any of these myself, but if I were to use one, I'd use the Dataview (to) Properties plugin. This is the one that has been recommended to me by others who have successfully moved their Dataview inline key-value pairs from their notes to their note properties.

But the bottom line is that you need to have clean and clear properties before you can actually leverage the power in Obsidian bases.

Understanding Your Current Dataview Queries

Most Dataview queries are pretty straightforward. The Dataview Query Language usually includes up to five different components that make up the query.

1. Output
2. Source
3. Filter
4. Sorting
5. Grouping

Let's break these down before we look at how to implement them using Bases.

The first thing in a Dataview query is usually the type of output you want. There are four different kinds of output:

• TABLE - includes rows and columns
• LIST - similar to a table, but only shows a single column
• TASK - shows Dataview-formatted tasks in your Obsidian vault
• CALENDAR - shows the results in a month-view calendar

Before you can do anything else in Dataview, you must select a query type. This is the only required field for a Dataview query, and unlike Bases, you can only choose one.

Next, you need to define the source by using FROM. This tells Dataview where to pull the query from, for example, a particular tag (i.e. #project) or a specific folder in your Obsidian vault (i.e. Writing/Articles).

After you've defined the output type and the source, you need to define the filter using WHERE. This sets the conditions of the query based on the data inside your notes. Only notes where the value equals true will be displayed in the query based on the clause that you use here.

Next, you can define the order of the results rendered by the query using SORT. This determines how the results of the query will be displayed, for example, in reverse chronological order.

And lastly, you can group results together by using GROUP. This is useful if you want a secondary way of showing how things are connected.

Here's an example Dataview query that rolls up all notes that have the #project tag and are not in the Templates folder:

```dataview
TABLE without id file.link as "Project", dateformat(file.ctime,"yyyy-MM-dd") as "Date Created", dateformat(file.mtime,"yyyy-MM-dd") as "Last Modified", file.tags as "Tags"
FROM #project AND -"Templates"
```

So once you understand these key components of your Dataview query, you can now start to translate these into Obsidian Bases.

Recreating Dataview Queries in Bases

The easiest way to recreate your Dataview queries in Bases is visually. You can either create a new .base file via the Command Palette, or you can create an inline Bases code block like so:

```base
```

Either way, you'll get a rendered Bases query that shows all of the notes in your vault.

From here, you can start bringing over the five different Dataview query components I outlined above.

First is the output type, which in Bases is called a View. When you create a new Base, the type of output for the default view is automatically set to Table by default. You can edit the current View (or create a new view) by clicking the button in the upper-left:

Currently, there are only two view types you can choose from: Table and Cards. Table creates a table that looks very similar to the Dataview table, and the Cards view looks something like this:

(This Cards View comes from my Obsidian Book Notes Library, and if you want to see me set the whole thing up, check out this YouTube video.)

But one big advantage of Obsidian Bases is that you can actually have multiple views in the same Base. Once you create an additional view, you can apply specific filters to each and actually flip back and forth between them at will.

Next is the source (which in Dataview was defined by using FROM). This is controlled in Bases by using the Filter button. From here, you can visually build the criteria you want to use to filter the results of your Base.

When adding these, you can use a couple of conditional statements:

• All of the following are true
• Any of the following are true
• None of the following are true

For each filter, you choose the property you want, the conditional statement (i.e., is, is not, contains, etc.), and the value. You can choose from any of the properties you have in your notes, as well as a bunch of inherited properties (like created or modified time).

And since you can have multiple views, you can also apply these filters for all views in the current Base or just the current view.

For example, in my Obsidian Book Notes library, I have a filter for all views that shows all notes from the Book Notes folder, then I have another view that has an additional filter that only shows books where the rating is five stars.

Being able to combine views and filters like this is really powerful, and one of the biggest advantages of using Obsidian Bases over Dataview.

When adding filters based on property values, you may want to list these values in either the Table or Cards views. To display these, click on the Properties button and just select the properties you want to make visible in the current view:

You can also edit the labels for any of these displayed Properties by clicking the carat and changing the display name.

Next, you can change the sort order of the results in your Obsidian Base by clicking the Sort button. You can sort by any of the available properties, and you can even add multiple properties here to apply different levels of sorting for larger queries.

Now, if you're following along, you might have noticed the only thing we didn't cover yet is the grouping options from Dataview. And that's because you currently can't do anything with these in Bases. This is one area where Dataview is still better than Bases, though the public roadmap does show that grouping options are currently in development (along with List and Kanban views and even a Bases API).

Editing Bases Syntax

So far, I've walked you through how to manually rebuild your Dataview queries using the visual nature of Obsidian Bases. But if you want to directly edit the syntax, you just need to create an inline Base by using the three backticks, make the changes like we've talked about so far. Then, click the code button in the upper-right of the Base to reveal the underlying syntax.

As an example, here's the code from the query above:

```base
filters:
  or:
    - file.inFolder("Daily Notes")
formulas:
  on_this_day: if(date(file.name).month == "09", if(date(file.name).day == "28", if(date(file.name).year != "2025", "True", "False"), "False"), "False")
properties:
  file.name:
    displayName: Daily Note
views:
  - type: table
    name: On This Day
    filters:
      and:
        - formula.on_this_day.contains("True")
    order:
      - file.name
    sort:
      - property: file.name
        direction: DESC
    formula.on_this_day:
      displayName: On This Day
```

(If you want to dig into how I built this specific query, check out this YouTube video.)

From here, you can copy and paste the code and place it anywhere else in your Obsidian vault. Note that you can't actually get to this if you are using a .base file, though (it's only accessible if you're using an inline Bases code block).

I actually think the fact that you can edit your Base visually makes it much easier to get started with Bases, and that's actually how I'd recommend you build your queries at first. But if you want to dive into the specifics of the syntax, there's a lot of helpful documentation available on the help site here.

Using the Online Dataview to Bases Converter

Maybe you've been reading up until this point, and you're still a little confused.

Don't worry 😉 There's another way to convert your Dataview queries to Bases syntax by using a web tool called the Dataview to Bases converter. With this tool, you can paste your existing Dataview query in the box on the left, and the query instantly gets translated into the corresponding Bases syntax on the right:

From here, you can simply copy and paste this code into your note as an inline Bases code block that uses the same settings, sources, and filters as the original Dataview query. If you prefer, you can also download the syntax as a .base file and drop it into your Obsidian vault.

Personally, I think this tool is pretty great. If you just want a quick way to convert some of your simple Dataview queries, this free tool is perfect for you.

Conclusion

So that's how you can convert your Dataview queries to Obsidian Bases. Obviously, the specifics of each query are going to be a little bit different, but in general, I'd 1) try to use the online Dataview to Bases converter tool first, then if you can't quite get it, 2) use the Obsidian Bases interface to live edit and rebuild your Dataview query visually.

It is still early, but I believe that Bases is already good enough to completely replace Dataview for the majority of Obsidian Users. In fact, I've actually replaced all of my standard Dataview queries with Bases, and even updated all of my template files. I've also completely updated LifeHQ ,my epic done-for-you Obsidian vault, which has had full Bases support from the very first day the plugin was released to the general public.

Bottom line: Bases is already amazing, and it's only going to get better. Now is a great time to make the switch.