ltrim and rtrim

Use ltrim & rtrim while loading the records from the flat file to the staging table itself. This will
avoid adding them in the Joins while going for subsequent Mappings

Foreign Key Constraint

In set mode, manipulate foreign key constraints so that rows are inserted faster while still
preserving referential integrity.

Inline View Technique for faster loading

OWB automatically detects the common scenario where one or more custom transformations are
applied to multiple, joined tables that are located in a remote database. First join the tables in the
source database and then apply the transformation functions on the (much reduced) result set in
the target database. OWB forces the join on the remote database by means of an inline view. On
average this feature brings a fivefold performance increase.

Bulk Binding

In row mode, use bulk binding for reads and writes. Bulk binds improve the performance of
PL/SQL statements. This feature significantly increases loading performance.

Partition Exchange Loading

Partition Exchange Loading enables parallel loading of data into partitioned tables, and avoids
implicit index maintenance by loading a temporary table and then switching it with a partition. It
is particularly efficient at loading data into a target table that already holds a large amount of
data. This technique can be up to ten times faster than conventional partition loading.

Automated Bitmap index creation

Bitmap indexing increases performance by enabling star query transformation. Warehouse

Repository installation

It’s always a good practice to install the OWB repository and Run Time Audit tables in different
schemas for better administration.

Hardware

The server hosting INFOMATICA gives good performance when minimum 128 MB RAM is
used. The same is the case for the client side also. Refer to suggestions from vendor in this
regard.
init.ora configuration

In init.ora file on the server, the value of max open cursor should be more than 300.

Projects

If the staging and target tables are residing in two different instances, then it’s better to have two
different projects to handle this logic.

Set Based Inserts

Wherever set-based inserts are involved, direct path insert should be invoked using the /*+
APPEND */ optimizer hint. Direct-path insert is one of the most effective tools the Oracle ETL
developer has available. By avoiding logging of the inserts, transformation runtimes can be
reduced.

Trailing Null cols

Use trailing null cols while invoking the SQL*Loader otherwise it will give an error” Record
Not Found” till the end of the file.

Informatica Tips: Set based implementation

Inthe Type 2 SCD approach ,where you need to look for the existence of data in the target before
inserting, if you use set-based, and run the package you will get an ORA-04091 error stating
"Table ‘XXX’ is mutating, trigger/function may not see it." This error occurs because you are
inserting into, and the function is selecting from, the target table in the same set-based statement.
(fig1)
Though ,the mapping will function properly when deployed as a row-based package, the
performance of the row-based implementation may be unacceptable when considering the
volume of rows being processed and the size of the ETL window.
So, an alternative approach is available that will allow you to deploy the mapping using a set-
based implementation. First, you will need to create a staging table that looks exactly like the
target table; then, substitute the staging table for the target table in the mapping. The Type 2
SCD function will still do the lookup on the target table, but the inserts will be redirected to the
staging table. A second mapping will then be required that inserts the new rows in the staging
table into the target table.

Informatica Performance Improvement Tips

We often come across situations where Data Transformation Manager (DTM) takes
more time to read from Source or when writing in to a Target. Following
standards/guidelines can improve the overall performance.

• Use Source Qualifier if the Source tables reside in the same schema
• Make use of Source Qualifier “Filter” Properties if the Source type is
Relational.

• If the subsequent sessions are doing lookup on the same table, use persistent
cache in the first session. Data remains in the Cache and available for the
subsequent session for usage.

• Use flags as integer, as the integer comparison is faster than the string
comparison.

• Use tables with lesser number of records as master table for joins.

• While reading from Flat files, define the appropriate data type instead of
reading as String and converting.

• Have all Ports that are required connected to Subsequent Transformations

• Suppress ORDER BY using the ‘-‘ at the end of the query in Lookup
Transformations

• Minimize the number of Update strategies.

• Group by simple columns in transformations like Aggregate, Source Qualifier

• Use Router transformation in place of multiple Filter transformations.

• Turn off the Verbose Logging while moving the mappings to UAT/Production
environment.

• For large volume of data drop index before loading and recreate indexes after
load.

• For large of volume of records Use Bulk load Increase the commit interval to
a higher value large volume of data

• Set ‘Commit on Target’ in the sessions