Get AI summaries of any video or article — Sign up free
Logseq Database DB Version - Play Around thumbnail

Logseq Database DB Version - Play Around

Ed Nico·
5 min read

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

TL;DR

DB version adds “classes” (super tags) that let users define typed properties once and apply them across many pages.

Briefing

Logseq’s pre-alpha “DB version” mode adds a more structured way to model data—using “classes” (super tags) with configurable properties—so users can turn scattered notes into consistent, queryable records. The biggest practical shift is that properties like title, author, status, dates, and page counts can be defined once on a class and then applied across many pages, reducing the repetitive template-and-property setup that previously required manual steps for each note.

In the demo, a new graph (“test one”) is created, then the familiar journal page remains largely unchanged: indentation, bullet behavior, and scrolling work as before. The meaningful differences show up when creating and managing structured data. A new “new class” option appears, enabling a super-tag-like workflow where the class can be configured with typed properties (for example, text fields, number fields, checkboxes, and date-like fields). The interface also introduces a “configure” popup when hovering over a class-linked item, letting users edit the property schema tied to that class.

The workflow is demonstrated by creating two classes: one for “books” and one for “author.” The author class is set up so book entries can reference authors as linked objects rather than plain text. When a new book page is created from the journal, applying the “books” class prompts property entry through the configured fields. Selecting an author creates or links an author object, and the author’s name becomes accessible as a linked page. The demo highlights both the power and the learning curve: the first property in the class behaves like the object’s name, making some explicit “title/name” properties feel redundant, and the author/tag behavior can be inconsistent depending on how the author is created.

Once properties exist, the DB version’s query tools become central. A query can pull all pages matching a property condition (e.g., all books by a given author) and display results in a table. The demo shows sorting and filtering improvements compared with older “all pages” views—especially the ability to sort by page name and to navigate large sets more effectively. Still, the interface has rough edges: scrolling in result tables can be limited, navigation sometimes forces exiting and restarting, and the table layout can feel cluttered with system fields like created/updated/tags.

The demo also touches on schema evolution: renaming or deleting properties in the class template updates existing pages in a “safe proof” way. Deleting a property removes it from the template, but existing values may persist in some views, while new pages follow the updated schema. Finally, the demo shows that web-based features like PDF upload and text highlighting/referencing appear to work in this mode, though some highlight types (like an “area highlight”) seem missing or not visible.

Overall, the pre-alpha DB version aims to make Logseq’s data modeling more consistent and scalable: define classes with typed properties, apply them to pages, link objects like authors, and query across the resulting structure—while the UI and edge cases remain under active refinement.

Cornell Notes

Logseq’s DB version (pre-alpha) introduces “classes” that act like super tags with configurable, typed properties. Instead of repeatedly creating templates and manually assigning properties, users can define a books class and an author class once, then apply them to new journal pages to collect structured data (title/name, dates, page counts, status, and linked authors). Hovering reveals a “configure” panel for editing the property schema, and changes propagate across pages in ways that reduce accidental inconsistencies. Query tools then let users filter and display results in tables (e.g., all books by a specific author), with sorting improvements over older “all pages” views. The interface still has rough navigation and table-layout limitations, and some tag/link behavior depends on how objects are created.

What new mechanism replaces (or reduces) the old template-and-property workflow?

The DB version adds “new class,” which behaves like a super tag. A class can be configured with properties of different schema types (e.g., text, number, checkbox, and date-like fields). In the demo, a “books” class and an “author” class are created, then applied to new journal pages so the properties appear as structured fields instead of requiring manual template setup for each page.

How does linking authors work compared with typing plain text?

The author field is configured as an object/list-style property so selecting an author creates or links an author page. When a new book is created and the author property is filled, clicking the author name navigates to the author object (a page). The demo also shows a learning snag: the first configured property effectively acts as the object’s name, making an explicit “title/name” property feel redundant.

What does the “configure” popup change in day-to-day use?

Hovering over a class-linked item brings up “configure,” which opens the property editor for that class. Users can add properties (like title, pages, started date, status, author), change types (e.g., converting a status field into a checkbox), and reorder fields. This centralizes schema management so updates can propagate to existing pages.

How do queries behave, and what improvements are shown?

Queries can filter pages by property conditions (e.g., all books where author equals a specific author). Results can be shown in a table and sorted (the demo emphasizes sorting by page name as a major improvement over older “all pages” views). Limitations remain: navigation can require exiting and restarting, and tables may include cluttered system fields and limited scrolling.

What happens when properties are deleted or renamed in the class template?

Renaming or editing a property updates the schema across pages. Deleting a property removes it from the template, and the demo suggests it’s handled in a “safe proof” way: the property disappears from the template view, but existing data may still appear in some contexts (e.g., values not fully purged from all views). New pages follow the updated schema, while existing pages may retain prior values depending on how the UI renders them.

Which non-database features appear to work in DB version (based on the demo)?

The demo shows web-side functionality like uploading a PDF and creating references by highlighting text, with jumps to the referenced page working as expected. An “area highlight” option appears missing or not visible, suggesting some highlight tools may still be under development or UI-dependent.

Review Questions

  1. How do classes with typed properties change the process of creating structured entries compared with templates in older Logseq setups?
  2. What does the demo suggest about the relationship between the first configured property in a class and the object’s displayed name?
  3. When a property is deleted from a class template, what kinds of inconsistencies or persistence issues might still appear across existing pages and query results?

Key Points

  1. 1

    DB version adds “classes” (super tags) that let users define typed properties once and apply them across many pages.

  2. 2

    A “configure” popup enables editing the property schema tied to a class, including adding fields and changing types (e.g., status to checkbox).

  3. 3

    Linking object properties (like author) creates navigable author pages rather than relying solely on plain-text fields.

  4. 4

    Query tools filter pages by property values and display results in tables, with sorting improvements over older “all pages” views.

  5. 5

    Schema updates propagate through the system, but deleting properties may not fully purge existing values from every view.

  6. 6

    Some UI rough edges remain in pre-alpha: navigation can require restarting, tables can be cluttered, and scrolling/filters may be limited.

  7. 7

    Web-side actions like PDF upload and text highlighting/references appear to work, though certain highlight modes may be missing.

Highlights

The most important shift is structural: “new class” lets users define typed properties (text/number/checkbox/date-like) and apply them to journal-created pages at scale.
Author linking turns a field into a navigable object page, enabling queries like “all books by Ben McIntyre” rather than manual searching.
Sorting and querying improve over older “all pages” behavior, but table navigation and layout still feel unfinished in pre-alpha.
Changing a class schema (adding/renaming/deleting properties) updates templates and new entries, while existing data may persist in some contexts.
PDF upload and text highlighting/references appear to function in this mode, suggesting broader feature parity beyond pure database modeling.

Topics

  • Logseq DB Version
  • Classes and Properties
  • Schema Configuration
  • Object Linking
  • Queries and Sorting