Combination of Operating Mode and Commit Strategy

If you want to populate a source into multiple targets, you may also want to ensure that every row from the source affects all targets uniformly (or separately). Let's consider the Example Mapping below. If a row from SOURCE causes different changes in multiple targets (TARGET_1, TARGET_2 and TARGET_3), for example, it can be successfully inserted into TARGET_1 and TARGET_3, but failed to be inserted into TARGET_2, and the current Mapping Property TLO (target load order) is "TARGET_1 -> TARGET_2 -> TARGET_3".

What should Oracle Warehouse Builder do, in order to commit the appropriate data to all affected targets at the same time? If it doesn't behave as you intended, the data could become inaccurate and possibly unusable.

                                              clip_image002

Example Mapping

In OWB, we can use Mapping Configuration Commit Strategies and Operating Modes together to achieve this kind of requirements.

Below we will explore the combination of these two features and how they affect the results in the target tables

Before going to the example, let's review some of the terms we will be using (Details can be found in white paper Oracle® Warehouse Builder Data Modeling, ETL, and Data Quality Guide11g Release 2):

Operating Modes:

Set-Based Mode: Warehouse Builder generates a single SQL statement that processes all data and performs all operations.

Row-Based Mode: Warehouse Builder generates statements that process data row by row. The select statement is in a SQL cursor. All subsequent statements are PL/SQL.

Row-Based (Target Only) Mode: Warehouse Builder generates a cursor select statement and attempts to include as many operations as possible in the cursor. For each target, Warehouse Builder inserts each row into the target separately.

Commit Strategies:

Automatic: Warehouse Builder loads and then automatically commits data based on the mapping design. If the mapping has multiple targets, Warehouse Builder commits and rolls back each target separately and independently of other targets. Use the automatic commit when the consequences of multiple targets being loaded unequally are not great or are irrelevant.

Automatic correlated: It is a specialized type of automatic commit that applies to PL/SQL mappings with multiple targets only. Warehouse Builder considers all targets collectively and commits or rolls back data uniformly across all targets. Use the correlated commit when it is important to ensure that every row in the source affects all affected targets uniformly.

Manual: select manual commit control for PL/SQL mappings when you want to interject complex business logic, perform validations, or run other mappings before committing data.

Combination of the commit strategy and operating mode

To understand the effects of each combination of operating mode and commit strategy, I'll illustrate using the following example Mapping.

Firstly we insert 100 rows into the SOURCE table and make sure that the 99th row and 100th row have the same ID value. And then we create a unique key constraint on ID column for TARGET_2 table. So while running the example mapping, OWB tries to load all 100 rows to each of the targets. But the mapping should fail to load the 100th row to TARGET_2, because it will violate the unique key constraint of table TARGET_2.

With different combinations of Commit Strategy and Operating Mode, here are the results

Set-based/ Correlated Commit:

Configuration of Example mapping:

                                                    clip_image004

Result:

                                                     clip_image006

What's happening:

A single error anywhere in the mapping triggers the rollback of all data. OWB encounters the error inserting into Target_2, it reports an error for the table and does not load the row. OWB rolls back all the rows inserted into Target_1 and does not attempt to load rows to Target_3. No rows are added to any of the target tables.

Row-based/ Correlated Commit:

Configuration of Example mapping:

                                                  clip_image008

Result:

                                                 clip_image010

What's happening:

OWB evaluates each row separately and loads it to all three targets. Loading continues in this way until OWB encounters an error loading row 100th to Target_2. OWB reports the error and does not load the row. It rolls back the row 100th previously inserted into Target_1 and does not attempt to load row 100 to Target_3. Then, if there are remaining rows, OWB will continue loading them, resuming with loading rows to Target_1. The mapping completes with 99 rows inserted into each target.

Set-based/ Automatic Commit:

Configuration of Example mapping:

clip_image012

Result:

clip_image014

What's happening:

When OWB encounters the error inserting into Target_2, it does not load any rows and reports an error for the table. It does, however, continue to insert rows into Target_3 and does not roll back the rows previously inserted into Target_1. The mapping completes with one error message for Target_2, no rows inserted into Target_2, and 100 rows inserted into Target_1 and Target_3 separately.

Row-based/Automatic Commit:

Configuration of Example mapping:

clip_image016

Result:

clip_image018

What's happening:

OWB evaluates each row separately for loading into the targets. Loading continues in this way until OWB encounters an error loading row 100 to Target_2 and reports the error. OWB does not roll back row 100th from Target_1, does insert it into Target_3. If there are remaining rows, it will continue to load them. The mapping completes with 99 rows inserted into Target_2 and 100 rows inserted into each of the other targets.

Note:

Automatic Correlated commit is not applicable for row-based (target only). If you design a mapping with the row-based (target only) and correlated commit combination, OWB runs the mapping but does not perform the correlated commit.

In set-based mode, correlated commit may impact the size of your rollback segments. Space for rollback segments may be a concern when you merge data (insert/update or update/insert). Correlated commit operates transparently with PL/SQL bulk processing code. The correlated commit strategy is not available for mappings run in any mode that are configured for Partition Exchange Loading or that include a Queue, Match Merge, or Table Function operator.

If you want to practice in your own environment, you can follow the steps:

1. Import the MDL file: commit_operating_mode.mdl

2. Fix the location for oracle module ORCL and deploy all tables under it.

3. Insert sample records into SOURCE table, using below plsql code:

begin

    for i in 1..99

    loop

        insert into source values(i, 'col_'||i);

    end loop;

    insert into source values(99, 'col_99');

end;

4. Configure MAPPING_1 to any combinations of operating mode and commit strategy you want to test. And make sure feature TLO of mapping is open.

5. Deploy Mapping "MAPPING_1".

6. Run the mapping and check the result.

Comments:

Hi Kevin, I really learn from your post. Thank you! Regards, Swing

Posted by Swing Zhou on April 26, 2010 at 06:11 PM PDT #

hi,this was very useful!
But what happens if you run the mapping in row-based(only target ) and use automatic commit? It will execute faster? If it encounters an error on table 1 will it skip the specific row for that table but insert it into the other 2 then continue to add rows into all 3 tables?

Posted by guest on March 12, 2013 at 03:23 AM PDT #

Hi Alexandra

Yes if there is an error it will process the row for the other targets and then go on to the next row.

Cheers
David

Posted by guest on March 20, 2013 at 02:31 PM PDT #

Post a Comment:
  • HTML Syntax: NOT allowed
About

ETL, CDC, Real-Time DI and Data Quality for the Oracle Database from the inside.

Search

Archives
« April 2014
SunMonTueWedThuFriSat
  
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
   
       
Today