- Introduction
- Getting started
- Building with Maestro BPMN
- Understanding Maestro BPMN modeling
- Opening the modeling canvas
- Modeling your process
- Aligning and connecting BPMN elements
- Autopilot for Maestro (Preview)
- Process Repository
- Implementing a simple BPMN process
- Implementing a complex BPMN process
- Debugging
- Simulating
- Evaluations (Preview)
- Common implementation scenarios
- Building with Maestro Case
- Introduction to Maestro Case
- Maestro BPMN vs. Maestro Case: when to use case management
- The Maestro Case lifecycle: from event trigger to app experience
- Build your first case with Maestro Case
- Build a Maestro Case with a coding agent (preview)
- Defining case keys (system vs. external)
- Establishing task I/O and write-back contracts
- Exit rules and early stage termination
- Modeling primary and secondary stages
- Triggering a case from Data Fabric
- Implementing stage-level personas and permissions
- Setting SLAs and automated escalation rules
- Configuring a rework loop (re-entry)
- Configuring and testing the Case Manager Agent (preview)
- Case Manager input and output contract
- Maestro Case component dictionary
- Building with Maestro Flow
- Maestro Automate
- Integrations
- Operating
- Monitoring
- Optimizing
- Reference information
Query entity records node for reading one or more records from a Data Fabric entity in a Flow, without an Integration Service connection.
Reads one or more records from a Data Fabric entity. This is a native Flow node — it doesn't require an Integration Service (IS) connection. It works with existing entities from the Data Fabric platform — both tenant and folder entities — and with entities defined in a VS Code solution. Refer to Entities in VS Code.
Configuration
| Field | Required | Description |
|---|---|---|
| Data Fabric entity | Yes | The entity to query. Select Refresh schema if the entity's fields changed since you added the node. |
| Records to return | Yes | Single record returns one record and fails if the filter matches more than one. Multiple records returns an array of matching records. |
| Filter condition(s) | No | One or more field/operator/value conditions, combined with All (AND) or Any (OR). |
| Sort by (Multiple records only) | No | The field to sort results by, and direction (Ascending or Descending). Without a sort, the query can return a different set of records each time. |
| Records to skip (Multiple records only) | No | Number of matching records to skip before returning results. Default 0. |
| Record limit (Multiple records only) | No | Maximum number of records to return. Default 100, maximum 1000. |
Within Filter condition(s), select Add condition for another condition at the same level, or Add group to nest a condition group with its own AND/OR logic.
This node doesn't support the Error handling tab.
Output
For Single record, the output fields mirror the entity's schema directly. For Multiple records, the output is a results array, with each item mirroring the entity's schema. Access them downstream as $vars.<nodeId>.output.<fieldName> (single record) or $vars.<nodeId>.output.results[<index>].<fieldName> (multiple records).
Live reference behavior
The output is a live reference to the query, not a stored copy of the results. Every expression, condition, or script that reads it re-runs the query at that moment, so it always sees the entity's current data. The LIVE QUERY chip in the schema tree marks outputs that behave this way.
For example, if a Query entity records node named Find ticket returns a ticket whose status is Open, and a later node in the flow sets that ticket to Closed, an expression reading $vars.Find ticket.output.Status after that point returns Closed — not the Open value the query first saw. A stored copy would still say Open.
Update entity record and Delete entity record set to Entity reference build on this: they act on the record this query found, without re-specifying the entity and filter.
Loop and data-transform collections are the exception. They read a snapshot of the results taken when the node ran, rather than re-running the query.