Get AI summaries of any video or article — Sign up free
An awesome update to queries thumbnail

An awesome update to queries

CombiningMinds·
5 min read

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

TL;DR

Logseq’s query update can render structured query results as tables, making metadata-heavy entries easier to scan and click through.

Briefing

Logseq’s latest query upgrade turns query results into real tables, making it far easier to scan, filter, and click through structured data stored in daily journals. The practical payoff is immediate: instead of getting a long list of records (or confusing blank rows when the queried property doesn’t exist), users can query a specific property type—like a “tweet” or “article”—and instantly view the results in a tabular layout where linked fields and tags are readable at a glance.

The transcript walks through the difference between a generic query and a property-driven one. When a query returns items that don’t share the relevant Logseq-defined properties, the table view fills with blank rows, which can look broken until the underlying schema is understood. Switching to a property-based query fixes that: querying for a property type such as “tweet” produces a table that includes the linked content and associated metadata. From there, the workflow becomes more useful than scrolling—shift-clicking a row opens the underlying page, and linked URLs can be accessed directly. This same pattern applies to journal content: entries created with a consistent “crumbs” metadata template (type, link, tags, and producer) become a searchable, table-friendly repository.

Books are used as a second example, revealing both the strength and a current limitation of the table output. Querying for “books” returns a clean set of results, but the table may not display the book title in the first column; instead, the first column can show the linked page/block, forcing users to open items to see details. A workaround appears tied to how metadata blocks are ordered: if the properties/metadata crumbs block isn’t positioned first within the book page, some books may not appear consistently in the table results. After adjusting the block order (and refreshing), missing entries return—suggesting the table feature depends on predictable placement of property blocks.

Beyond tables, the transcript highlights two additional query behaviors. First, text search supports quoted phrases (inverted commas) inside the desktop app, enabling precise matching—for example, searching for the word “objective” across the database. Second, indentation matters for hierarchical queries: if related links aren’t indented correctly, a query that expects a parent-child structure may return only the page that matches the correct sibling/child level. Re-indenting the content so the hierarchy aligns with the query’s expectations makes the missing page appear.

Overall, the update shifts queries from “find something” toward “manage and review structured information.” The table output rewards consistent metadata practices, and the indentation and quoted-text rules add precision—while the books example shows that a bit of schema discipline (and sometimes block ordering) is still required for fully seamless results.

Cornell Notes

Logseq’s query update can transform structured query outputs into tables, turning scattered journal entries into a scannable interface. Property-based queries work best: querying a property type (e.g., tweets, articles, books) produces meaningful rows, while querying items lacking those properties leads to blank rows. Book queries reveal a current dependency on how metadata/property blocks are placed—if the properties block isn’t first, some entries may not appear until block order is corrected and the database is refreshed. The transcript also notes two precision features: quoted text search using inverted commas and hierarchy-sensitive querying that depends on correct indentation. Together, these changes make database review faster, but they reward consistent metadata structure.

Why do some query-to-table results show blank rows?

Blank rows appear when the query returns items that don’t have the queried Logseq properties defined. For example, querying “tutorials” yields many records, but the table view looks empty because those pages don’t include the relevant property fields. In contrast, querying something like “work” that uses defined properties (e.g., to-do/done) produces populated table rows.

How does a property-based query improve usability compared with a generic list?

A property-based query (such as querying for the “tweet” property type) returns results in a table format where metadata like tags and linked content are visible in columns. That makes it easier to scan and then shift-click a row to open the underlying page and follow links, instead of scrolling through a long list.

What metadata consistency practices make table queries work well?

The transcript describes using a “crumbs” template in journal entries that includes fields like type, link, tags, and producer. When entries follow that template, the table view can reliably display and link the associated content. Missing fields (like producer on some tweets) may reduce what appears in the table, but the overall table workflow still benefits from consistent property definitions.

What limitation shows up with book queries, and what workaround is suggested?

Book query results may not display the book title in the first column; instead, the first column can show the linked page/block, requiring opening items to see details. Additionally, some books may not appear if the properties/metadata block isn’t positioned first on the page. Reordering the properties block to be first and refreshing the database makes missing entries appear again (e.g., “show your work” returns after the properties block is moved).

How do quoted text and indentation affect query accuracy?

Quoted text (using inverted commas) enables more precise matching in desktop app text queries—for instance, searching for “objective” finds all occurrences. Indentation affects hierarchical matching: if a query expects a page with a specific parent-child structure, improperly indented siblings/children can cause only one page to match. Correcting indentation and refreshing restores the missing page.

Review Questions

  1. What conditions lead to blank rows when converting query outputs into tables, and how can a user diagnose the cause?
  2. How can block ordering on a page affect whether items appear in a property-based table query (using the book example)?
  3. Why might a query return only one page when multiple pages seem to contain the right links, and how does indentation change the result?

Key Points

  1. 1

    Logseq’s query update can render structured query results as tables, making metadata-heavy entries easier to scan and click through.

  2. 2

    Table rows go blank when queried items lack the specific Logseq properties being requested; property-driven queries avoid this confusion.

  3. 3

    Consistent metadata templates (like a “crumbs” block with type, link, tags, and producer) make table outputs more reliable and useful.

  4. 4

    Book queries may show linked blocks rather than titles in the first column, so users may need to open rows to see details.

  5. 5

    Some missing book entries appear to depend on placing the properties/metadata block first on the page; refreshing after reordering restores results.

  6. 6

    Quoted text search using inverted commas supports more precise text matching in desktop app queries.

  7. 7

    Hierarchy-sensitive queries depend on correct indentation; re-indenting content can change which pages match.

Highlights

Turning query outputs into tables changes the workflow from scrolling lists to reviewing structured rows with tags and links visible.
Blank table rows often trace back to missing properties—querying items without the defined property schema yields empty cells.
Book results can be inconsistent when the properties block isn’t positioned first, but reordering plus refresh brings entries back.
Indentation controls hierarchy matching: sibling/child structure determines whether a page qualifies for a query.

Topics