Skip to main content

Object and Event Transformations

In Object-Centric Process Mining (OCPM), custom transformations allow you to clean, filter, and shape your raw source data before mapping it to the semantic layer. Depending on your data architecture and performance requirements, you can output your transformations into a standalone database table or map them directly to object and event attributes.

Transformation selection matrix

Use the matrix below to determine the best transformation method for your specific development scenario:

Transformation type

Storage behavior

Best used for

Performance and downstream impact

Table Transformations

See: Table transformations

Creates a new physical database table.

  • Heavy data pre-processing.

  • Complex multi-table JOIN operations.

  • Reusable staging data consumed by multiple downstream objects or events.

High efficiency.

Follows a "build once, reference many" architecture to prevent redundant query execution.

Object transformations

See: Objects and events transformations

Evaluated dynamically during object runtime mapping.

  • Direct 1:1 column mapping from source to object.

  • Basic attribute calculations.

  • Pulling standalone fields from a single source table.

Lightweight.

Ideal for highly localized logic specific to a single business entity.

Event transformations

See: Objects and events transformations

Evaluated dynamically during event runtime mapping.

  • Generating activity timestamps.

  • Defining row-level event triggers (e.g., creating a "Clear Credit Block" event).

Targeted.

Directly populates the activity history of your process logs.

Related topics

Creating table transformations

In Object-Centric Process Mining (OCPM), building an accurate data model requires transforming raw system data before it can be mapped to objects and events. Table Transformations allow you to design, test, and execute custom table-level transformations directly within the Objects & Events interface, eliminating the need to pivot to isolated data integration tools.

For an Analytics Engineer optimizing an Order-to-Cash (O2C) workflow, raw ERP tables often obscure the root causes of process bottlenecks. For example, when analyzing order fulfillment delays, a common business pain point is untracked credit blocks on high-value transactions. If regional databases store block status codes differently, you cannot accurately pinpoint which approvals are delaying shipments.

Table transformations bridge this gap by enabling you to:

  • Target process pain points: Isolate and standardize data anomalies, such as mismatched regional status codes, directly within your OCPM environment.

  • Simplify SQL logic: Eliminate redundant JOIN operations across massive transactional tables by creating a single, clean reference table.

  • Leverage advanced SQL: Centralize Common Table Expressions (CTEs) to isolate specific business segments, such as filtering out low-value noise to focus strictly on high-risk orders.

  • Eliminate orchestration dependencies: You no longer need to orchestrate and coordinate multiple different data jobs with each other to complete pre-processing.

Before you begin

Before you begin, ensure you have:

  • Permissions: Admin access to the Objects and Events dashboard.

  • Source data: Successfully ingested the raw source tables (e.g., SAP, Oracle) required for your query into your Data Pool.

Creating table transformations

To create table transformations using the Objects and Events dashboard:

Step 1: Creating and defining the table transformation

Set up the initial configuration and database naming conventions for your new custom transformation table.

From the Objects and Events dashboard:

  1. Click Transformations.

  2. Click Create.

    Click transformations and then click create.

  3. Select Tables as the transformation type.

  4. Enter a Name and Description for the table using these parameters:

    • Name: This becomes the technical name of the underlying table created in the database during data job execution.

      • Best practice: Use an uppercase, underscore-separated convention (e.g., STG_O2C_ORDER_CLEANED). Avoid spaces and special characters. Do not add environment prefixes (like t_), as Celonis manages these automatically.

    • Description: An optional but highly recommended field used to provide context for other data teams. Use this space to document:

      • The core business logic or process pain point being addressed.

      • The source tables and dependencies involved (e.g., SAP VBAK / VBAP).

      • Key filters applied, such as specific regional or high-value segment exclusions.

    select_table_and_add_name.png

  5. Click Next.

  6. In the SQL Editor workspace, write a standard SELECT statement to define your table transformations (such as dropping columns, changing data types, or joining source tables).

    For example:

    select * from "adrp"

    In this example, "adrp" refers to the standard SAP ERP system table for Business Address Services (Persons). In your actual transformation, replace this with whatever raw staging or source table contains the data you need to clean, filter, or pre-process.

    select_statement.png

  7. Click Execute query selection to run a preview in the transformation console.

    • Expected result: Verify in the lower console panel that your query executes successfully and shows the correct columns and mock data without syntax errors.

  8. Click Save with Validation.

    Celonis will check the query against your active Data Pool schema to ensure all referenced tables and fields exist before saving the asset.

    save_with_validation.png

Step 2: Deploying the OCDM version

After saving your table transformation, you must deploy a new version of your OCDM to make the new table available for object and event mappings.

  1. Click Deploy.

    deploy.png

  2. Create a new draft version, include your transformation, and click Deploy.

    click_deploy.png

For detailed, step-by-step instructions on versioning and deploying your OCDM, see: Versioning and deploying OCDM

Step 3: Referencing the table in subsequent transformations

