Obsidianguide   ›   Obsidian effektiv nutzen   ›   Eigenschaften auswerten mit Dataview

Eigenschaften auswerten mit Dataview

Mit Vorlagen und der Erweiterung QuickAdd hast du deinen Vault bereits mit strukturierten Notiz-Eigenschaften, auch Metadaten genannt, angereichert. Das ist ein wichtiger erster Schritt, um den Inhalt deines Vaults systematisch auswerten und durchsuchen zu können.

Hier kommen zwei mächtige Erweiterungen ins Spiel: Dataview und Obsidian Bases.

Sie verwandeln deine Notizen in eine persönliche Datenbank und ermöglichen es dir, gezielte Fragen an dein Wissen zu stellen. Zum Beispiel:

  • Welche Restaurants habe ich besucht und würde ich wieder besuchen?
  • Welchen Riesling habe ich zuletzt getrunken – und wie habe ich ihn bewertet?
  • Welche Städte, zu denen ich schon Notizen gemacht habe, habe ich noch nicht besucht?

In einem kleinen Beispiel-Vault mag das noch unspektakulär wirken. Doch je größer die Notizsammlung wird, desto wertvoller sind solche automatisierten Übersichten. Du sparst Zeit, behältst den Überblick und nutzt deine Daten aktiv.

Beide Erweiterungen verwandeln deine Vault in eine Datenbank, die du mit einfachen Abfragen durchsuchen kannst. Dataview ist dabei sehr mächtig und lange Zeit die dominierende Lösung gewesen. Das Obsidian-Team hat die Idee nun aufgegriffen und bietet mit Bases eine eigene Erweiterung an, die jedoch einen anderen Einstieg verfolgt. Im Moment (Sommer 2025) befindet sich Bases noch im Beta-Test. Deshalb beginne ich mit Dataview und beschränke mich an dieser Stelle auf die Grundfunktionen. Die weiteren Möglichkeiten, wie die Verwendung von Inline-Abfragen oder JavaScript, werde ich in einem späteren Kapitel behandeln. Ein Kapitel zu Bases werde ich auch zu einem späteren Zeitpunkt einfügen.

Damit du die Beispiele in diesem Kapitel nachvollziehen kannst, stelle ich dir den aktuellen Stand des kleinen Beispiel-Vaults hier zur Verfügung. Du kannst natürlich auch deinen eigenen Vault verwenden – musst dann allerdings die Beispiele entsprechend anpassen.

Du kannst übrigens problemlos mit mehreren Vaults gleichzeitig arbeiten.

Lade den Beispiel-Vault von hier herunter, entpacke die ZIP-Datei in ein lokales Verzeichnis und bestätige beim Öffnen, dass du den Einstellungen vertraust. Dann kann es losgehen.

#Dataview: Installation und Einführung

#Dataview installieren

Die Dataview-Erweiterung ist eine externe Erweiterung, die zunächst installiert werden muss. Öffne dazu die Obsidian-Einstellungen, wähle die Option „Externe Erweiterungen“ (1) und klicke rechts auf den Button „Durchsuchen“ (2).

Gib im Suchfeld (1) „data“ ein, dann sollte die Kachel für die „Dataview“-Erweiterung (2) direkt angezeigt werden.

Klicke im folgenden Dialog auf „Installieren“, nachdem du natürlich vorher den Text gelesen hast. Anschließend wird die Erweiterung aktiviert – und damit bist du fertig.

In den Optionen der Erweiterung kannst du aktuell das Datums- (1) und das Datums-+Zeit-Format (2) anpassen sowie die Begriffe (3) und (4) für die Tabellenüberschriften übersetzen. Die anderen Einstellungen solltest du vorerst nicht ändern.

Dass das Zeitformat an dieser Stelle problemlos angepasst werden kann, liegt daran, dass es sich hierbei nur um die Darstellung der Zeit handelt. Intern arbeitet Dataview weiterhin mit dem amerikanischen Zeitformat (ISO 8601), also dem Format yyyy-MM-ddTHH:mm:ssZ.

