Features

Retrieving data

Filter by conditionsFilter by conditions Narrow the available table rows by applying one or more conditions.table("order").where("status", "open")	check_circle
Conditional operatorsConditional operators Non-exact matching with basic operators such as >, < or !=. Full support also needs matching against a set of values (in) and fuzzy text matching (contains).table("order").where("total", ">=", 100)	check_circle
Server-side sortServer-side sort The server re-arranges the results, respecting each column's data type, ascending or descending, on several columns in a set priority.table("order").sort("total", "desc")	check_circle
Quick searchQuick search A text search across several columns, performed on the server, so it can cover the entire table.table("client").search("smith")	check_circle
CountCount The server can say exactly how many rows remain in the set once the conditions are applied.table("order").where("status", "due").count()	check_circle
Column aggregatesColumn aggregates Aggregate functions applied to a column of a filtered set. The backend supports at least some of them, such as max, avg, median or a string concatenation (group_concat).select().from("order") .expression(avg(ident("total")).alias("avg_total")) .expression(max(ident("total")).alias("max_total"))	check_circle
Random-access pagesRandom-access pages Skip any number of rows in a filtered set without a performance penalty, and request any number of records up to a maximum.select().from("order") .order_by(ident("id"), "asc") .limit(50, 1000)	check_circle
Progressive (cursor) loadProgressive load A fall-back way to paginate: pages are sequential, and the next page can be fetched only after the previous one.	check_circle

Relations

