Get AI summaries of any video or article — Sign up free
Build Powerful Workflows With Logseq Queries thumbnail

Build Powerful Workflows With Logseq Queries

Logseq·
5 min read

Based on Logseq's video on YouTube. If you like this content, support the original creators by watching, liking and subscribing to their content.

TL;DR

Properties only apply to the specific block they’re attached to, so queries that rely on properties across branches can fail.

Briefing

Logseq queries can turn a messy note collection into practical “data tables” and dashboards—if links and properties are used correctly. The core lesson is that property-based filtering is powerful, but properties behave differently from links across branches, so building reliable workflows often requires converting property values into links (using square brackets) when the goal is to filter other parts of the graph.

Early in the session, the discussion zeroes in on a common failure mode: combining filters with AND. A query that requires two properties will only return blocks that have both properties on the same block. That’s because properties don’t “flow” across branches the way links do. The workaround is to make property values into links—e.g., wrapping an author value like Carol DW in square brackets—so the link tagging applies to the entire branch under a parent block. With that change, downstream queries can filter by those linked values, enabling dynamic indexes such as “all notes tagged with David Perel” to appear consistently across the graph.

Date handling is another practical constraint. Dates are treated as properties, and a created-at property exists for pages created in Logseq, but it’s not automatically added to blocks. For workflows that rely on time-based review—like using the between filter to surface todos within a date range—this distinction matters. The session also flags performance tradeoffs: turning on block timestamps can degrade query and search performance, so most workflows rely on journal pages, where blocks written on a journal page inherit that date context.

From there, the session lays out a week-long progression of five use cases that build on one another. It starts with a generic index of notes, then moves to a content consumption pipeline (saving items to consume later, templating, and viewing them in multiple passes). Wednesday shifts toward content creation—turning highlights and notes into insights and using query-driven review collections. Thursday focuses on project management, combining notes and action items, using date-based review queries to find finished work and overdue tasks. The final step ties everything into a Personal Learning System that treats learning as an input→sensemaking→output loop.

The day’s hands-on challenge (Challenge 1) focuses on building a dynamic notes index. The live walkthrough targets the David Perel page: a query macro is created using the author property, producing a table view where columns can be toggled (block titles, property fields like author and status). A key technique appears in the details: links are created from property values so that the tagging applies to the whole branch, making it possible to filter other pages (like an Audience Building page) based on those values.

The session ends with practical guidance for troubleshooting: if new links or properties don’t show up in queries, reindex Logseq so the database refreshes link references. Questions about advanced wildcard behavior are deferred to Data Log, keeping the focus on Logseq’s simpler query language for this course week.

Cornell Notes

The session centers on building reliable Logseq workflows with queries by understanding the difference between links and properties. Properties filter only the block they’re attached to, which can break queries that expect values to apply across branches. A workaround is to convert property values into links (e.g., wrapping values in square brackets) so the link tagging applies to the entire branch under a parent block. The week then scales from a dynamic notes index into content pipelines, content creation, project management dashboards, and a Personal Learning System. Date-based workflows rely on how Logseq stores dates as properties and often on journal pages, while block timestamps can hurt performance.

Why can an AND-based query fail when properties seem correct at first glance?

An AND filter requires both properties to exist on the same block for that block to appear in results. Properties don’t “look across branches,” so a property attached to one block won’t satisfy an AND condition for sibling/child blocks elsewhere in the branch. The fix is to restructure tagging so the needed values are available where the query expects them—often by using links that apply to the whole branch.

How does converting property values into links change query behavior?

When property values are turned into links using square brackets, those links inherit branch-level tagging. In the David Perel example, making values like author/status into links under a parent block causes the entire branch to be tagged with those linked values. That enables other queries to filter by those values as normal link references, not just by the original property on a single block.

What’s the practical limitation of date properties for block-level workflows?

Created-at is generated when a page is created, but it’s not automatically added to blocks. That means block-level date filtering may not work as expected unless the workflow uses a date source that applies to blocks (commonly journal pages) or uses another identifier strategy. For date-range review, the between filter becomes useful once the date values are present in the right place.

Why are block timestamps described as a performance risk?

Enabling block timestamps previously degraded performance, including query performance and search performance. The session suggests most people avoid this by using journal pages, where blocks written on those pages are automatically associated with the journal date context.

What does the live walkthrough demonstrate about property queries?

Creating a query based on a property (like author = David Perel) produces a table view that behaves like a custom data table. Columns can be adjusted to show block titles and selected properties (author, status). The walkthrough then shows that link-based tagging derived from property values makes it possible to filter other pages using those values as link references.

Review Questions

  1. In what situation would a property-based AND filter return no results even though the graph contains the needed values somewhere nearby?
  2. What is the difference between property-based filtering and link-based filtering across branches, and how does square-bracket link conversion address it?
  3. How do journal pages and created-at properties differ when building date-driven queries with between filters?

Key Points

  1. 1

    Properties only apply to the specific block they’re attached to, so queries that rely on properties across branches can fail.

  2. 2

    Links propagate through branches under a parent block, making them more suitable for branch-wide tagging and filtering.

  3. 3

    Converting property values into links (using square brackets) is a practical workaround when branch-level filtering is required.

  4. 4

    Date workflows depend on where date values actually exist (often journal pages vs. created-at on pages), which affects whether between filters work.

  5. 5

    Block timestamps can hurt query and search performance, so journal-page tagging is often the safer default.

  6. 6

    After adding new links or properties, reindex Logseq so queries can see updated references.

  7. 7

    The week’s structure builds from a dynamic notes index into consumption pipelines, content creation, project management dashboards, and a Personal Learning System.

Highlights

Properties don’t behave like links across branches; an AND filter can fail because properties don’t “carry” to other blocks.
Turning property values into square-bracket links makes branch-level tagging possible, enabling dynamic indexes.
Date handling is property-driven: created-at exists for pages but not automatically for blocks, so journal-page workflows are often more reliable.
Block timestamps can degrade performance, pushing many users toward journal pages for date context.
Reindexing is the go-to fix when newly added links or properties don’t appear in query results.

Topics

  • Logseq Queries
  • Properties vs Links
  • Dynamic Notes Index
  • Date Filtering
  • Project Management Dashboards