What is the difference between OBJ and RDB in PEGA?

Difference between OBJ and RDB methods

In PEGA, the difference between OBJ and RDB methods are used to interact with the database, but they differ significantly in how they are implemented and their use cases.

Let’s see the difference between OBJ and RDB methods.

OBJ Methods

OBJ methods are used for operations on PEGA objects (instances of PEGA classes). These methods work with PEGA’s internal data structures and adhere to the platform’s best practices, such as leveraging the data model and declarative processing.

1.Abstraction Layer:

OBJ methods abstract the database details, making the interaction easier but more aligned with PEGA’s data model.

2.Consistency and Integrity:

They ensure data consistency and integrity by following PEGA’s rules and constraints.

3.Declarative Processing:

These methods support declarative processing, such as declare expressions, constraints, and on-change rules.

4.Automatic Locking:

OBJ methods manage record locking automatically to prevent concurrent modifications.


They are optimized for performance within the PEGA platform, though sometimes they may not be as fast as direct SQL for complex queries.


  • Obj-Browse: Retrieves multiple records based on certain criteria.
  • Obj-Open: Opens a specific record.
  • Obj-Save: Saves changes to a record.
  • Obj-Delete: Deletes a specific record.

Below is an activity that we have created to save customer information.

When this activity is called from Work Flow using the utility flow shape and executed, The data that is passed to this activity has been successfully stored in the customer table.

Test Cases: Open Obj-Save Activity and Run, Directly pass parameter values; however, see if the data is retained in the table or not.

The record is not available in the table.

Test Case 1:  It is used to see the “commit.”.

When the activity is called from Flow, Obj-Save is successful, and the commit has been automatically done by the process commander.

If an activity with Obj-Save is called during Work Flow Processing, the process commander automatically performs a commit. That is, there is no need to use “Write Now” or “Commit Method.”.

If an activity with Obj-Save is executed without being part of work flow processing, we have to use “write now” or commit only when “the activity is part of non-transactional processing (not being part of work flow processing).

Difference between Write Now and Commit:

Write Now

Write Now performs an immediate commit on a specific Differ Queue instance of specific Obj-Save.


Commit Methods perform a commit of the entire Differ Queue. Thus, all the queue instances get stored in their tables.

RDB Methods

RDB methods provide a way to execute SQL queries directly on the database. These methods offer more control and flexibility but come with increased responsibility for ensuring data integrity and performance.

Difference between the OBJ and RDB methods
Difference between the OBJ and RDB methods

Direct SQL Execution: RDB methods allow for direct SQL query execution, giving developers control over the exact SQL used.

Flexibility: These methods can be used to perform complex queries and operations that might be cumbersome or impossible with OBJ methods.

Database-Specific: They can be tailored to specific database features and optimizations, potentially improving performance for certain operations.

Manual Management: Developers need to manually handle aspects like transaction management, record locking, and ensuring data consistency.

Performance: Direct SQL can be faster for certain operations, especially complex joins or bulk operations, but improper use can degrade performance.



Executes a SQL SELECT statement to retrieve data.


Executes a SQL SELECT statement to retrieve a single record.


Executes a SQL INSERT or UPDATE statement.


Executes a SQL DELETE statement.

When to Use Each Method

1.OBJ Methods:
  • Work effectively with Pega’s data structure.
  • Take advantage of Pega’s automated processing rules.
  • Maintain data consistency and integrity within Pega’s framework.
2.RDB Methods:
  • When you need to perform complex SQL operations that are not feasible with OBJ methods.
  • When optimizing performance for specific queries that can benefit from direct SQL execution,.
  • When interacting with external databases or performing operations that require precise control over the SQL.

Technical Aspects:

  • Difference between OBJ and RDB methods:  OBJ methods offer transactional control (deferred save, rollback) while RDB methods auto-commit immediately.
  • SQL Flexibility: Allows the execution of custom SQL queries, providing full control over database operations.
  • Database Interaction: Can interact directly with the database, bypassing PEGA’s abstraction layers.
  • Complex Queries: capable of executing complex joins, subqueries, and other advanced SQL features not easily accomplished with OBJ methods.
  • External Databases: Suitable for integrating with external databases that are not part of PEGA’s internal data structure.

Practical Use Cases:

  • Complex Reporting: Generating complex reports that require intricate SQL queries.
  • Bulk Data Operations: performing bulk inserts, updates, or deletes more efficiently than OBJ methods.
  • Custom Integrations: Interfacing with legacy systems or external databases using custom SQL.


  • Performance: Potentially higher performance for certain operations due to direct SQL execution.
  • Flexibility: greater flexibility in defining however, executing database operations.
  • Advanced Features: Ability to leverage database-specific features  however, optimizations.


  • Complexity: Requires a good understanding of SQL and database management.
  • Risk: There is a higher risk of data corruption and inconsistency if not managed properly, especially in multi-user environments.
  • Manual Management: Requires manual handling of transactions, locking, and error management.

Using RDB Methods:

  • SQL Optimization: Write optimized SQL queries to improve performance and reduce database load.
  • Transaction Management: Carefully manage transactions to ensure data consistency and avoid conflicts.
  • Security: Implement robust security practices to prevent SQL injection and unauthorized access.
  • Use Where Necessary: Reserve RDB methods for scenarios where OBJ methods are insufficient, such as complex data operations or integration with external databases.


In PEGA, choosing difference between OBJ and RDB methods depends on the specific requirements of the task at hand. Pega’s OBJ methods elevate the level of abstraction, simplify use, and integrate more seamlessly with its declarative processing. This makes them the ideal choice for handling standard operations within the Pega environment.

For more details on technology, click here.

Leave a Comment