One-to-many relationsOne-to-many relations Only needs a filter by condition whose value comes from a record loaded from another table — in the same data source or a different one.table("client").where("id", "c1").ref("orders")	check_circle
Many-to-many relationsMany-to-many relations A condition can be an expression over another set, such as a subquery or a join. Partial support when the in operator can match against a set of values.table("client").where("country", "UK").ref("orders")	check_circle
Relation aggregationRelation aggregation A column can be defined as an aggregate of a field or expression in a related table, calculated on the server. The classic example is account.balance as the sum of transaction.amount.// invoice.paid: the sum of its payments coalesce( select().value().from("payment") .expression(sum(ident("amount"))) .where(ident("invoice") == parent("id")) .group_all().subquery()[0], 0)	~Partly supported From Rust (Table::with_expression), or as a column of a read-only rhai: / base: table. There is no expr: column in SQL YAML yet.
Arbitrary expressionsArbitrary expressions Per-row operations on the server, over stored values or relation aggregates — for example invoice_line.total as qty * item.price.mul(ident("qty"), ident("price")).alias("total")	~Partly supported From Rust (Table::with_expression), or as a column of a read-only rhai: / base: table. There is no expr: column in SQL YAML yet.
Column from related tableColumn from related table Import a field through a one-to-one relation, such as country_id.name, as a read-only column.columns: client.name: { type: string }	check_circle
Contained record expressionsContained record expressions A condition can iterate over sub-records stored inside a record — invoices whose JSON lines field contains item 123.self.with_condition(#{"lines.item_id": 123})	remove
Relations defined in RhaiRelations defined in Rhai Executes arbitrary code after a row is retrieved from the table, in the context of the entire row — a Rhai lazy: script in YAML, or a Rust closure that can also do I/O.badge: lazy: | if row.vip { "★ " + row.name } else { row.name }	check_circle

Live updates

Record changedRecord changed An open record updates in place when someone else changes it — the source pushes the change, no polling.	remove
Record set changedRecord set changed A filtered grid updates when rows matching its condition change, and a row that stops matching leaves the grid.	remove
Table changedTable changed Any insert, update or delete in the table reaches open grids as it happens.	remove
Related record changedRelated record changed A change in a related table — an invoice_line — reaches the parent's view, such as invoice.total.	remove

Editing data

Add recordsAdd records Create rows from a form dialog. In a filtered view, new rows are filled in to belong to it.table("order") .insert(#{ id: "o10", client: "c3", total: 55 })	check_circle
Update recordsUpdate records Edit rows in a form dialog. A write through a filtered view can never change a row outside it.table("order").patch("o1", #{ status: "paid" })	check_circle
Delete recordsDelete records Remove rows, after a confirmation step, from a grid or a record view.table("order").where("status", "paid").delete("o2")	check_circle
Atomic importAtomic import A CSV or wizard import lands in one transaction: either every new row is stored or none is, and existing rows are left untouched.let paid = table("order").where("status", "paid"); table("archive").import_from(paid)	remove
Bulk modifyBulk modify Change every row of a filtered set in one operation — mark all open orders as shipped — without loading them first.	remove

Custom tables

Tables from custom queriesTables from custom queries A table can be defined by a query instead of a stored table — a Rhai script or a native query — and is read-only.select().from("order") .inner_join("client", "c", expr("c.id = order.client_id"))	check_circle
Table aggregateTable aggregate A table defined through another table — sales grouped by month, built on orders — inheriting its columns and relations.name: category_totals id_column: category_id columns: total_price: { type: int } sqlite: base: product inherit: columns: [category_id] rhai: | base.clear_fields().field("category_id") .expression(expr("SUM(price) AS total_price")) .group_by(expr("category_id"))	check_circle
Server-side actionsServer-side actions An action runs inside the data source, such as a stored procedure or function, instead of in the app.	remove

Misc

Auto-IDAuto-ID When the id column is flagged auto, an insert without an id asks the data source to assign one — auto-increment, a generated record id, an ObjectId — and returns it. Without the flag the app mints a UUIDv7 instead, so retries stay idempotent.# order.yaml columns: id: { type: int, flags: [id, auto] } // Rhai — no id, so the data source makes one let id = table("order") .insert(#{ client: "c2", total: 30 });

check_circle

IdempotencyIdempotency By default, every write can be retried safely: a repeated insert or delete changes nothing, and writes through a filtered view stay inside it. An insert that relies on Auto-ID is the exception — retrying it adds a second row.// run twice: same result table("order") .upsert("o10", #{ client: "c3", total: 60 })

check_circle

What stands out

• One file on disk — no server to run or credentials to manage.
• Related columns become correlated subqueries, so client.name sorts and filters like any column.
• Views built from a Rhai query, or derived from another table with base:, taking arguments from the page.
• JSON columns open as their own editable tables.

Retrieving data

Filter by conditionsFilter by conditions Narrow the available table rows by applying one or more conditions.table("order").where("status", "open")	check_circle
Conditional operatorsConditional operators Non-exact matching with basic operators such as >, < or !=. Full support also needs matching against a set of values (in) and fuzzy text matching (contains).table("order").where("total", ">=", 100)	check_circle
Server-side sortServer-side sort The server re-arranges the results, respecting each column's data type, ascending or descending, on several columns in a set priority.table("order").sort("total", "desc")	check_circle
Quick searchQuick search A text search across several columns, performed on the server, so it can cover the entire table.table("client").search("smith")	check_circle
CountCount The server can say exactly how many rows remain in the set once the conditions are applied.table("order").where("status", "due").count()	check_circle
Column aggregatesColumn aggregates Aggregate functions applied to a column of a filtered set. The backend supports at least some of them, such as max, avg, median or a string concatenation (group_concat).select().from("order") .expression(avg(ident("total")).alias("avg_total")) .expression(max(ident("total")).alias("max_total"))	check_circle
Random-access pagesRandom-access pages Skip any number of rows in a filtered set without a performance penalty, and request any number of records up to a maximum.select().from("order") .order_by(ident("id"), "asc") .limit(50, 1000)	check_circle
Progressive (cursor) loadProgressive load A fall-back way to paginate: pages are sequential, and the next page can be fetched only after the previous one.	check_circle

Relations

One-to-many relationsOne-to-many relations Only needs a filter by condition whose value comes from a record loaded from another table — in the same data source or a different one.table("client").where("id", "c1").ref("orders")	check_circle
Many-to-many relationsMany-to-many relations A condition can be an expression over another set, such as a subquery or a join. Partial support when the in operator can match against a set of values.table("client").where("country", "UK").ref("orders")	check_circle
Relation aggregationRelation aggregation A column can be defined as an aggregate of a field or expression in a related table, calculated on the server. The classic example is account.balance as the sum of transaction.amount.// invoice.paid: the sum of its payments coalesce( select().value().from("payment") .expression(sum(ident("amount"))) .where(ident("invoice") == parent("id")) .group_all().subquery()[0], 0)	~Partly supported From Rust (Table::with_expression), or as a column of a read-only rhai: / base: table. There is no expr: column in SQL YAML yet.
Arbitrary expressionsArbitrary expressions Per-row operations on the server, over stored values or relation aggregates — for example invoice_line.total as qty * item.price.mul(ident("qty"), ident("price")).alias("total")	~Partly supported From Rust (Table::with_expression), or as a column of a read-only rhai: / base: table. There is no expr: column in SQL YAML yet.
Column from related tableColumn from related table Import a field through a one-to-one relation, such as country_id.name, as a read-only column.columns: client.name: { type: string }	check_circle
Contained record expressionsContained record expressions A condition can iterate over sub-records stored inside a record — invoices whose JSON lines field contains item 123.self.with_condition(#{"lines.item_id": 123})	remove
Relations defined in RhaiRelations defined in Rhai Executes arbitrary code after a row is retrieved from the table, in the context of the entire row — a Rhai lazy: script in YAML, or a Rust closure that can also do I/O.badge: lazy: | if row.vip { "★ " + row.name } else { row.name }	check_circle

Live updates

Record changedRecord changed An open record updates in place when someone else changes it — the source pushes the change, no polling.	remove
Record set changedRecord set changed A filtered grid updates when rows matching its condition change, and a row that stops matching leaves the grid.	remove
Table changedTable changed Any insert, update or delete in the table reaches open grids as it happens.	~Partly supported Needs a LISTEN/NOTIFY trigger you install, and the app doesn't switch it on yet. Changes arrive as "re-read the table", without the changed row.
Related record changedRelated record changed A change in a related table — an invoice_line — reaches the parent's view, such as invoice.total.	remove

Editing data

Add recordsAdd records Create rows from a form dialog. In a filtered view, new rows are filled in to belong to it.table("order") .insert(#{ id: "o10", client: "c3", total: 55 })	check_circle
Update recordsUpdate records Edit rows in a form dialog. A write through a filtered view can never change a row outside it.table("order").patch("o1", #{ status: "paid" })	check_circle
Delete recordsDelete records Remove rows, after a confirmation step, from a grid or a record view.table("order").where("status", "paid").delete("o2")	check_circle
Atomic importAtomic import A CSV or wizard import lands in one transaction: either every new row is stored or none is, and existing rows are left untouched.let paid = table("order").where("status", "paid"); table("archive").import_from(paid)	remove
Bulk modifyBulk modify Change every row of a filtered set in one operation — mark all open orders as shipped — without loading them first.	remove

Custom tables

Tables from custom queriesTables from custom queries A table can be defined by a query instead of a stored table — a Rhai script or a native query — and is read-only.select().from("order") .inner_join("client", "c", expr("c.id = order.client_id"))	check_circle
Table aggregateTable aggregate A table defined through another table — sales grouped by month, built on orders — inheriting its columns and relations.name: category_totals id_column: category_id columns: total_price: { type: int } sqlite: base: product inherit: columns: [category_id] rhai: | base.clear_fields().field("category_id") .expression(expr("SUM(price) AS total_price")) .group_by(expr("category_id"))	check_circle
Server-side actionsServer-side actions An action runs inside the data source, such as a stored procedure or function, instead of in the app.	remove

Misc

Auto-IDAuto-ID When the id column is flagged auto, an insert without an id asks the data source to assign one — auto-increment, a generated record id, an ObjectId — and returns it. Without the flag the app mints a UUIDv7 instead, so retries stay idempotent.# order.yaml columns: id: { type: int, flags: [id, auto] } // Rhai — no id, so the data source makes one let id = table("order") .insert(#{ client: "c2", total: 30 });

check_circle

IdempotencyIdempotency By default, every write can be retried safely: a repeated insert or delete changes nothing, and writes through a filtered view stay inside it. An insert that relies on Auto-ID is the exception — retrying it adds a second row.// run twice: same result table("order") .upsert("o10", #{ client: "c3", total: 60 })

check_circle

What stands out

• Related columns become correlated subqueries, so client.name sorts and filters like any column.
• Views built from a Rhai query, or derived from another table with base:, taking arguments from the page.
• JSON columns open as their own editable tables.
• The framework reads live changes from a LISTEN/NOTIFY trigger you install.

Retrieving data

Filter by conditionsFilter by conditions Narrow the available table rows by applying one or more conditions.table("order").where("status", "open")	check_circle
Conditional operatorsConditional operators Non-exact matching with basic operators such as >, < or !=. Full support also needs matching against a set of values (in) and fuzzy text matching (contains).table("order").where("total", ">=", 100)	check_circle
Server-side sortServer-side sort The server re-arranges the results, respecting each column's data type, ascending or descending, on several columns in a set priority.table("order").sort("total", "desc")	check_circle
Quick searchQuick search A text search across several columns, performed on the server, so it can cover the entire table.table("client").search("smith")	check_circle
CountCount The server can say exactly how many rows remain in the set once the conditions are applied.table("order").where("status", "due").count()	check_circle
Column aggregatesColumn aggregates Aggregate functions applied to a column of a filtered set. The backend supports at least some of them, such as max, avg, median or a string concatenation (group_concat).select().from("order") .expression(avg(ident("total")).alias("avg_total")) .expression(max(ident("total")).alias("max_total"))	check_circle
Random-access pagesRandom-access pages Skip any number of rows in a filtered set without a performance penalty, and request any number of records up to a maximum.select().from("order") .order_by(ident("id"), "asc") .limit(50, 1000)	check_circle
Progressive (cursor) loadProgressive load A fall-back way to paginate: pages are sequential, and the next page can be fetched only after the previous one.	check_circle

Relations

One-to-many relationsOne-to-many relations Only needs a filter by condition whose value comes from a record loaded from another table — in the same data source or a different one.table("client").where("id", "c1").ref("orders")	check_circle
Many-to-many relationsMany-to-many relations A condition can be an expression over another set, such as a subquery or a join. Partial support when the in operator can match against a set of values.table("client").where("country", "UK").ref("orders")	check_circle
Relation aggregationRelation aggregation A column can be defined as an aggregate of a field or expression in a related table, calculated on the server. The classic example is account.balance as the sum of transaction.amount.// invoice.paid: the sum of its payments coalesce( select().value().from("payment") .expression(sum(ident("amount"))) .where(ident("invoice") == parent("id")) .group_all().subquery()[0], 0)	~Partly supported From Rust (Table::with_expression), or as a column of a read-only rhai: / base: table. There is no expr: column in SQL YAML yet.
Arbitrary expressionsArbitrary expressions Per-row operations on the server, over stored values or relation aggregates — for example invoice_line.total as qty * item.price.mul(ident("qty"), ident("price")).alias("total")	~Partly supported From Rust (Table::with_expression), or as a column of a read-only rhai: / base: table. There is no expr: column in SQL YAML yet.
Column from related tableColumn from related table Import a field through a one-to-one relation, such as country_id.name, as a read-only column.columns: client.name: { type: string }	check_circle
Contained record expressionsContained record expressions A condition can iterate over sub-records stored inside a record — invoices whose JSON lines field contains item 123.self.with_condition(#{"lines.item_id": 123})	check_circle
Relations defined in RhaiRelations defined in Rhai Executes arbitrary code after a row is retrieved from the table, in the context of the entire row — a Rhai lazy: script in YAML, or a Rust closure that can also do I/O.badge: lazy: | if row.vip { "★ " + row.name } else { row.name }	check_circle

Live updates

Record changedRecord changed An open record updates in place when someone else changes it — the source pushes the change, no polling.	remove
Record set changedRecord set changed A filtered grid updates when rows matching its condition change, and a row that stops matching leaves the grid.	remove
Table changedTable changed Any insert, update or delete in the table reaches open grids as it happens.	remove
Related record changedRelated record changed A change in a related table — an invoice_line — reaches the parent's view, such as invoice.total.	remove

Editing data

Add recordsAdd records Create rows from a form dialog. In a filtered view, new rows are filled in to belong to it.table("order") .insert(#{ id: "o10", client: "c3", total: 55 })	check_circle
Update recordsUpdate records Edit rows in a form dialog. A write through a filtered view can never change a row outside it.table("order").patch("o1", #{ status: "paid" })	check_circle
Delete recordsDelete records Remove rows, after a confirmation step, from a grid or a record view.table("order").where("status", "paid").delete("o2")	check_circle
Atomic importAtomic import A CSV or wizard import lands in one transaction: either every new row is stored or none is, and existing rows are left untouched.let paid = table("order").where("status", "paid"); table("archive").import_from(paid)	check_circle
Bulk modifyBulk modify Change every row of a filtered set in one operation — mark all open orders as shipped — without loading them first.	remove

Custom tables

Tables from custom queriesTables from custom queries A table can be defined by a query instead of a stored table — a Rhai script or a native query — and is read-only.select().from("order") .inner_join("client", "c", expr("c.id = order.client_id"))	check_circle
Table aggregateTable aggregate A table defined through another table — sales grouped by month, built on orders — inheriting its columns and relations.name: category_totals id_column: category_id columns: total_price: { type: int } sqlite: base: product inherit: columns: [category_id] rhai: | base.clear_fields().field("category_id") .expression(expr("SUM(price) AS total_price")) .group_by(expr("category_id"))	check_circle
Server-side actionsServer-side actions An action runs inside the data source, such as a stored procedure or function, instead of in the app.	remove

Misc

Auto-IDAuto-ID When the id column is flagged auto, an insert without an id asks the data source to assign one — auto-increment, a generated record id, an ObjectId — and returns it. Without the flag the app mints a UUIDv7 instead, so retries stay idempotent.# order.yaml columns: id: { type: int, flags: [id, auto] } // Rhai — no id, so the data source makes one let id = table("order") .insert(#{ client: "c2", total: 30 });

check_circle

IdempotencyIdempotency By default, every write can be retried safely: a repeated insert or delete changes nothing, and writes through a filtered view stay inside it. An insert that relies on Auto-ID is the exception — retrying it adds a second row.// run twice: same result table("order") .upsert("o10", #{ client: "c3", total: 60 })

check_circle

What stands out

• Related columns become correlated subqueries, so client.name sorts and filters like any column.
• Bulk imports run in one transaction, match ids the way the column's collation does, and fire the same hooks as a single insert.
• Views built from a Rhai query, or derived from another table with base:, taking arguments from the page.
• modify: scripts add SQL conditions that YAML can't express: self.with_condition(ident("total") > 100).
• JSON columns open as their own editable tables.
• No live updates: MariaDB has no push channel short of reading the binlog.

Retrieving data

Filter by conditionsFilter by conditions Narrow the available table rows by applying one or more conditions.table("order").where("status", "open")	check_circle
Conditional operatorsConditional operators Non-exact matching with basic operators such as >, < or !=. Full support also needs matching against a set of values (in) and fuzzy text matching (contains).table("order").where("total", ">=", 100)	check_circle
Server-side sortServer-side sort The server re-arranges the results, respecting each column's data type, ascending or descending, on several columns in a set priority.table("order").sort("total", "desc")	check_circle
Quick searchQuick search A text search across several columns, performed on the server, so it can cover the entire table.table("client").search("smith")	check_circle
CountCount The server can say exactly how many rows remain in the set once the conditions are applied.table("order").where("status", "due").count()	check_circle
Column aggregatesColumn aggregates Aggregate functions applied to a column of a filtered set. The backend supports at least some of them, such as max, avg, median or a string concatenation (group_concat).select().from("order") .expression(avg(ident("total")).alias("avg_total")) .expression(max(ident("total")).alias("max_total"))	check_circle
Random-access pagesRandom-access pages Skip any number of rows in a filtered set without a performance penalty, and request any number of records up to a maximum.select().from("order") .order_by(ident("id"), "asc") .limit(50, 1000)	check_circle
Progressive (cursor) loadProgressive load A fall-back way to paginate: pages are sequential, and the next page can be fetched only after the previous one.	check_circle

Relations

One-to-many relationsOne-to-many relations Only needs a filter by condition whose value comes from a record loaded from another table — in the same data source or a different one.table("client").where("id", "c1").ref("orders")	check_circle
Many-to-many relationsMany-to-many relations A condition can be an expression over another set, such as a subquery or a join. Partial support when the in operator can match against a set of values.table("client").where("country", "UK").ref("orders")	~Partly supported Matches with in against the related ids, fetched first — not as a subquery.
Relation aggregationRelation aggregation A column can be defined as an aggregate of a field or expression in a related table, calculated on the server. The classic example is account.balance as the sum of transaction.amount.// invoice.paid: the sum of its payments coalesce( select().value().from("payment") .expression(sum(ident("amount"))) .where(ident("invoice") == parent("id")) .group_all().subquery()[0], 0)	remove
Arbitrary expressionsArbitrary expressions Per-row operations on the server, over stored values or relation aggregates — for example invoice_line.total as qty * item.price.mul(ident("qty"), ident("price")).alias("total")	remove
Column from related tableColumn from related table Import a field through a one-to-one relation, such as country_id.name, as a read-only column.columns: client.name: { type: string }	check_circle
Contained record expressionsContained record expressions A condition can iterate over sub-records stored inside a record — invoices whose JSON lines field contains item 123.self.with_condition(#{"lines.item_id": 123})	check_circle
Relations defined in RhaiRelations defined in Rhai Executes arbitrary code after a row is retrieved from the table, in the context of the entire row — a Rhai lazy: script in YAML, or a Rust closure that can also do I/O.badge: lazy: | if row.vip { "★ " + row.name } else { row.name }	check_circle

Live updates

Record changedRecord changed An open record updates in place when someone else changes it — the source pushes the change, no polling.	~Partly supported Needs a replica set: change streams don't run on a standalone server.
Record set changedRecord set changed A filtered grid updates when rows matching its condition change, and a row that stops matching leaves the grid.	~Partly supported Needs a replica set: change streams don't run on a standalone server.
Table changedTable changed Any insert, update or delete in the table reaches open grids as it happens.	~Partly supported Needs a replica set: change streams don't run on a standalone server.
Related record changedRelated record changed A change in a related table — an invoice_line — reaches the parent's view, such as invoice.total.	remove

Editing data

Add recordsAdd records Create rows from a form dialog. In a filtered view, new rows are filled in to belong to it.table("order") .insert(#{ id: "o10", client: "c3", total: 55 })	check_circle
Update recordsUpdate records Edit rows in a form dialog. A write through a filtered view can never change a row outside it.table("order").patch("o1", #{ status: "paid" })	check_circle
Delete recordsDelete records Remove rows, after a confirmation step, from a grid or a record view.table("order").where("status", "paid").delete("o2")	check_circle
Atomic importAtomic import A CSV or wizard import lands in one transaction: either every new row is stored or none is, and existing rows are left untouched.let paid = table("order").where("status", "paid"); table("archive").import_from(paid)	~Partly supported Needs a replica set: the import runs in a transaction.
Bulk modifyBulk modify Change every row of a filtered set in one operation — mark all open orders as shipped — without loading them first.	remove

Custom tables

Tables from custom queriesTables from custom queries A table can be defined by a query instead of a stored table — a Rhai script or a native query — and is read-only.select().from("order") .inner_join("client", "c", expr("c.id = order.client_id"))	check_circle
Table aggregateTable aggregate A table defined through another table — sales grouped by month, built on orders — inheriting its columns and relations.name: category_totals id_column: category_id columns: total_price: { type: int } sqlite: base: product inherit: columns: [category_id] rhai: | base.clear_fields().field("category_id") .expression(expr("SUM(price) AS total_price")) .group_by(expr("category_id"))	remove
Server-side actionsServer-side actions An action runs inside the data source, such as a stored procedure or function, instead of in the app.	remove

Misc

Auto-IDAuto-ID When the id column is flagged auto, an insert without an id asks the data source to assign one — auto-increment, a generated record id, an ObjectId — and returns it. Without the flag the app mints a UUIDv7 instead, so retries stay idempotent.# order.yaml columns: id: { type: int, flags: [id, auto] } // Rhai — no id, so the data source makes one let id = table("order") .insert(#{ client: "c2", total: 30 });

check_circle

IdempotencyIdempotency By default, every write can be retried safely: a repeated insert or delete changes nothing, and writes through a filtered view stay inside it. An insert that relies on Auto-ID is the exception — retrying it adds a second row.// run twice: same result table("order") .upsert("o10", #{ client: "c3", total: 60 })

check_circle

What stands out

• On a replica set, tables update live through change streams — edits from any client appear in place.
• Read-only views from an aggregation pipeline written in YAML, or built by a Rhai script.
• client.name columns joined server-side with $lookup, several hops deep.
• Nested fields as columns — nested_path: address.city — searchable and filterable like any other.
• Embedded objects and arrays open as their own editable tables.
• Edits keep ObjectId, date and decimal types; datetime and decimal columns check what you type.
• Bulk imports run in one transaction and fire the same hooks as a single insert.
• Rhai filters are plain maps: self.with_condition(#{price: #{"$gt": 100}}).

Retrieving data

Filter by conditionsFilter by conditions Narrow the available table rows by applying one or more conditions.table("order").where("status", "open")	check_circle
Conditional operatorsConditional operators Non-exact matching with basic operators such as >, < or !=. Full support also needs matching against a set of values (in) and fuzzy text matching (contains).table("order").where("total", ">=", 100)	remove
Server-side sortServer-side sort The server re-arranges the results, respecting each column's data type, ascending or descending, on several columns in a set priority.table("order").sort("total", "desc")	remove
Quick searchQuick search A text search across several columns, performed on the server, so it can cover the entire table.table("client").search("smith")	remove
CountCount The server can say exactly how many rows remain in the set once the conditions are applied.table("order").where("status", "due").count()	check_circle
Column aggregatesColumn aggregates Aggregate functions applied to a column of a filtered set. The backend supports at least some of them, such as max, avg, median or a string concatenation (group_concat).select().from("order") .expression(avg(ident("total")).alias("avg_total")) .expression(max(ident("total")).alias("max_total"))	remove
Random-access pagesRandom-access pages Skip any number of rows in a filtered set without a performance penalty, and request any number of records up to a maximum.select().from("order") .order_by(ident("id"), "asc") .limit(50, 1000)	remove
Progressive (cursor) loadProgressive load A fall-back way to paginate: pages are sequential, and the next page can be fetched only after the previous one.	check_circle

Relations

One-to-many relationsOne-to-many relations Only needs a filter by condition whose value comes from a record loaded from another table — in the same data source or a different one.table("client").where("id", "c1").ref("orders")	check_circle
Many-to-many relationsMany-to-many relations A condition can be an expression over another set, such as a subquery or a join. Partial support when the in operator can match against a set of values.table("client").where("country", "UK").ref("orders")	remove
Relation aggregationRelation aggregation A column can be defined as an aggregate of a field or expression in a related table, calculated on the server. The classic example is account.balance as the sum of transaction.amount.// invoice.paid: the sum of its payments coalesce( select().value().from("payment") .expression(sum(ident("amount"))) .where(ident("invoice") == parent("id")) .group_all().subquery()[0], 0)	remove
Arbitrary expressionsArbitrary expressions Per-row operations on the server, over stored values or relation aggregates — for example invoice_line.total as qty * item.price.mul(ident("qty"), ident("price")).alias("total")	remove
Column from related tableColumn from related table Import a field through a one-to-one relation, such as country_id.name, as a read-only column.columns: client.name: { type: string }	remove
Contained record expressionsContained record expressions A condition can iterate over sub-records stored inside a record — invoices whose JSON lines field contains item 123.self.with_condition(#{"lines.item_id": 123})	remove
Relations defined in RhaiRelations defined in Rhai Executes arbitrary code after a row is retrieved from the table, in the context of the entire row — a Rhai lazy: script in YAML, or a Rust closure that can also do I/O.badge: lazy: | if row.vip { "★ " + row.name } else { row.name }	remove

Live updates

Record changedRecord changed An open record updates in place when someone else changes it — the source pushes the change, no polling.	remove
Record set changedRecord set changed A filtered grid updates when rows matching its condition change, and a row that stops matching leaves the grid.	remove
Table changedTable changed Any insert, update or delete in the table reaches open grids as it happens.	remove
Related record changedRelated record changed A change in a related table — an invoice_line — reaches the parent's view, such as invoice.total.	remove

Editing data

Add recordsAdd records Create rows from a form dialog. In a filtered view, new rows are filled in to belong to it.table("order") .insert(#{ id: "o10", client: "c3", total: 55 })	remove
Update recordsUpdate records Edit rows in a form dialog. A write through a filtered view can never change a row outside it.table("order").patch("o1", #{ status: "paid" })	remove
Delete recordsDelete records Remove rows, after a confirmation step, from a grid or a record view.table("order").where("status", "paid").delete("o2")	remove
Atomic importAtomic import A CSV or wizard import lands in one transaction: either every new row is stored or none is, and existing rows are left untouched.let paid = table("order").where("status", "paid"); table("archive").import_from(paid)	remove
Bulk modifyBulk modify Change every row of a filtered set in one operation — mark all open orders as shipped — without loading them first.	remove

Custom tables

Tables from custom queriesTables from custom queries A table can be defined by a query instead of a stored table — a Rhai script or a native query — and is read-only.select().from("order") .inner_join("client", "c", expr("c.id = order.client_id"))	remove
Table aggregateTable aggregate A table defined through another table — sales grouped by month, built on orders — inheriting its columns and relations.name: category_totals id_column: category_id columns: total_price: { type: int } sqlite: base: product inherit: columns: [category_id] rhai: | base.clear_fields().field("category_id") .expression(expr("SUM(price) AS total_price")) .group_by(expr("category_id"))	remove
Server-side actionsServer-side actions An action runs inside the data source, such as a stored procedure or function, instead of in the app.	remove

Misc

Auto-IDAuto-ID When the id column is flagged auto, an insert without an id asks the data source to assign one — auto-increment, a generated record id, an ObjectId — and returns it. Without the flag the app mints a UUIDv7 instead, so retries stay idempotent.# order.yaml columns: id: { type: int, flags: [id, auto] } // Rhai — no id, so the data source makes one let id = table("order") .insert(#{ client: "c2", total: 30 });

remove

IdempotencyIdempotency By default, every write can be retried safely: a repeated insert or delete changes nothing, and writes through a filtered view stay inside it. An insert that relies on Auto-ID is the exception — retrying it adds a second row.// run twice: same result table("order") .upsert("o10", #{ client: "c3", total: 60 })

remove

Retrieving data

Filter by conditionsFilter by conditions Narrow the available table rows by applying one or more conditions.table("order").where("status", "open")	check_circle
Conditional operatorsConditional operators Non-exact matching with basic operators such as >, < or !=. Full support also needs matching against a set of values (in) and fuzzy text matching (contains).table("order").where("total", ">=", 100)	~Partly supported Hasura dialect only.
Server-side sortServer-side sort The server re-arranges the results, respecting each column's data type, ascending or descending, on several columns in a set priority.table("order").sort("total", "desc")	~Partly supported Hasura dialect only.
Quick searchQuick search A text search across several columns, performed on the server, so it can cover the entire table.table("client").search("smith")	~Partly supported Hasura dialect only.
CountCount The server can say exactly how many rows remain in the set once the conditions are applied.table("order").where("status", "due").count()	check_circle
Column aggregatesColumn aggregates Aggregate functions applied to a column of a filtered set. The backend supports at least some of them, such as max, avg, median or a string concatenation (group_concat).select().from("order") .expression(avg(ident("total")).alias("avg_total")) .expression(max(ident("total")).alias("max_total"))	remove
Random-access pagesRandom-access pages Skip any number of rows in a filtered set without a performance penalty, and request any number of records up to a maximum.select().from("order") .order_by(ident("id"), "asc") .limit(50, 1000)	~Partly supported limit / offset are rendered when the table sets paginate: true, but the grid doesn't page with them yet.
Progressive (cursor) loadProgressive load A fall-back way to paginate: pages are sequential, and the next page can be fetched only after the previous one.	remove

Relations

One-to-many relationsOne-to-many relations Only needs a filter by condition whose value comes from a record loaded from another table — in the same data source or a different one.table("client").where("id", "c1").ref("orders")	check_circle
Many-to-many relationsMany-to-many relations A condition can be an expression over another set, such as a subquery or a join. Partial support when the in operator can match against a set of values.table("client").where("country", "UK").ref("orders")	remove
Relation aggregationRelation aggregation A column can be defined as an aggregate of a field or expression in a related table, calculated on the server. The classic example is account.balance as the sum of transaction.amount.// invoice.paid: the sum of its payments coalesce( select().value().from("payment") .expression(sum(ident("amount"))) .where(ident("invoice") == parent("id")) .group_all().subquery()[0], 0)	remove
Arbitrary expressionsArbitrary expressions Per-row operations on the server, over stored values or relation aggregates — for example invoice_line.total as qty * item.price.mul(ident("qty"), ident("price")).alias("total")	remove
Column from related tableColumn from related table Import a field through a one-to-one relation, such as country_id.name, as a read-only column.columns: client.name: { type: string }	remove
Contained record expressionsContained record expressions A condition can iterate over sub-records stored inside a record — invoices whose JSON lines field contains item 123.self.with_condition(#{"lines.item_id": 123})	remove
Relations defined in RhaiRelations defined in Rhai Executes arbitrary code after a row is retrieved from the table, in the context of the entire row — a Rhai lazy: script in YAML, or a Rust closure that can also do I/O.badge: lazy: | if row.vip { "★ " + row.name } else { row.name }	check_circle

Live updates

Record changedRecord changed An open record updates in place when someone else changes it — the source pushes the change, no polling.	remove
Record set changedRecord set changed A filtered grid updates when rows matching its condition change, and a row that stops matching leaves the grid.	remove
Table changedTable changed Any insert, update or delete in the table reaches open grids as it happens.	remove
Related record changedRelated record changed A change in a related table — an invoice_line — reaches the parent's view, such as invoice.total.	remove

Editing data

Add recordsAdd records Create rows from a form dialog. In a filtered view, new rows are filled in to belong to it.table("order") .insert(#{ id: "o10", client: "c3", total: 55 })	remove
Update recordsUpdate records Edit rows in a form dialog. A write through a filtered view can never change a row outside it.table("order").patch("o1", #{ status: "paid" })	remove
Delete recordsDelete records Remove rows, after a confirmation step, from a grid or a record view.table("order").where("status", "paid").delete("o2")	remove
Atomic importAtomic import A CSV or wizard import lands in one transaction: either every new row is stored or none is, and existing rows are left untouched.let paid = table("order").where("status", "paid"); table("archive").import_from(paid)	remove
Bulk modifyBulk modify Change every row of a filtered set in one operation — mark all open orders as shipped — without loading them first.	remove

Custom tables

Tables from custom queriesTables from custom queries A table can be defined by a query instead of a stored table — a Rhai script or a native query — and is read-only.select().from("order") .inner_join("client", "c", expr("c.id = order.client_id"))	remove
Table aggregateTable aggregate A table defined through another table — sales grouped by month, built on orders — inheriting its columns and relations.name: category_totals id_column: category_id columns: total_price: { type: int } sqlite: base: product inherit: columns: [category_id] rhai: | base.clear_fields().field("category_id") .expression(expr("SUM(price) AS total_price")) .group_by(expr("category_id"))	remove
Server-side actionsServer-side actions An action runs inside the data source, such as a stored procedure or function, instead of in the app.	remove

Misc

Auto-IDAuto-ID When the id column is flagged auto, an insert without an id asks the data source to assign one — auto-increment, a generated record id, an ObjectId — and returns it. Without the flag the app mints a UUIDv7 instead, so retries stay idempotent.# order.yaml columns: id: { type: int, flags: [id, auto] } // Rhai — no id, so the data source makes one let id = table("order") .insert(#{ client: "c2", total: 30 });

remove

IdempotencyIdempotency By default, every write can be retried safely: a repeated insert or delete changes nothing, and writes through a filtered view stay inside it. An insert that relies on Auto-ID is the exception — retrying it adds a second row.// run twice: same result table("order") .upsert("o10", #{ client: "c3", total: 60 })

remove

Retrieving data

Filter by conditionsFilter by conditions Narrow the available table rows by applying one or more conditions.table("order").where("status", "open")	~Partly supported Equality only, as a URL path segment or ?field=value; the API has to honour it. Can be set to filter in the app instead.
Conditional operatorsConditional operators Non-exact matching with basic operators such as >, < or !=. Full support also needs matching against a set of values (in) and fuzzy text matching (contains).table("order").where("total", ">=", 100)	remove
Server-side sortServer-side sort The server re-arranges the results, respecting each column's data type, ascending or descending, on several columns in a set priority.table("order").sort("total", "desc")	~Partly supported When the API has a sort parameter (OrderingParams); one column at a time.
Quick searchQuick search A text search across several columns, performed on the server, so it can cover the entire table.table("client").search("smith")	remove
CountCount The server can say exactly how many rows remain in the set once the conditions are applied.table("order").where("status", "due").count()	~Partly supported Exact when the API reports a total (total_key); otherwise the rows are fetched and counted.
Column aggregatesColumn aggregates Aggregate functions applied to a column of a filtered set. The backend supports at least some of them, such as max, avg, median or a string concatenation (group_concat).select().from("order") .expression(avg(ident("total")).alias("avg_total")) .expression(max(ident("total")).alias("max_total"))	remove
Random-access pagesRandom-access pages Skip any number of rows in a filtered set without a performance penalty, and request any number of records up to a maximum.select().from("order") .order_by(ident("id"), "asc") .limit(50, 1000)	~Partly supported When page/limit or skip/limit parameters are configured and the API supports them.
Progressive (cursor) loadProgressive load A fall-back way to paginate: pages are sequential, and the next page can be fetched only after the previous one.	remove

Relations

One-to-many relationsOne-to-many relations Only needs a filter by condition whose value comes from a record loaded from another table — in the same data source or a different one.table("client").where("id", "c1").ref("orders")	check_circle
Many-to-many relationsMany-to-many relations A condition can be an expression over another set, such as a subquery or a join. Partial support when the in operator can match against a set of values.table("client").where("country", "UK").ref("orders")	remove
Relation aggregationRelation aggregation A column can be defined as an aggregate of a field or expression in a related table, calculated on the server. The classic example is account.balance as the sum of transaction.amount.// invoice.paid: the sum of its payments coalesce( select().value().from("payment") .expression(sum(ident("amount"))) .where(ident("invoice") == parent("id")) .group_all().subquery()[0], 0)	remove
Arbitrary expressionsArbitrary expressions Per-row operations on the server, over stored values or relation aggregates — for example invoice_line.total as qty * item.price.mul(ident("qty"), ident("price")).alias("total")	remove
Column from related tableColumn from related table Import a field through a one-to-one relation, such as country_id.name, as a read-only column.columns: client.name: { type: string }	remove
Contained record expressionsContained record expressions A condition can iterate over sub-records stored inside a record — invoices whose JSON lines field contains item 123.self.with_condition(#{"lines.item_id": 123})	remove
Relations defined in RhaiRelations defined in Rhai Executes arbitrary code after a row is retrieved from the table, in the context of the entire row — a Rhai lazy: script in YAML, or a Rust closure that can also do I/O.badge: lazy: | if row.vip { "★ " + row.name } else { row.name }	check_circle

Live updates

Record changedRecord changed An open record updates in place when someone else changes it — the source pushes the change, no polling.	remove
Record set changedRecord set changed A filtered grid updates when rows matching its condition change, and a row that stops matching leaves the grid.	remove
Table changedTable changed Any insert, update or delete in the table reaches open grids as it happens.	remove
Related record changedRelated record changed A change in a related table — an invoice_line — reaches the parent's view, such as invoice.total.	remove

Editing data

Add recordsAdd records Create rows from a form dialog. In a filtered view, new rows are filled in to belong to it.table("order") .insert(#{ id: "o10", client: "c3", total: 55 })	remove
Update recordsUpdate records Edit rows in a form dialog. A write through a filtered view can never change a row outside it.table("order").patch("o1", #{ status: "paid" })	remove
Delete recordsDelete records Remove rows, after a confirmation step, from a grid or a record view.table("order").where("status", "paid").delete("o2")	remove
Atomic importAtomic import A CSV or wizard import lands in one transaction: either every new row is stored or none is, and existing rows are left untouched.let paid = table("order").where("status", "paid"); table("archive").import_from(paid)	remove
Bulk modifyBulk modify Change every row of a filtered set in one operation — mark all open orders as shipped — without loading them first.	remove

Custom tables

Tables from custom queriesTables from custom queries A table can be defined by a query instead of a stored table — a Rhai script or a native query — and is read-only.select().from("order") .inner_join("client", "c", expr("c.id = order.client_id"))	remove
Table aggregateTable aggregate A table defined through another table — sales grouped by month, built on orders — inheriting its columns and relations.name: category_totals id_column: category_id columns: total_price: { type: int } sqlite: base: product inherit: columns: [category_id] rhai: | base.clear_fields().field("category_id") .expression(expr("SUM(price) AS total_price")) .group_by(expr("category_id"))	remove
Server-side actionsServer-side actions An action runs inside the data source, such as a stored procedure or function, instead of in the app.	remove

Misc

Auto-IDAuto-ID When the id column is flagged auto, an insert without an id asks the data source to assign one — auto-increment, a generated record id, an ObjectId — and returns it. Without the flag the app mints a UUIDv7 instead, so retries stay idempotent.# order.yaml columns: id: { type: int, flags: [id, auto] } // Rhai — no id, so the data source makes one let id = table("order") .insert(#{ client: "c2", total: 30 });

remove

IdempotencyIdempotency By default, every write can be retried safely: a repeated insert or delete changes nothing, and writes through a filtered view stay inside it. An insert that relies on Auto-ID is the exception — retrying it adds a second row.// run twice: same result table("order") .upsert("o10", #{ client: "c3", total: 60 })

remove

Retrieving data

Filter by conditionsFilter by conditions Narrow the available table rows by applying one or more conditions.table("order").where("status", "open")	check_circle
Conditional operatorsConditional operators Non-exact matching with basic operators such as >, < or !=. Full support also needs matching against a set of values (in) and fuzzy text matching (contains).table("order").where("total", ">=", 100)	remove
Server-side sortServer-side sort The server re-arranges the results, respecting each column's data type, ascending or descending, on several columns in a set priority.table("order").sort("total", "desc")	remove
Quick searchQuick search A text search across several columns, performed on the server, so it can cover the entire table.table("client").search("smith")	remove
CountCount The server can say exactly how many rows remain in the set once the conditions are applied.table("order").where("status", "due").count()	check_circle
Column aggregatesColumn aggregates Aggregate functions applied to a column of a filtered set. The backend supports at least some of them, such as max, avg, median or a string concatenation (group_concat).select().from("order") .expression(avg(ident("total")).alias("avg_total")) .expression(max(ident("total")).alias("max_total"))	remove
Random-access pagesRandom-access pages Skip any number of rows in a filtered set without a performance penalty, and request any number of records up to a maximum.select().from("order") .order_by(ident("id"), "asc") .limit(50, 1000)	remove
Progressive (cursor) loadProgressive load A fall-back way to paginate: pages are sequential, and the next page can be fetched only after the previous one.	remove

Relations

One-to-many relationsOne-to-many relations Only needs a filter by condition whose value comes from a record loaded from another table — in the same data source or a different one.table("client").where("id", "c1").ref("orders")	check_circle
Many-to-many relationsMany-to-many relations A condition can be an expression over another set, such as a subquery or a join. Partial support when the in operator can match against a set of values.table("client").where("country", "UK").ref("orders")	remove
Relation aggregationRelation aggregation A column can be defined as an aggregate of a field or expression in a related table, calculated on the server. The classic example is account.balance as the sum of transaction.amount.// invoice.paid: the sum of its payments coalesce( select().value().from("payment") .expression(sum(ident("amount"))) .where(ident("invoice") == parent("id")) .group_all().subquery()[0], 0)	remove
Arbitrary expressionsArbitrary expressions Per-row operations on the server, over stored values or relation aggregates — for example invoice_line.total as qty * item.price.mul(ident("qty"), ident("price")).alias("total")	remove
Column from related tableColumn from related table Import a field through a one-to-one relation, such as country_id.name, as a read-only column.columns: client.name: { type: string }	remove
Contained record expressionsContained record expressions A condition can iterate over sub-records stored inside a record — invoices whose JSON lines field contains item 123.self.with_condition(#{"lines.item_id": 123})	remove
Relations defined in RhaiRelations defined in Rhai Executes arbitrary code after a row is retrieved from the table, in the context of the entire row — a Rhai lazy: script in YAML, or a Rust closure that can also do I/O.badge: lazy: | if row.vip { "★ " + row.name } else { row.name }	remove

Live updates

Record changedRecord changed An open record updates in place when someone else changes it — the source pushes the change, no polling.	remove
Record set changedRecord set changed A filtered grid updates when rows matching its condition change, and a row that stops matching leaves the grid.	remove
Table changedTable changed Any insert, update or delete in the table reaches open grids as it happens.	remove
Related record changedRelated record changed A change in a related table — an invoice_line — reaches the parent's view, such as invoice.total.	remove

Editing data

Add recordsAdd records Create rows from a form dialog. In a filtered view, new rows are filled in to belong to it.table("order") .insert(#{ id: "o10", client: "c3", total: 55 })	remove
Update recordsUpdate records Edit rows in a form dialog. A write through a filtered view can never change a row outside it.table("order").patch("o1", #{ status: "paid" })	remove
Delete recordsDelete records Remove rows, after a confirmation step, from a grid or a record view.table("order").where("status", "paid").delete("o2")	remove
Atomic importAtomic import A CSV or wizard import lands in one transaction: either every new row is stored or none is, and existing rows are left untouched.let paid = table("order").where("status", "paid"); table("archive").import_from(paid)	remove
Bulk modifyBulk modify Change every row of a filtered set in one operation — mark all open orders as shipped — without loading them first.	remove

Custom tables

Tables from custom queriesTables from custom queries A table can be defined by a query instead of a stored table — a Rhai script or a native query — and is read-only.select().from("order") .inner_join("client", "c", expr("c.id = order.client_id"))	remove
Table aggregateTable aggregate A table defined through another table — sales grouped by month, built on orders — inheriting its columns and relations.name: category_totals id_column: category_id columns: total_price: { type: int } sqlite: base: product inherit: columns: [category_id] rhai: | base.clear_fields().field("category_id") .expression(expr("SUM(price) AS total_price")) .group_by(expr("category_id"))	remove
Server-side actionsServer-side actions An action runs inside the data source, such as a stored procedure or function, instead of in the app.	remove

Misc

Auto-IDAuto-ID When the id column is flagged auto, an insert without an id asks the data source to assign one — auto-increment, a generated record id, an ObjectId — and returns it. Without the flag the app mints a UUIDv7 instead, so retries stay idempotent.# order.yaml columns: id: { type: int, flags: [id, auto] } // Rhai — no id, so the data source makes one let id = table("order") .insert(#{ client: "c2", total: 30 });

remove

IdempotencyIdempotency By default, every write can be retried safely: a repeated insert or delete changes nothing, and writes through a filtered view stay inside it. An insert that relies on Auto-ID is the exception — retrying it adds a second row.// run twice: same result table("order") .upsert("o10", #{ client: "c3", total: 60 })

remove

Retrieving data

Filter by conditionsFilter by conditions Narrow the available table rows by applying one or more conditions.table("order").where("status", "open")	remove
Conditional operatorsConditional operators Non-exact matching with basic operators such as >, < or !=. Full support also needs matching against a set of values (in) and fuzzy text matching (contains).table("order").where("total", ">=", 100)	remove
Server-side sortServer-side sort The server re-arranges the results, respecting each column's data type, ascending or descending, on several columns in a set priority.table("order").sort("total", "desc")	remove
Quick searchQuick search A text search across several columns, performed on the server, so it can cover the entire table.table("client").search("smith")	remove
CountCount The server can say exactly how many rows remain in the set once the conditions are applied.table("order").where("status", "due").count()	check_circle
Column aggregatesColumn aggregates Aggregate functions applied to a column of a filtered set. The backend supports at least some of them, such as max, avg, median or a string concatenation (group_concat).select().from("order") .expression(avg(ident("total")).alias("avg_total")) .expression(max(ident("total")).alias("max_total"))	remove
Random-access pagesRandom-access pages Skip any number of rows in a filtered set without a performance penalty, and request any number of records up to a maximum.select().from("order") .order_by(ident("id"), "asc") .limit(50, 1000)	remove
Progressive (cursor) loadProgressive load A fall-back way to paginate: pages are sequential, and the next page can be fetched only after the previous one.	remove

Relations

One-to-many relationsOne-to-many relations Only needs a filter by condition whose value comes from a record loaded from another table — in the same data source or a different one.table("client").where("id", "c1").ref("orders")	remove
Many-to-many relationsMany-to-many relations A condition can be an expression over another set, such as a subquery or a join. Partial support when the in operator can match against a set of values.table("client").where("country", "UK").ref("orders")	remove
Relation aggregationRelation aggregation A column can be defined as an aggregate of a field or expression in a related table, calculated on the server. The classic example is account.balance as the sum of transaction.amount.// invoice.paid: the sum of its payments coalesce( select().value().from("payment") .expression(sum(ident("amount"))) .where(ident("invoice") == parent("id")) .group_all().subquery()[0], 0)	remove
Arbitrary expressionsArbitrary expressions Per-row operations on the server, over stored values or relation aggregates — for example invoice_line.total as qty * item.price.mul(ident("qty"), ident("price")).alias("total")	remove
Column from related tableColumn from related table Import a field through a one-to-one relation, such as country_id.name, as a read-only column.columns: client.name: { type: string }	remove
Contained record expressionsContained record expressions A condition can iterate over sub-records stored inside a record — invoices whose JSON lines field contains item 123.self.with_condition(#{"lines.item_id": 123})	remove
Relations defined in RhaiRelations defined in Rhai Executes arbitrary code after a row is retrieved from the table, in the context of the entire row — a Rhai lazy: script in YAML, or a Rust closure that can also do I/O.badge: lazy: | if row.vip { "★ " + row.name } else { row.name }	check_circle

Live updates

Record changedRecord changed An open record updates in place when someone else changes it — the source pushes the change, no polling.	remove
Record set changedRecord set changed A filtered grid updates when rows matching its condition change, and a row that stops matching leaves the grid.	remove
Table changedTable changed Any insert, update or delete in the table reaches open grids as it happens.	remove
Related record changedRelated record changed A change in a related table — an invoice_line — reaches the parent's view, such as invoice.total.	remove

Editing data

Add recordsAdd records Create rows from a form dialog. In a filtered view, new rows are filled in to belong to it.table("order") .insert(#{ id: "o10", client: "c3", total: 55 })	remove
Update recordsUpdate records Edit rows in a form dialog. A write through a filtered view can never change a row outside it.table("order").patch("o1", #{ status: "paid" })	remove
Delete recordsDelete records Remove rows, after a confirmation step, from a grid or a record view.table("order").where("status", "paid").delete("o2")	remove
Atomic importAtomic import A CSV or wizard import lands in one transaction: either every new row is stored or none is, and existing rows are left untouched.let paid = table("order").where("status", "paid"); table("archive").import_from(paid)	remove
Bulk modifyBulk modify Change every row of a filtered set in one operation — mark all open orders as shipped — without loading them first.	remove

Custom tables

Tables from custom queriesTables from custom queries A table can be defined by a query instead of a stored table — a Rhai script or a native query — and is read-only.select().from("order") .inner_join("client", "c", expr("c.id = order.client_id"))	remove
Table aggregateTable aggregate A table defined through another table — sales grouped by month, built on orders — inheriting its columns and relations.name: category_totals id_column: category_id columns: total_price: { type: int } sqlite: base: product inherit: columns: [category_id] rhai: | base.clear_fields().field("category_id") .expression(expr("SUM(price) AS total_price")) .group_by(expr("category_id"))	remove
Server-side actionsServer-side actions An action runs inside the data source, such as a stored procedure or function, instead of in the app.	remove

Misc

Auto-IDAuto-ID When the id column is flagged auto, an insert without an id asks the data source to assign one — auto-increment, a generated record id, an ObjectId — and returns it. Without the flag the app mints a UUIDv7 instead, so retries stay idempotent.# order.yaml columns: id: { type: int, flags: [id, auto] } // Rhai — no id, so the data source makes one let id = table("order") .insert(#{ client: "c2", total: 30 });

remove

IdempotencyIdempotency By default, every write can be retried safely: a repeated insert or delete changes nothing, and writes through a filtered view stay inside it. An insert that relies on Auto-ID is the exception — retrying it adds a second row.// run twice: same result table("order") .upsert("o10", #{ client: "c3", total: 60 })

remove

Retrieving data

Filter by conditionsFilter by conditions Narrow the available table rows by applying one or more conditions.table("order").where("status", "open")	check_circle
Conditional operatorsConditional operators Non-exact matching with basic operators such as >, < or !=. Full support also needs matching against a set of values (in) and fuzzy text matching (contains).table("order").where("total", ">=", 100)	remove
Server-side sortServer-side sort The server re-arranges the results, respecting each column's data type, ascending or descending, on several columns in a set priority.table("order").sort("total", "desc")	remove
Quick searchQuick search A text search across several columns, performed on the server, so it can cover the entire table.table("client").search("smith")	remove
CountCount The server can say exactly how many rows remain in the set once the conditions are applied.table("order").where("status", "due").count()	check_circle
Column aggregatesColumn aggregates Aggregate functions applied to a column of a filtered set. The backend supports at least some of them, such as max, avg, median or a string concatenation (group_concat).select().from("order") .expression(avg(ident("total")).alias("avg_total")) .expression(max(ident("total")).alias("max_total"))	remove
Random-access pagesRandom-access pages Skip any number of rows in a filtered set without a performance penalty, and request any number of records up to a maximum.select().from("order") .order_by(ident("id"), "asc") .limit(50, 1000)	remove
Progressive (cursor) loadProgressive load A fall-back way to paginate: pages are sequential, and the next page can be fetched only after the previous one.	remove

Relations

One-to-many relationsOne-to-many relations Only needs a filter by condition whose value comes from a record loaded from another table — in the same data source or a different one.table("client").where("id", "c1").ref("orders")	check_circle
Many-to-many relationsMany-to-many relations A condition can be an expression over another set, such as a subquery or a join. Partial support when the in operator can match against a set of values.table("client").where("country", "UK").ref("orders")	remove
Relation aggregationRelation aggregation A column can be defined as an aggregate of a field or expression in a related table, calculated on the server. The classic example is account.balance as the sum of transaction.amount.// invoice.paid: the sum of its payments coalesce( select().value().from("payment") .expression(sum(ident("amount"))) .where(ident("invoice") == parent("id")) .group_all().subquery()[0], 0)	remove
Arbitrary expressionsArbitrary expressions Per-row operations on the server, over stored values or relation aggregates — for example invoice_line.total as qty * item.price.mul(ident("qty"), ident("price")).alias("total")	remove
Column from related tableColumn from related table Import a field through a one-to-one relation, such as country_id.name, as a read-only column.columns: client.name: { type: string }	remove
Contained record expressionsContained record expressions A condition can iterate over sub-records stored inside a record — invoices whose JSON lines field contains item 123.self.with_condition(#{"lines.item_id": 123})	remove
Relations defined in RhaiRelations defined in Rhai Executes arbitrary code after a row is retrieved from the table, in the context of the entire row — a Rhai lazy: script in YAML, or a Rust closure that can also do I/O.badge: lazy: | if row.vip { "★ " + row.name } else { row.name }	check_circle

Live updates

Record changedRecord changed An open record updates in place when someone else changes it — the source pushes the change, no polling.	remove
Record set changedRecord set changed A filtered grid updates when rows matching its condition change, and a row that stops matching leaves the grid.	remove
Table changedTable changed Any insert, update or delete in the table reaches open grids as it happens.	remove
Related record changedRelated record changed A change in a related table — an invoice_line — reaches the parent's view, such as invoice.total.	remove

Editing data

Add recordsAdd records Create rows from a form dialog. In a filtered view, new rows are filled in to belong to it.table("order") .insert(#{ id: "o10", client: "c3", total: 55 })	remove
Update recordsUpdate records Edit rows in a form dialog. A write through a filtered view can never change a row outside it.table("order").patch("o1", #{ status: "paid" })	remove
Delete recordsDelete records Remove rows, after a confirmation step, from a grid or a record view.table("order").where("status", "paid").delete("o2")	remove
Atomic importAtomic import A CSV or wizard import lands in one transaction: either every new row is stored or none is, and existing rows are left untouched.let paid = table("order").where("status", "paid"); table("archive").import_from(paid)	remove
Bulk modifyBulk modify Change every row of a filtered set in one operation — mark all open orders as shipped — without loading them first.	remove

Custom tables

Tables from custom queriesTables from custom queries A table can be defined by a query instead of a stored table — a Rhai script or a native query — and is read-only.select().from("order") .inner_join("client", "c", expr("c.id = order.client_id"))	remove
Table aggregateTable aggregate A table defined through another table — sales grouped by month, built on orders — inheriting its columns and relations.name: category_totals id_column: category_id columns: total_price: { type: int } sqlite: base: product inherit: columns: [category_id] rhai: | base.clear_fields().field("category_id") .expression(expr("SUM(price) AS total_price")) .group_by(expr("category_id"))	remove
Server-side actionsServer-side actions An action runs inside the data source, such as a stored procedure or function, instead of in the app.	remove

Misc

Auto-IDAuto-ID When the id column is flagged auto, an insert without an id asks the data source to assign one — auto-increment, a generated record id, an ObjectId — and returns it. Without the flag the app mints a UUIDv7 instead, so retries stay idempotent.# order.yaml columns: id: { type: int, flags: [id, auto] } // Rhai — no id, so the data source makes one let id = table("order") .insert(#{ client: "c2", total: 30 });

remove

IdempotencyIdempotency By default, every write can be retried safely: a repeated insert or delete changes nothing, and writes through a filtered view stay inside it. An insert that relies on Auto-ID is the exception — retrying it adds a second row.// run twice: same result table("order") .upsert("o10", #{ client: "c3", total: 60 })

remove

Retrieving data

Filter by conditionsFilter by conditions Narrow the available table rows by applying one or more conditions.table("order").where("status", "open")	remove
Conditional operatorsConditional operators Non-exact matching with basic operators such as >, < or !=. Full support also needs matching against a set of values (in) and fuzzy text matching (contains).table("order").where("total", ">=", 100)	remove
Server-side sortServer-side sort The server re-arranges the results, respecting each column's data type, ascending or descending, on several columns in a set priority.table("order").sort("total", "desc")	remove
Quick searchQuick search A text search across several columns, performed on the server, so it can cover the entire table.table("client").search("smith")	remove
CountCount The server can say exactly how many rows remain in the set once the conditions are applied.table("order").where("status", "due").count()	remove
Column aggregatesColumn aggregates Aggregate functions applied to a column of a filtered set. The backend supports at least some of them, such as max, avg, median or a string concatenation (group_concat).select().from("order") .expression(avg(ident("total")).alias("avg_total")) .expression(max(ident("total")).alias("max_total"))	remove
Random-access pagesRandom-access pages Skip any number of rows in a filtered set without a performance penalty, and request any number of records up to a maximum.select().from("order") .order_by(ident("id"), "asc") .limit(50, 1000)	remove
Progressive (cursor) loadProgressive load A fall-back way to paginate: pages are sequential, and the next page can be fetched only after the previous one.	remove

Relations

One-to-many relationsOne-to-many relations Only needs a filter by condition whose value comes from a record loaded from another table — in the same data source or a different one.table("client").where("id", "c1").ref("orders")	remove
Many-to-many relationsMany-to-many relations A condition can be an expression over another set, such as a subquery or a join. Partial support when the in operator can match against a set of values.table("client").where("country", "UK").ref("orders")	remove
Relation aggregationRelation aggregation A column can be defined as an aggregate of a field or expression in a related table, calculated on the server. The classic example is account.balance as the sum of transaction.amount.// invoice.paid: the sum of its payments coalesce( select().value().from("payment") .expression(sum(ident("amount"))) .where(ident("invoice") == parent("id")) .group_all().subquery()[0], 0)	remove
Arbitrary expressionsArbitrary expressions Per-row operations on the server, over stored values or relation aggregates — for example invoice_line.total as qty * item.price.mul(ident("qty"), ident("price")).alias("total")	remove
Column from related tableColumn from related table Import a field through a one-to-one relation, such as country_id.name, as a read-only column.columns: client.name: { type: string }	remove
Contained record expressionsContained record expressions A condition can iterate over sub-records stored inside a record — invoices whose JSON lines field contains item 123.self.with_condition(#{"lines.item_id": 123})	remove
Relations defined in RhaiRelations defined in Rhai Executes arbitrary code after a row is retrieved from the table, in the context of the entire row — a Rhai lazy: script in YAML, or a Rust closure that can also do I/O.badge: lazy: | if row.vip { "★ " + row.name } else { row.name }	check_circle

Live updates

Record changedRecord changed An open record updates in place when someone else changes it — the source pushes the change, no polling.	remove
Record set changedRecord set changed A filtered grid updates when rows matching its condition change, and a row that stops matching leaves the grid.	remove
Table changedTable changed Any insert, update or delete in the table reaches open grids as it happens.	remove
Related record changedRelated record changed A change in a related table — an invoice_line — reaches the parent's view, such as invoice.total.	remove

Editing data

Add recordsAdd records Create rows from a form dialog. In a filtered view, new rows are filled in to belong to it.table("order") .insert(#{ id: "o10", client: "c3", total: 55 })	check_circle
Update recordsUpdate records Edit rows in a form dialog. A write through a filtered view can never change a row outside it.table("order").patch("o1", #{ status: "paid" })	remove
Delete recordsDelete records Remove rows, after a confirmation step, from a grid or a record view.table("order").where("status", "paid").delete("o2")	remove
Atomic importAtomic import A CSV or wizard import lands in one transaction: either every new row is stored or none is, and existing rows are left untouched.let paid = table("order").where("status", "paid"); table("archive").import_from(paid)	remove
Bulk modifyBulk modify Change every row of a filtered set in one operation — mark all open orders as shipped — without loading them first.	remove

Custom tables

Tables from custom queriesTables from custom queries A table can be defined by a query instead of a stored table — a Rhai script or a native query — and is read-only.select().from("order") .inner_join("client", "c", expr("c.id = order.client_id"))	remove
Table aggregateTable aggregate A table defined through another table — sales grouped by month, built on orders — inheriting its columns and relations.name: category_totals id_column: category_id columns: total_price: { type: int } sqlite: base: product inherit: columns: [category_id] rhai: | base.clear_fields().field("category_id") .expression(expr("SUM(price) AS total_price")) .group_by(expr("category_id"))	remove
Server-side actionsServer-side actions An action runs inside the data source, such as a stored procedure or function, instead of in the app.	remove

Misc

Auto-IDAuto-ID When the id column is flagged auto, an insert without an id asks the data source to assign one — auto-increment, a generated record id, an ObjectId — and returns it. Without the flag the app mints a UUIDv7 instead, so retries stay idempotent.# order.yaml columns: id: { type: int, flags: [id, auto] } // Rhai — no id, so the data source makes one let id = table("order") .insert(#{ client: "c2", total: 30 });

remove

IdempotencyIdempotency By default, every write can be retried safely: a repeated insert or delete changes nothing, and writes through a filtered view stay inside it. An insert that relies on Auto-ID is the exception — retrying it adds a second row.// run twice: same result table("order") .upsert("o10", #{ client: "c3", total: 60 })

remove

Retrieving data

Filter by conditionsFilter by conditions Narrow the available table rows by applying one or more conditions.table("order").where("status", "open")	check_circle
Conditional operatorsConditional operators Non-exact matching with basic operators such as >, < or !=. Full support also needs matching against a set of values (in) and fuzzy text matching (contains).table("order").where("total", ">=", 100)	check_circle
Server-side sortServer-side sort The server re-arranges the results, respecting each column's data type, ascending or descending, on several columns in a set priority.table("order").sort("total", "desc")	check_circle
Quick searchQuick search A text search across several columns, performed on the server, so it can cover the entire table.table("client").search("smith")	check_circle
CountCount The server can say exactly how many rows remain in the set once the conditions are applied.table("order").where("status", "due").count()	check_circle
Column aggregatesColumn aggregates Aggregate functions applied to a column of a filtered set. The backend supports at least some of them, such as max, avg, median or a string concatenation (group_concat).select().from("order") .expression(avg(ident("total")).alias("avg_total")) .expression(max(ident("total")).alias("max_total"))	check_circle
Random-access pagesRandom-access pages Skip any number of rows in a filtered set without a performance penalty, and request any number of records up to a maximum.select().from("order") .order_by(ident("id"), "asc") .limit(50, 1000)	check_circle
Progressive (cursor) loadProgressive load A fall-back way to paginate: pages are sequential, and the next page can be fetched only after the previous one.	remove

Relations

One-to-many relationsOne-to-many relations Only needs a filter by condition whose value comes from a record loaded from another table — in the same data source or a different one.table("client").where("id", "c1").ref("orders")	check_circle
Many-to-many relationsMany-to-many relations A condition can be an expression over another set, such as a subquery or a join. Partial support when the in operator can match against a set of values.table("client").where("country", "UK").ref("orders")	~Partly supported Matches with in against the related ids, fetched first — not as a subquery.
Relation aggregationRelation aggregation A column can be defined as an aggregate of a field or expression in a related table, calculated on the server. The classic example is account.balance as the sum of transaction.amount.// invoice.paid: the sum of its payments coalesce( select().value().from("payment") .expression(sum(ident("amount"))) .where(ident("invoice") == parent("id")) .group_all().subquery()[0], 0)	remove
Arbitrary expressionsArbitrary expressions Per-row operations on the server, over stored values or relation aggregates — for example invoice_line.total as qty * item.price.mul(ident("qty"), ident("price")).alias("total")	remove
Column from related tableColumn from related table Import a field through a one-to-one relation, such as country_id.name, as a read-only column.columns: client.name: { type: string }	remove
Contained record expressionsContained record expressions A condition can iterate over sub-records stored inside a record — invoices whose JSON lines field contains item 123.self.with_condition(#{"lines.item_id": 123})	remove
Relations defined in RhaiRelations defined in Rhai Executes arbitrary code after a row is retrieved from the table, in the context of the entire row — a Rhai lazy: script in YAML, or a Rust closure that can also do I/O.badge: lazy: | if row.vip { "★ " + row.name } else { row.name }	check_circle

Live updates

Record changedRecord changed An open record updates in place when someone else changes it — the source pushes the change, no polling.	check_circle
Record set changedRecord set changed A filtered grid updates when rows matching its condition change, and a row that stops matching leaves the grid.	check_circle
Table changedTable changed Any insert, update or delete in the table reaches open grids as it happens.	check_circle
Related record changedRelated record changed A change in a related table — an invoice_line — reaches the parent's view, such as invoice.total.	remove

Editing data

Add recordsAdd records Create rows from a form dialog. In a filtered view, new rows are filled in to belong to it.table("order") .insert(#{ id: "o10", client: "c3", total: 55 })	check_circle
Update recordsUpdate records Edit rows in a form dialog. A write through a filtered view can never change a row outside it.table("order").patch("o1", #{ status: "paid" })	check_circle
Delete recordsDelete records Remove rows, after a confirmation step, from a grid or a record view.table("order").where("status", "paid").delete("o2")	check_circle
Atomic importAtomic import A CSV or wizard import lands in one transaction: either every new row is stored or none is, and existing rows are left untouched.let paid = table("order").where("status", "paid"); table("archive").import_from(paid)	check_circle
Bulk modifyBulk modify Change every row of a filtered set in one operation — mark all open orders as shipped — without loading them first.	remove

Custom tables

Tables from custom queriesTables from custom queries A table can be defined by a query instead of a stored table — a Rhai script or a native query — and is read-only.select().from("order") .inner_join("client", "c", expr("c.id = order.client_id"))	remove
Table aggregateTable aggregate A table defined through another table — sales grouped by month, built on orders — inheriting its columns and relations.name: category_totals id_column: category_id columns: total_price: { type: int } sqlite: base: product inherit: columns: [category_id] rhai: | base.clear_fields().field("category_id") .expression(expr("SUM(price) AS total_price")) .group_by(expr("category_id"))	remove
Server-side actionsServer-side actions An action runs inside the data source, such as a stored procedure or function, instead of in the app.	remove

Misc

Auto-IDAuto-ID When the id column is flagged auto, an insert without an id asks the data source to assign one — auto-increment, a generated record id, an ObjectId — and returns it. Without the flag the app mints a UUIDv7 instead, so retries stay idempotent.# order.yaml columns: id: { type: int, flags: [id, auto] } // Rhai — no id, so the data source makes one let id = table("order") .insert(#{ client: "c2", total: 30 });

check_circle

IdempotencyIdempotency By default, every write can be retried safely: a repeated insert or delete changes nothing, and writes through a filtered view stay inside it. An insert that relies on Auto-ID is the exception — retrying it adds a second row.// run twice: same result table("order") .upsert("o10", #{ client: "c3", total: 60 })

check_circle

What stands out

• Faker simulations write into it on a schedule, so grids, charts and logs have moving data to show.
• Live updates are scoped to the vista's query: a row that stops matching arrives as a delete.
• No server, no files — the data lasts as long as the app runs.