📝 Lesson 6.2: Dataview — Turn Your Notes into a Database

The Big Idea: Notes as a Database

Picture a spreadsheet of every book you've read: title, author, rating, date finished. Now imagine you never had to build that spreadsheet — it just assembled itself from the notes you already wrote, and stayed current forever. That's Dataview.

Here's the shift in thinking. A plain note is a page of text. But if you add a little structured data to your notes — "this note is about a book, rated 4 stars, finished last March" — then a collection of notes becomes a table of records. Dataview reads all your notes, gathers that structured data, and lets you query it: show me every book rated 4 stars or higher, sorted by date. The result appears right inside a note, live, and refreshes as you add more books.

Why does this matter so much? Because it flips note-taking from filing to querying. You stop maintaining lists by hand — reading lists, project trackers, meeting logs, "notes I need to revisit" — and instead let a query build them for you from the notes you're already writing. This is the engine behind dashboards and Maps of Content (MOCs), and it's why Dataview is the single most-loved plugin in the Obsidian world.

Installing Dataview & Adding Data

You already know the drill from Lesson 6.1. Open Settings > Community plugins > Browse, search for Dataview (by Michael Brenan / blacksmithgu), Install, then Enable. Dataview is enormously popular and actively maintained — it sails through the evaluation checklist. It only reads your notes to build its index, so it's low-risk.

Two ways to add data to a note

Dataview reads structured data from your notes in two forms. You'll use both.

1. YAML frontmatter (Properties)

You met this back in the Properties lesson: a block of key: value lines between --- fences at the very top of a note. Dataview treats every property as a field.

---
title: The Pragmatic Programmer
author: Hunt & Thomas
rating: 5
status: finished
finished: 2026-03-14
tags:
  - book
---

2. Inline fields

Sometimes you want a field in the body of a note, next to the text it describes. Dataview lets you write inline fields using a double colon: key:: value.

This book was recommended by a mentor.
rating:: 5
status:: finished
finished:: 2026-03-14

You can even put an inline field mid-sentence using bracket syntax so it reads naturally, e.g. [rating:: 5] or (rating:: 5) — square brackets keep the key visible, parentheses hide it and show only the value.

The Four Query Types

A Dataview query lives inside a fenced code block whose language is dataview. When you're in Reading view (or Live Preview), Obsidian replaces the block with the rendered result. Every query starts with one of four query types.

LIST — a simple bullet list of notes

The simplest output: one bullet per matching note, linked.

```dataview
LIST
FROM #book
```

That renders a bulleted, clickable list of every note tagged #book. You can also list a value beside each note: LIST rating FROM #book shows each book with its rating.

TABLE — columns of data

The workhorse. You name the columns you want, and (optionally) rename them with AS for a friendly header.

```dataview
TABLE author AS "Author", rating AS "★", status AS "Status"
FROM #book
SORT rating DESC
```

The first column is always the note's link — you don't have to ask for it. Each additional expression after TABLE becomes a column; AS "..." sets its header text.

TASK — checkboxes from across your vault

Dataview can gather Markdown tasks (lines starting with - [ ] or - [x]) from every note. The magic touch: checking a box in the query result checks it in the original note. It's a real, interactive task view.

```dataview
TASK
FROM "Projects"
WHERE !completed
```

That collects every unfinished task from notes in your "Projects" folder into one live checklist.

CALENDAR — a monthly heat-map (worth knowing)

The fourth type, CALENDAR, plots notes onto a month calendar based on a date field. It's less commonly used than the other three, but it's there when you want a visual, date-based view.

```dataview
CALENDAR finished
FROM #book
```

This drops a dot on each day a book was finished. For most everyday work you'll reach for LIST, TABLE, and TASK — master those three and you can build almost anything.

FROM, WHERE, SORT, LIMIT, GROUP BY

These clauses shape which notes appear and in what order. They read almost like English.

FROM — choose your source

FROM narrows the query to a set of notes. Sources can be combined with and / or:

Omit FROM entirely and Dataview searches your whole vault — useful, but usually you want to narrow it.

WHERE — filter by field values

WHERE keeps only rows matching a condition. Combine with and, or, and comparison operators:

WHERE rating >= 4
WHERE status = "finished"
WHERE rating >= 4 and status != "abandoned"
WHERE contains(tags, "favorite")
WHERE !completed          # for tasks: only unchecked ones

SORT — order the results

SORT field ASC or SORT field DESC. You can sort by any field or implicit field: SORT rating DESC, SORT file.name ASC, SORT file.mtime DESC (most recently modified first).

LIMIT — cap the number of rows

LIMIT 10 shows only the first ten results — perfect for a dashboard's "5 most recent notes" widget when paired with a SORT.

GROUP BY — cluster rows under headings

GROUP BY field collapses results into groups. For example, group your books by status so "reading," "finished," and "to-read" each get their own section:

```dataview
TABLE rows.file.link AS "Books"
FROM #book
GROUP BY status
```

FLATTEN — one row per value (brief)