Once deployed, your custom transformation table functions as a standard data source within your schema. You can reference it in downstream SQL scripts to build out more complex object or event transformations.

Note

Always enclose your custom table name in double quotes (e.g., "STG_O2C_ORDER_CLEANED") to comply with database case-sensitivity rules and ensure smooth execution within the Celonis validation engine.

  1. Create or open a downstream transformation asset (such as an Object Transformation or Event Transformation).

  2. In the SQL Editor workspace, query your custom table by referencing its exact technical name.

    For example, to use your cleaned staging table for an event mapping:

    SELECT 
    "Order_ID",
    "Clearance_Date" AS "EventTime",
    'Clear Credit Block' AS "Activity"
FROM "STG_O2C_ORDER_CLEANED";

  3. Click Execute query selection to verify that the downstream editor successfully reads from your custom table and outputs the expected dataset.

Step 4: Managing and monitoring dependencies

Track the data lineage, validation health, and execution history of your custom table to ensure downstream data integrity.

  1. In the main Transformations menu, use the filter options to isolate your custom table transformations.

    • What to check: Verify the Validation Status (to ensure no schema mismatches) and the Last Run timestamp (to guarantee data freshness).

  2. Click on a specific table transformation to open its details view. Review the dependency graph or reference section to identify exactly which objects, events, or downstream transformations rely on this table.

  3. Before saving any edits or schema updates to an active table transformation, carefully review the system-generated Impact Assessment.

    Caution

    Modifying column names, deleting fields, or changing data types can cause breaking changes downstream. Always verify the validation engine's impact report before committing your changes to a production table.

Related topics

Creating custom transformations for objects and events

Map raw or pre-processed source data directly to specific object types or event activities within the Object-Centric Data Model (OCDM) semantic layer using custom CeloSQL scripts.

Object and event transformations define the runtime mapping logic for your business entities and process activities. Unlike standalone table transformations, which physically materialize data in the database, these transformations map data fields directly to attributes in the semantic layer.

For an Analytics Engineer, mapping directly to objects and events is ideal for localized logic, direct 1:1 data routing, and establishing exact activity timelines. This development environment allows you to:

  • Accelerate development with AI: Use the built-in Code Assistant to automatically generate initial SQL mappings based on your source system (such as SAP or Oracle) and target attribute context.

  • Parameterize queries: Implement global parameters, local script parameters, or specific data connection overrides to dynamically adjust script execution across different environments.

  • Control mapping scope: Build full or partial overwrite scripts, or utilize extension scripts to safely append custom attributes to existing Celonis Catalog objects without modifying standard definitions.

Creating custom transformations

To create custom transformations for either objects or events using the Objects and Events dashboard:

  1. Click Transformations.

  2. Click Create and select either objects or events.

    Click transformations and then click create.

  3. Select create new or start from a template.

  4. Select the object to create the transformation for and then click Next.

    select_object.png

  5. In the SQL editor, select the transformation you want to edit.

    • Celonis transformations can’t be renamed.

    • Custom transformations are given an autogenerated name.

    Code Assistant for SAP and Oracle data connections

    For SAP ECC, S/4 or Oracle EBS/Fusion sources, click Code Assistant to quickly generate an initial transformation script with the AI-powered Transformation Assistant. It uses object, attribute, and source system context to create a custom script you can refine. All transformation types are supported except relationship transformations, and it works with both custom objects/events and Celonis catalog extensions.

    select_attribute_in_SQL_editor.png

  6. Data source: Select the main data source for the business data in the Data source section. Queries run on this data source unless a data connection parameter is used.

    select_data_source.png

  7. Parameters: If applicable, set values for any local parameters used in the transformation:

    parameters.png

    • Global parameters: belong to the workspace. You supply their values in the transformation editor.

    • Local parameters: belong to your script. You supply their values in the transformation editor.

    • Data connections: are specific data connections in the data pool. They override the default data source for the transformation.

  8. Script: If applicable, add a custom script or overwrite script (partial or full).

    • Only one overwrite per script type is allowed.

    • Extension scripts must populate all custom attributes or relationships for an object.

    • Each script opens with a generated SQL template. Remove comments and build a SELECT statement that maps source columns to target attributes.

    • Ensure object and event IDs are unique.

    Script_section.png

  9. Validate script: Use the Preview pane to see required attributes and key types.

    • Insert source columns using the Data Source explorer.

    • Use NULL for unmapped attributes and double quotes for source column names if needed.

    preview_SQL.png

  10. After reviewing your script, click Save or Save with validation:

    • Save: Allows you to return to configure the transformation later.

    • Save with validation: Only validated transformations run as part of data jobs.

After creating a custom validation, you may want to deploy this latest version to development or product. See: Versioning and deploying OCDM.

After deploying custom transformations, you need to run them to create or update objects and events. Running is also required whenever you add new attributes or relationships, ensuring your data stays up to date. See:

Related topics