Datacore

Datacore is a successor to the Dataview plugin designed to index vault information for searching and compiling into views. It provides several key improvements over the original Dataview:

• Performance: Up to 100x faster due to an optimized index design.
• Granularity: Supports querying at the section, block, line, and canvas item levels.
• Advanced API: Features a powerful JavaScript/TypeScript API, including React and JSX support for creating complex, live-updating views.
• Code Reuse: Supports importing code files and using JSX/TypeScript directly.
• Enhanced View Features: All views include built-in support for paging and embedding complex components within other components.

The childof() function produces all children of the objects matched by an input query.

• childof(query): Exclusive. Returns only the children of the matching objects.
• subtree(query): Inclusive. Returns both the children and the original matching objects.

Example:

// Return all sections, blocks, etc that are children of markdown pages.
childof(@page)

// Return page objects and all of the sections, blocks, etc in them.
subtree(@page)

Datacore functions can be used in expressions using two different styles:

1. Standard Function Calling: Pass arguments directly to the function name. func(arg1, arg2)

2. Postfix Calling Style: Chain functions onto an object. The object becomes the implicit first argument. object.func(arg1) is equivalent to func(object, arg1).

Vectorization: Functions support vectorization. If you pass a list as an argument instead of a single value, the function will return a list of results instead of a single value.

Example of vectorization with postfix style:

["YES", "NO"].lower() // -> ["yes", "no"]

lower("YES")  // -> "yes"
"YES".lower() // Same as lower("YES")
["YES", "NO"].lower() // vectorization + postfix calling style.

Datacore supports several ways to define and query metadata, moving towards native Obsidian metadata patterns while maintaining backward compatibility:

• Inline YAML: Place YAML objects anywhere in a document and mark them inline to add metadata to a page or section.
• Inline Objects: Define YAML codeblocks as "objects" (e.g., an "exercise" object) which are searchable independently of the page they reside on.
• Sections: Individual sections within markdown files can be treated as objects and are directly queryable.
• Tasks: Tasks are directly queryable and support metadata via the Tasks plugin emoji or inline fields.

The Datacore index is hierarchical. You can traverse this hierarchy using relationship fields:

• Top-down: A page object contains a list of its sections in the $sections field.
• Bottom-up: Any child object (like a section or block) can find its parent using the $parent field.

Datacore tracks sections in markdown files and canvases, which can be queried using the @section type. Each section contains built-in metadata fields such as $ordinal, $title, $level, $position, and $tags.

Accessing Inline Fields

Inline fields defined within a section can be accessed in two ways:

1. In queries and expressions: Reference the field name directly.
2. In JavaScript: Use the .value() method on the section object.

Note that inline field access is case-insensitive.

In addition to standard numeric indexing (e.g., array[0]), DataArray supports "swizzling". If you index into a DataArray using a field name (e.g., array.fieldName), it automatically maps every element in the array to that field. If the field itself is an array, the result is automatically flattened.

This is equivalent to calling .to("fieldName").

const data = dc.array(dc.query("#books and @page"));

data.$name // => List of all book names.
data.$ctime // => List of all book created times.

Datacore distinguishes between a list-block (the container) and individual list-items (the elements within).

List Blocks (list-block)

Used to query the entire list structure. They contain a $elements field which is a list of the items within.

List Items (list-item)

Individual items or tasks. They can be queried via @list-item.

Key List Item fields:

• $type: Either task or list.
• $line / $lineCount: The starting line number and total line count.
• $text: The full text of the item including markup.
• $cleantext: The text with indentation, inline fields, and IDs removed.
• $parentLine: The line number of the parent item (negative for top-level items).
• $symbol: The marker used (e.g., -, *, 1.).
• $elements: A list of sub-items under this item.