Damit ist die Installation der Dataview-Erweiterung abgeschlossen und du bist bereit, deine ersten Abfragen zu erstellen. Im Folgenden erkläre ich dir den grundlegenden Aufbau und die Syntax von Dataview-Abfragen, damit du deine Notizen gezielt auswerten kannst. Danach wirst du einige Beispiel-Abfragen definieren und kannst auch selbst experimentieren, um ein Gefühl für die Möglichkeiten zu bekommen.

#Erster Schritt: Erstellung einer Testumgebung

Ich gebe in den folgenden Abschnitten einen Überblick der einzelnen Abfrage-Parameter. Probiere die Beispiele aus. Nutze dazu eine Ansicht in Obsidian, in der du die gleiche Notiz links im Quellcode anzeigst und rechts im Lese-Modus:

  1. Öffne die Beispiels-Vault
  2. Erstelle eine neue Notiz, z.B. mit dem Namen „Dataview Test“
  3. Öffne nun auf dem Tab der neuen Notiz das Kontext-Menü aka „rechte Maustaste“ und wähle „Rechts teilen“ aus
  4. Schalte nun die Ansicht in der linken Tab auch „Quellcode“ um und den rechten Tab auf die „Lese-Ansicht“
  5. Lösche das Frontmatter im Quellcode, damit du etwas mehr siehst.
  6. Wenn du nicht so viel Bildschirmplatz hast, kannst du auch das rechte und linke Side-Panel einklappen.

Nun sollte dein Obsidian Fenster etwas so aussehen:

#Dataview-Abfragen: Aufbau und Beispiele

Dataview Abfragen werden in einem Code-Block definiert und folgen einem bestimmten Schema:

```dataview
<Darstellungs-TYP> <Felder oder Ausdruck>
FROM <Datenquelle>
WHERE <Filter-Bedingung>
GROUP BY <Gruppierungskriterium>
FLATTEN <Listen-Feld>
SORT <Sortierregel>
LIMIT <Maximale Anzahl>
```

Der Darstellungs-Typ definiert, wie die Ergebnisse angezeigt werden. Du kannst zwischen LISTE, TABLE und CALENDAR wählen. Dabei verweisen die Ergebnisse immer auf Notizen. Ein weiterer Typ ist der TASK, der zuerst auf in Notizen vorkommende Checkboxen verweist, wobei du das z.B. auf alle ausgewählten beschränken kannst, also auf alle erledigten Aufgaben. Der Darstellungs-Typ muss angegeben werden, alle weiteren Optionen und Argumente sind optional.

Mit den Argumenten Felder oder Ausdruck nach dem Darstellungs-Typ kannst du z.B. definieren, welche Eigenschaften als Spalten in der Tabelle für einen Eintrag angezeigt werden sollen. Wobei auch etwas komplexere Ausdrücke möglich sind:

