OCPQ is a framework and graphical tool for querying object-centric process data. Traditional process querying relies on case-centric event data, which often cannot represent the multiple interacting objects and perspectives of real-life processes accurately. Querying individual events or cases is no longer suficient for object-centric data. The OCPQ tool allows more flexible queries for arbitrary combinations of objects and events. Queries are represented graphically as node trees in the OCPQ tool, enabling constructing complex queries visually and without programming experience. The query backend of the tool is implemented in the Rust programming language with a focus on fast execution.
combinations of objects and events, so-called bindings, by specifying their object and event types, and any additional filter predicates, e.g., that there should be event-to-object (E2O) or object-to-object (O2O) relationships between them. In this demo paper, we present the OCPQ tool implementation in more detail, including new features like general binding annotations, OCEL filtering, or early-stopping on overload. The OCPQ tool allows visually modeling and evaluating object-centric process queries on a loaded object-centric dataset. As the result of each query or subquery, an output table can be explored, where individual entries correspond to bindings, i.e., combinations of event or object instances, as defined by the query. Each binding row can additionally be annotated with additional labels or information, for example a violation indicator or a key performance indicator (KPI) value. Figure 1 shows an example OCPQ query with integrated constraints. The graphical query is shown on the left and the output table of the root node is shown on the right.
The remainder of this paper is structured as follows: First, we present an overview of the OCPQ tool and its capabilities in Section 2. Next, in Section 3, we provide a brief description of the OCPQ tool’s implementation. Finally, we conclude this paper in Section 4, also giving an outlook on future work.
The OCPQ tool is available for download at https://ocpq.aarkue.eu, where the documentation can also be found. The source code of OCPQ is publicly available at https://github.com/aarkue/ocpq. A short demo video of the tool is available at https://github.com/aarkue/ocpq-demo.
Initially, an object-centric event log has to be imported. OCPQ supports the OCEL 2.0
specification [
e1: Filterse1 o1 Labels Constraints
A
B 71196 Object Variables 2780
Event Variables
e1: payment reminder Filterse1 o1 Labels Constraints 2.1. Features After importing an OCEL file, the dataset can be explored using queries, constraints, or graph visualizations of objects, events, and their relationships.
Visual Query and Constraint Tree Editor The query editor appears after creating a new query and can be used to create and link multiple query nodes to form a query tree. This tree structure allows easily modeling and nesting of subqueries (e.g., a subquery for all items in an order). In each node, event and object variables can be added, as well as filter predicates, determining what combinations of object and event instances to consider. For example, the E2O iflter predicate specifies that there should be an event-to-object relationship between variable values. Figure 1 shows the user interface of the query tree editor on the left. The top node queries all combinations of orders objects and corresponding place order events. For that, the node introduces two variables o1 (for the orders object) and e1 (for the place order event), and also has one E2O filter predicate (visualized as a link icon), specifying that the values of o1 and e1 should be in an E2O relationship. Queries can be evaluated using the play button on the top right. After evaluation, the number of queried bindings is displayed in the top right for every node, indicated with # as shown in Figure 1. Analogously to filters, predicates can also be used for constraints. For that, bindings that fulfill all constraint predicates are considered satisfied, and violated otherwise. If constraint predicates are used, the violation percentage of a node is used to determine its color. For instance, in Figure 1, the root node is colored yellow because it is violated in around 30% of bindings.
General Annotations and KPIs The violation status is not the only annotation that can be added to output bindings. For example, KPIs, like the total order volume or the number of payment reminders per customer, can be augmented to each output binding row. To allow general annotations, OCPQ uses the Common Expression Language1. In Figure 2, an example OCPQ query calculating the number of payment reminders per customer is shown.
All output tables can be explored in the tool directly, or also exported as CSV or XLSX files for usage in other tools and applications, e.g., as input for machine learning techniques. OCEL Filtering Filtering OCEL datasets and exporting the resulting subset again is also supported in OCQP. The filtering is implemented using three diferent configuration modes for each element (i.e., object, event, or relation): Included (green) which specifies that the element should be included in the output. Excluded (red) which specifies that the element should be explicitly excluded, even if it is included somewhere else. Ignored (gray) which does not influence the output. On the right of Figure 2, a filtering example of OCPQ is shown. Other Features Apart from the previously mentioned functionality, OCPQ also has some additional features. For example, it supports automatic discovery for some types of constraints based on an input OCEL. Moreover, some safeguards are in place to stop execution of overloaded queries early on and inform the user. For more information and feature descriptions, we refer interested readers to the website of the tool.
The OCPQ implementation is based on the Rust4PM software library presented in [
In this paper, we presented the OCPQ tool for querying object-centric process data. As handling
object-centric processes requires more flexibility, OCPQ not only allows querying individual
1https://cel.dev/
2The desktop application uses the tauri framework from https://github.com/tauri-apps/tauri.
events or objects, but any combination of objects and events. Through a graphical constraint
editor, nested queries can be modeled in a tree structure without programming experience. The
result of queries can be explored inside the tool, and can also be exported. Constraints and
other annotations can be added to add additional information and labels to each output binding.
Maturity The first main version of the OCPQ tool was published in September 2024 as v0.5.0.
Since then, more than 15 version updates have been published, including additional functionality,
like allowing general annotation labels, filtering OCEL files, or macOS support. The tool is
stable, and installers for Windows, Linux, and macOS are automatically built for every release.
As described in more detail in [
The authors have not employed any Generative AI tools.