Occasionally a field holds a list (e.g. a note with several author values, or you want one row per tag). FLATTEN expands a list so each item becomes its own row. It's an advanced move — just remember it exists for when you need "one row per item in a list rather than one row per note."

```dataview
TABLE author
FROM #book
FLATTEN author
```

Implicit Fields & Inline Queries

Implicit fields — data every note already has

You don't have to add fields to query useful things. Every note automatically carries a set of implicit fields under file. These are gold for dashboards:

So "the 5 notes I touched most recently" needs no special fields at all:

```dataview
TABLE file.mtime AS "Last edited"
SORT file.mtime DESC
LIMIT 5
```

Inline queries — a value dropped into prose

Sometimes you don't want a whole block — just a single value woven into a sentence. An inline query uses a single equals sign inside backticks, and Dataview replaces it with the computed value in Reading view:

This note is called `= this.file.name` and was created on `= this.file.ctime`.

Here this refers to the current note. You can surface any field: `= this.rating` prints the current note's rating right in the text. Inline queries are wonderful for note headers and templates (which is exactly where you'll use them in the next lesson).

Four Queries You Can Paste

Here are four correct, ready-to-use queries. Assuming you've tagged some notes, paste any of these into a note (in a dataview fence) and watch it come alive.

1. Every note tagged #book, as a list

```dataview
LIST
FROM #book
SORT file.name ASC
```

2. A table of projects with their status and due date

```dataview
TABLE status AS "Status", due AS "Due", file.mtime AS "Updated"
FROM #project
WHERE status != "done"
SORT due ASC
```

3. Every incomplete task across the vault

```dataview
TASK
WHERE !completed
GROUP BY file.link
```

Grouping by file.link tidies the tasks under the note each one came from. Check a box here and it updates the source note.

4. Your five most recently edited notes (a dashboard classic)

```dataview
TABLE file.folder AS "Folder", file.mtime AS "Last edited"
SORT file.mtime DESC
LIMIT 5
```

A Word on DataviewJS

Everything above uses the friendly Dataview Query Language (DQL) — plain, readable, and enough for the vast majority of needs. Dataview also ships a power-user mode called DataviewJS: a dataviewjs code block where you write actual JavaScript to build completely custom output — computed columns, charts, conditional formatting, anything code can do.

```dataviewjs
dv.list(dv.pages("#book").where(b => b.rating >= 4).file.link)
```

You do not need DataviewJS to be productive — many expert users never touch it. Just know it exists as a ceiling above you: if one day you hit something DQL can't express, JavaScript is waiting. For now, DQL is your happy home. (And a small safety note: because DataviewJS runs code, only paste DataviewJS you understand or trust — the same mindset from Lesson 6.1.)

Bases — Obsidian's Native Database (No Plugin Needed)

Dataview is a community plugin. But Obsidian now ships a built-in way to turn notes into a database, too: Bases, a core feature you enable in one click — no plugin to install, and it works everywhere Obsidian does, including Sync and mobile. Where Dataview is a query language you write, Bases is a visual, spreadsheet-like interface you click: pick which note properties become columns, add filters from menus, and switch between a Table and a Card view — all without learning any syntax.

How it works

Turn it on under Settings → Core plugins → Bases. Then create a base — either a standalone .base file or one embedded inside a note. A base gathers notes (you set a filter, like "notes with the property type: book"), shows their properties as columns, and lets you sort, filter, and add formula columns from a point-and-click UI. Because it reads the same frontmatter properties you met in Lesson 2.3, any structure you've already added to your notes shows up instantly — no query to write.

🎯 Project: Build a Dashboard

Time to make Dataview real in your vault. You'll tag a few notes, then build a single dashboard note with two live queries that update themselves as your vault grows.

# 📊 Dashboard

## 📚 My Books
```dataview
TABLE status AS "Status", rating AS "★"
FROM #book
SORT rating DESC
```

## 🕒 Recently Edited
```dataview
TABLE file.folder AS "Folder", file.mtime AS "Last edited"
SORT file.mtime DESC
LIMIT 5
```

📓 Learning Journal

📝 Lesson Summary

🎉 What You've Accomplished

You've learned to think about your vault as data — and you built a real, self-updating dashboard from notes you already had. That's a genuine superpower: the more you write, the more your queries surface for you, with zero extra maintenance. Most people never get here. You just did.

❓ Common Questions at This Stage

🔭 Looking Ahead

You've been adding fields and tags to notes by hand. In the next lesson we automate the creation of well-structured notes with Templater and Templates — so every new book note, meeting note, or daily note starts life with exactly the frontmatter your Dataview queries expect. Dataview and Templater are a legendary duo.

✅ Before the Next Lesson

• Keep your Dashboard note — you'll enrich it as your vault grows
• Try one more query of your own invention (even a small one)
• Notice which fields you keep typing by hand — those are template candidates
• Write your Learning Journal entry for this lesson

📚 Additional Resources

• Dataview official documentation
• Dataview — Query types reference
• Obsidian Help — Properties (frontmatter)