```dataview
TABLE notizen_typ AS "Typ", bewertung * 2 AS "Punkte"

Bei diesem Aufruf wird eine Tabelle mit allen Notizen erstellt. Die erste Spalte zeigt den Namen und Link zu der Notiz, die zweite, welcher Wert an der Eigenschaft notizen_typ angegeben wurde, das AS definiert den Namen dieser Spalte, in der nächsten Spalte werden die bewertung mit 2 multipliziert und in der Spalte Punkte angezeigt.

Hier noch ein Beispiel für den Darstellungs-Typ Liste:

LIST file.path + " (Geändert: " + string(file.mday) + ")"

Bei der Liste kannst du nur eine Eigenschaft zusätzlich angeben, allerdings kannst du, wie in diesem Beispiel gezeigt, diese Attribute aus verschiedenen Attributen zusammensetzen. Hier wird eine Art von Eigenschaften genutzt, die du nicht selbst definiert hast, sondern sogenannte Notiz-Eigenschaften, die einer Notiz automatisch zugordnet werden, wie hier file.path, in dem der relative Pfad zum Obsidian-Wurzelverzeichnis abgelegt ist, und das file.mday, das das Datum angibt, wann die Notiz das letzte Mal modifiziert wurde. Das Ganze wird dann als String ausgegeben:

#Der FROM Abfrage-Parameter

Der Abfrage-Parameter FROM schränkt das Ergebnis ein. So wird der folgende Aufruf nur Notizen aus dem Ordner „02 Restaurants“ anzeigen. Außerdem zeigt dieser Aufruf, dass du die Möglichkeit hast, die Werte für die Anzeige in der Tabelle zu manipulieren. Hier habe ich eine arithmetische Funktion gewählt. Du könntest aber auch z.B. zusätzlichen Text angeben, etwa bewertung + " Punkte".

```dataview
TABLE notizen_typ AS "Typ", bewertung * 2 AS "Punkte"
FROM "02 Restaurants"
```

Oder hier werden nur Notizen in der Tabelle angezeigt, die mit dem Tag #speyer versehen sind.

```dataview
TABLE notizen_typ AS "Typ", bewertung * 2 AS "Punkte"
FROM #speyer
```

Die nächste Einschränkung zeigt nur die Notizen, die einen Link zu der Notiz „Speyer“ enthalten und mit der Eigenschaft bewertung versehen sind.

```dataview
TABLE notizen_typ AS "Typ", bewertung * 2 AS "Punkte"
FROM [[Speyer]]
```

#WHERE: Filterbedingungen definieren

Während der FROM-Abfrageparameter die Abfrage auf einen bestimmten Bereich einschränkt, also auf alle Notizen, die im Ordner XY liegen oder die mit einem bestimmten Tag ausgezeichnet sind, schränkt der WHERE-Parameter die Notizen eher inhaltlich ein.

```dataview
TABLE besucht AS "Besucht"
FROM "03 Städte"
WHERE besucht = true
```

Mit dieser Abfrage werden alle Notizen im Ordner „03 Städte“ (FROM) angezeigt, in denen die Eigenschaft besucht angekreuzt ist. Diese Eigenschaft ist als „Checkbox“ definiert und gibt als Wert „true“ oder „false“ zurück. Da in diesem Beispiel die WHERE-Bedingung recht eindeutig ist, könnte die Abfrage auch so erfolgen:

```dataview
TABLE "Ja" AS "Besucht"
FROM "03 Städte"
WHERE besucht = true
```

In diesem Fall wird die Spalte „Besucht“ nicht aus mit dem Wert der Eigenschaft besucht gefüllt, sondern einfach mit einem „Ja“ belegt. Wenn du die WHERE-Zeile löschst, würden alle Städte-Notizen in der Tabelle erscheinen, aber mit einem „Ja“ in der Besucht-Spalte.

Für die WHERE Abfragen sind weitere Bedingungen möglich, wie z.B. Vergleichsoperatoren:

Ausdruck Bedeutung Beispiel
= gleich status = "offen"
!= ungleich rating != 5
> größer rating > 3
< kleiner created < date(2024-01-01)
>=, <= größer/kleiner gleich importance >= 2

Spezielle Funktionen und Ausdrücke

Hier noch eine Übersicht über weitere Möglichkeiten, die in der WHEREBedingung verwendet werden können:

Funktion Beschreibung Beispiel
contains(list, x) prüft, ob x in einer Liste (z. B. Tags) enthalten ist contains(tags, "#lesen")
regexmatch(re, x) prüft, ob x einem RegEx-Ausdruck entspricht regexmatch("^Sp", file.name)
length(list) gibt die Länge einer Liste zurück length(tags) > 2
date(...) konvertiert einen String zu einem Datum created < date(2025-07-01)
type(x) liefert den Typ eines Felds (string, number, list, etc.) type(rating) = "number"

Mit der date-Funktion können so auch zeitbezogene Bedingungen definiert werden, wie:

WHERE date(today) - file.mtime < dur(7 days)

Durch diese Bedingung werden nur die Notizen anzeigt, die in den letzten 7 Tagen geändert wurden.

Bedingungen können auch mit logischen Operatoren verknüpft werden, wodurch dann komplexe Abfragen erstellt werden können.

Ausdruck Bedeutung Beispiel
AND und status = "offen" AND done = false
OR oder status = "offen" OR status = "geplant"
! nicht !done oder !(rating > 3)

#GROUP BY

Wenn du in dem Beispiels-Vault eine Übersicht aller Notizen gruppiert nach dem notizen_typ ausgeben möchtest, kannst du die GROUP BY-Abfrage nutzen. Der Dataview-Aufruf könnte dann etwa so aussehen:

```dataview
TABLE rows.file.link AS "Notizen", rows.file.path AS Pfad
WHERE !contains(file.path, "98 Vorlagen")
GROUP BY notizen_typ AS Notizen-Typ
```

Der oben gezeigte Dataview-Ausdruck weist einige, teils optionale, Besonderheiten auf. Die generierte Tabelle enthält eine Zeile pro Wert im Feld notizen_typ, z. B. ort. Da es nun mehrere Notizen im Vault gibt, die ort als Eigenschaft haben, die aber alle in der gleichen Tabellenzeile in einer Zelle angezeigt werden müssen, wird mit dem Aufruf durch rows.file.link eine Liste der Notizen erstellt, die in einer Tabellenzelle angezeigt werden können. Das gleiche gilt für den Pfad der Notiz, der ebenso als rows.file.path eingebunden wurde.

Die WHERE-Klausel nutzt !contains(file.path, "98 Vorlagen"), um Notizen auszuschließen, deren Pfad den angegebenen Ordnernamen enthält. Das vorangestellte Ausrufezeichen ! negiert die Bedingung – es handelt sich um eine logische NICHT-Verknüpfung. So werden die Notizen im Ordner 98 Vorlagennicht in der Tabelle angezeigt.

Mit dem Ausdruck GROUP BY notizen_typ wird schließlich die Gruppierung definiert: Alle Notizen mit einem identischen Wert im Feld notizen_typ werden dadurch zu einer Gruppe zusammengefasst und gemeinsam in einer Zeile dargestellt.

#FLATTEN: Listen auflösen für Sortierung

Wenn du z.B. einen Dataview-Aufruf wie diesen ausführst:

```dataview
TABLE tags
SORT file.name
```

Wird je Tabellenzeile eine Notiz in der zweiten Spalte alle definierten Tags als Liste in der Tabellenzelle angezeigt:

Falls du aber die Ausgabe nach den Tags sortieren möchtest, würde das so nicht funktionieren. Dazu müsste die entsprechende Notiz für jeden Tag in einer eigenen Zeile aufgeführt werden. Genau dafür dient der Ausdruck FLATTEN. Er sorgt dafür, dass für jedes Tag eine eigene Ergebniszeile erstellt wird, nach der dann auch sortiert werden kann.

```dataview
TABLE tags
FLATTEN tags
sort tags
```

Das kannst du im obigen Beispiel sehr schön am Beispiel Brügge sehen.

#SORT & LIMIT: Sortieren und Begrenzen

Den Ausdruck SORT habe ich gerade schon verwendet. Er dient, wie der Name schon sagt, der Sortierung der Tabelle oder Liste. Dabei wird zwischen der aufsteigenden Sortierung (ASC) und der absteigenden (DESC) unterschieden. Das Kriterium kann eine Eigenschaft aus dem Frontmatter sein, die auch in der Tabelle angezeigt wird, oder eine andere, wie z. B. das Datum der letzten Änderung file.mday die du nicht für die Darstellung in der Tabelle oder Liste definiert hast.

LIMIT limitiert die Anzahl der Tabellen- oder Listeneinträge. Es lässt sich in Verbindung mit einer Eigenschaft wie Rating z. B. für eine Top-N-Liste nutzen.

#CALENDAR: Kalenderansicht nutzen

In den Beispielen habe ich mich bisher auf die Listen- und Tabellen-Darstellung beschränkt. Es gibt jedoch, wie erwähnt, noch den Darstellungs-Typ CALENDAR und TASK.

Der Ausdruck CALENDAR zeigt die gefundenen Notizen nicht als Zeile mit allen Informationen, sondern nur als kleine Punkte unterhalb des Tages in einem Kalenderblatt an. Diese Punkte sind anklickbar. Pro Notiz, die mit der Abfrage übereinstimmt, wird ein Punkt dargestellt. Im Bild unten siehst du, dass am 1.6. und am 11.6.2025 ein Restaurantbesuch stattfand.

Die Funktionalität der Kalenderdarstellung ist sehr rudimentär, daher gibt es viele externe Erweiterungen, die Kalenderdarstellungen mit mehr Funktionen ermöglichen. Im Zusammenspiel mit den täglichen Notizen werde ich in kurz auf eine Kalender-Erweiterung eingehen.

#TASK

Tasks, also Aufgaben, werden in Obsidian in Markdown als Checkboxen definiert. Dazu verwendest du die Markdown-Auszeichnung - [ ] für offene Aufgaben oder - [x] für erledigte Aufgaben. Es ist wichtig, dass diese Auszeichnungen am Anfang einer Zeile stehen, sonst werden sie nicht als Checkbox dargestellt und somit nicht als Aufgabe interpretiert.

Eine einfache Abfrage listet alle so definierten Aufgaben auf:

```dataview
TASK 
```

Wenn du nur die offenen Aufgaben sehen möchtest, dann muss du die Abfrage entsprechend einschränken:

```dataview
TASK 
WHERE !completed
```

Wenn du auch noch sehen möchtest, in welchen Notizen die Aufgaben definiert sind, hilft dieser Aufruf:

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

Du kannst auch weitere Abfrageparameter nutzen und z.B. die Abfrage auf einen bestimmten Ordner beschränken, die Liste nach dem Alter der Notiz sortieren oder auf eine bestimmte Anzahl von Einträgen limitieren. Wie bei all den vorgestellten Dataview-Aufrufen kann auch der Task-Aufruf komplex sein.

Da Obsidian auch gerne zum Task-Management genutzt wird, finden sich auch zu diesem Thema eine Vielzahl von externen Erweiterungen, von denen ich eine später vorstellen möchte. Für einen einfachen Überblick reicht oft eine Dataview-Abfrage aus.

#Fazit und nächste Schritte

Mit diesem Rüstzeug kannst du bereits viele interessante Abfragen erstellen. Eine wichtige Anwendung der Dataview-Erweiterung ist die automatische Erstellung von MOCs (Maps of Content), die du bisher nur manuell anlegen konntest, jetzt aber ganz einfach mit einem Dataview-Aufruf erzeugen kannst.

```dataview
list notizen_typ
WHERE contains(tags, "Speyer")
```

Dieser Aufruf listet alle Notizen mit dem Tag Speyer auf und könnte so in einer Notiz mit dem Namen „Alles über Speyer“ stehen. So kannst du Abfragen definieren, die flexiblere Sammlungen von Notizen erzeugen, als es durch einfaches Sortieren in Ordnern möglich wäre.

Im nächsten Kapitel gehe ich nochmals auf das Thema Vorlagen ein und zeige dir anhand der täglichen Notizen, wie du schon bei der Erstellung von Notizen automatisch aktuelle Informationen hinzufügen kannst.