Skip to content

Expressions

Dataview query language expressions are anything that yields a value - all fields are expressions, as are literal values (like 6), as are computed values (like field - 9). For a very high level summary:

# Literals
1                   (number)
true/false          (boolean)
"text"              (text)
date(2021-04-18)    (date)
dur(1 day)          (duration)
[[Link]]            (link)
[1, 2, 3]           (list)
{ a: 1, b: 2 }      (object)

# Lambdas
(x1, x2) => ...     (lambda)

# References
field               (directly refer to a field)
simple-field        (refer to fields with spaces/punctuation in them like "Simple Field!")
a.b                 (if a is an object, retrieve field named 'b')
a[expr]             (if a is an object or array, retrieve field with name specified by expression 'expr')
f(a, b, ...)        (call a function called `f` on arguments a, b, ...)

# Arithmetic
a + b               (addition)
a - b               (subtraction)
a * b               (multiplication)
a / b               (division)
a % b               (modulo / remainder of division)

# Comparison
a > b               (check if a is greater than b)
a < b               (check if a is less than b)
a = b               (check if a equals b)
a != b              (check if a does not equal b)
a <= b              (check if a is less than or equal to b)
a >= b              (check if a is greater than or equal to b)

# Special Operations
[[Link]].value      (fetch `value` from page `Link`)

More detailed explanations of each follow.

Expression Types

Fields as Expressions

The simplest expression is one that just directly refers to a field. If you have a field called "field", then you can refer to it directly by name - field. If the field name has spaces, punctuation, or other non-letter/number characters, then you can refer to it using Dataview's simplified name, which is all lower case with spaces replaced with "-". For example, this is a field becomes this-is-a-field; Hello! becomes hello, and so on.

Literals

Constant values - things like 1 or "hello" or date(som) ("start of month"). There are literals for each data type that dataview supports; you can see the reference above for examples of what each literal type looks like.

Arithmetic

You can use standard arithmetic operators to combine fields: addition (+), subtraction (-), multiplication (*), and division (/). For example field1 + field2 is an expression which computes the sum of the two fields.

Comparisons

You can compare most values using the various comparison operators: <, >, <=, >=, =, !=. This yields a boolean true or false value which can be used in WHERE blocks in queries.

Array/Object Indexing

You can retrieve data from arrays via the index operator array[<index>], where <index> is any computed expression. Arrays are 0-indexed, so the first element is index 0, the second element is index 1, and so on. For example list(1, 2, 3)[0] = 1.

A similar notation style works for objects. You can use field["nestedfield"] to reference fields inside an object or otherwise similarly nested. For example, in the YAML defined below, we can reference previous via episode_metadata["previous"].

---
current_episode: "S01E03"
episode_metadata:
  previous: "S01E02"
  next: "S01E04"
---

You can also retrieve data from objects (which map text to data values) also using the index operator, where indexes are now strings/text instead of numbers. You can also use the shorthand object.<name>, where <name> is the name of the value to retrieve. For the previous frontmatter example, we could also use episode_metadata.previous to obtain the same value.

Index expressions also work on objects which have fields that are not directly supported by the query language. A good example is where, since it is a keyword. If your frontmatter/metadata contains a field where, you can reference it via the row syntax: row["where"]. See the note in the FAQ and the corresponding issue for further information.

Function Calls

Dataview supports various functions for manipulating data, which are described in full in the functions documentation. They have the general syntax function(arg1, arg2, ...) - i.e., lower("yes") or regexmatch("text", ".+").

Lambdas

Lambdas are advanced literals which let you define a function that takes some number of inputs, and produces an output. They have the general form:

(arg1, arg2, arg3, ...) => <expression using args>

Lambdas are used in several advanced operators like reduce and map to allow for complex transformations of data. A few examples:

(x, y) => x + y                 (sum x and y)
(x) => 2 * x                    (double x)
(value) => length(value) = 4    (return true if value is length 4)

Type-specific Interactions & Values

Most dataview types have special interactions with operators, or have additional fields that can be retrieved using the index operator.

Dates

You can retrieve various components of a date via indexing: date.year, date.month, date.day, date.hour, date.minute, date.second, date.week, date.weekyear. You can also add durations to dates to get new dates.

Durations

Durations can be added to each other or to dates. You can retrieve various components of a duration via indexing: duration.years, duration.months, duration.days, duration.hours, duration.minutes, duration.seconds.

You can "index through" a link to get values on the corresponding page. For example [[Link]].value would get the value value from page Link.

Link Indexing in Expressions

If your link is a field that you defined in an inline field or in front-matter, like Key:: [[Link]], then you should index into it by just writing Key.value; Using [[Key]].value would look up the page literally called Key, which is probably not what you want!