Welcome to Scribd, the world's digital library. Read, publish, and share books and documents. See more
Download
Standard view
Full view
of .
Save to My Library
Look up keyword or section
Like this
136Activity

Table Of Contents

Informatica Knowledge Base
Informatica Global Customer Support
Overview
Active Transformations
Passive Transformations
Unconnected Transformations
Transformation Descriptions
Creating a Transformation
Configuring Transformations
Working with Ports
Creating Ports
Linking Ports
Multi-Group Transformations
Working with Expressions
Using the Expression Editor
Using Local Variables
Temporarily Store Data and Simplify Complex Expressions
Store Values Across Rows
Capture Values from Stored Procedures
Guidelines for Configuring Variable Ports
Using Default Values for Ports
Entering User-Defined Default Values
Entering User-Defined Default Input Values
Entering User-Defined Default Output Values
General Rules for Default Values
Entering and Validating Default Values
Configuring Tracing Level in Transformations
Reusable Transformations
Instances and Inherited Changes
Mapping Variables in Expressions
Creating Reusable Transformations
Promoting Non-Reusable Transformations
Creating Non-Reusable Instances of Reusable Transformations
Adding Reusable Transformations to Mappings
Modifying a Reusable Transformation
Components of the Aggregator Transformation
Configuring Aggregator Transformation Properties
Configuring Aggregator Transformation Ports
Configuring Aggregate Caches
Aggregate Expressions
Aggregate Functions
Nested Aggregate Functions
Conditional Clauses
Non-Aggregate Functions
Null Values in Aggregate Functions
Group By Ports
Creating Groups and Ports
Editing Groups and Ports
Defining Port Relationships
Working with Port Attributes
Custom Transformation Properties
Setting the Update Strategy
Working with Thread-Specific Procedure Code
Working with Transaction Control
Transformation Scope
Generate Transaction
Working with Transaction Boundaries
Blocking Input Data
Writing the Procedure Code to Block Data
Configuring Custom Transformations as Blocking Transformations
Validating Mappings with Custom Transformations
Working with Procedure Properties
Creating Custom Transformation Procedures
Step 1. Create the Custom Transformation
Step 2. Generate the C Files
Step 3. Fill Out the Code with the Transformation Logic
Step 4. Build the Module
Step 5. Create a Mapping
Step 6. Run the Session in a Workflow
Working with Handles
Function Reference
Working with Rows
Generated Functions
3.Deinitialization functions
Initialization Functions
Notification Functions
Deinitialization Functions
API Functions
Set Data Access Mode Function
Navigation Functions
Property Functions
Rebind Datatype Functions
Data Handling Functions (Row-Based Mode)
Set Pass-Through Port Function
Output Notification Function
Data Boundary Output Notification Function
Error Functions
Session Log Message Functions
Increment Error Count Function
Is Terminated Function
Blocking Functions
Pointer Functions
Change String Mode Function
Set Data Code Page Function
Row Strategy Functions (Row-Based Mode)
Change Default Row Strategy Function
Array-Based API Functions
Maximum Number of Rows Functions
Number of Rows Functions
Is Row Valid Function
Data Handling Functions (Array-Based Mode)
Row Strategy Functions (Array-Based Mode)
Set Input Error Row Functions
Data Masking Transformation Overview
Masking Properties
Locale
Masking Type
Seed
Associated O/P
Key Masking
Masking String Values
Masking Numeric Values
Masking Datetime Values
Masking with Mapping Parameters
Random Masking
Masking Date Values
Applying Masking Rules
Mask Format
Source String Characters
Result String Replacement Characters
Range
Blurring
Expression Masking
Special Mask Formats
♦Social Security numbers
Social Security Numbers
Credit Card Numbers
Phone Numbers
URLs
Email Addresses
IP Addresses
Default Value File
Rules and Guidelines
Name and Address Lookup Files
Substituting Data with the Lookup Transformation
Masking Data with an Expression Transformation
Expression Transformation Components
Configuring Ports
Calculating Values
Creating an Expression Transformation
External Procedure Transformation
External Procedures and External Procedure Transformations
External Procedure Transformation Properties
COM Versus Informatica External Procedures
The BankSoft Example
Configuring External Procedure Transformation Properties
Developing COM Procedures
Steps for Creating a COM Procedure
COM External Procedure Server Type
Using Visual C++ to Develop COM Procedures
Developing COM Procedures with Visual Basic
Developing Informatica External Procedures
Step 1. Create the External Procedure Transformation
Step 2. Generate the C++ Files
Step 3. Fill Out the Method Stub with Implementation
Step 4. Building the Module
Step 6. Run the Session
Distributing External Procedures
Distributing COM Procedures
Distributing Informatica Modules
Development Notes
COM Datatypes
Row-Level Procedures
Return Values from Procedures
Exceptions in Procedure Calls
Memory Management for Procedures
Wrapper Classes for Pre-Existing C/C++ Libraries or VB Functions
Generating Error and Tracing Messages
Unconnected External Procedure Transformations
Initializing COM and Informatica Modules
Other Files Distributed and Used in TX
Service Process Variables in Initialization Properties
External Procedure Interfaces
Dispatch Function
External Procedure Function
Property Access Functions
Parameter Access Functions
Code Page Access Functions
Transformation Name Access Functions
Procedure Access Functions
Partition Related Functions
Tracing Level Function
Filter Transformation Components
Configuring Filter Transformation Ports
Filter Condition
Filtering Rows with Null Values
Steps to Create a Filter Transformation
Authentication
Connecting to the HTTP Server
Creating an HTTP Transformation
Configuring the Properties Tab
Configuring the HTTP Tab
Selecting a Method
Configuring Groups and Ports
Configuring a URL
Examples
GET Example
POST Example
SIMPLE POST Example
Java Transformation
Steps to Define a Java Transformation
Active and Passive Java Transformations
Datatype Conversion
Using the Java Code Tab
Setting Default Port Values
Configuring Java Transformation Properties
Developing Java Code
Creating Java Code Snippets
Importing Java Packages
Defining Helper Code
On Input Row Tab
On End of Data Tab
On Receiving Transaction Tab
Using Java Code to Parse a Flat File
Configuring Java Transformation Settings
Configuring the Classpath
Enabling High Precision
Processing Subseconds
Compiling a Java Transformation
Fixing Compilation Errors
Locating the Source of Compilation Errors
Identifying Compilation Errors
Java Transformation API Methods
commit
failSession
generateRow
getInRowType
incrementErrorCount
isNull
logError
logInfo
rollBack
setNull
setOutRowType
Expression Function Types
Using the Define Expression Dialog Box
Step 1. Configure the Function
Step 2. Create and Validate the Expression
Step 3. Generate Java Code for the Expression
Steps to Create an Expression and Generate Java Code
Java Expression Templates
Working with the Simple Interface
invokeJExpression
Simple Interface Example
Working with the Advanced Interface
Steps to Invoke an Expression with the Advanced Interface
Rules and Guidelines for Working with the Advanced Interface
EDataType Class
JExprParamMetadata Class
defineJExpression
JExpression Class
Advanced Interface Example
JExpression API Reference
invoke
getResultDataType
getResultMetadata
isResultNull
getInt
getDouble
getLong
getStringBuffer
getBytes
Step 1. Import the Mapping
Step 2. Create Transformation and Configure Ports
Step 3. Enter Java Code
Import Packages Tab
Helper Code Tab
Step 4. Compile the Java Code
Step 5. Create a Session and Workflow
Sample Data
Working with the Joiner Transformation
Joiner Transformation Properties
Defining a Join Condition
Defining the Join Type
Normal Join
Master Outer Join
Detail Outer Join
Full Outer Join
Configuring the Sort Order
Adding Transformations to the Mapping
Configuring the Joiner Transformation
Defining the Join Condition
Joining Data from a Single Source
♦Join two branches of the same pipeline
Joining Two Branches of the Same Pipeline
Joining Two Instances of the Same Source
Guidelines
Blocking the Source Pipelines
Unsorted Joiner Transformation
Sorted Joiner Transformation
Working with Transactions
Preserving Transaction Boundaries for a Single Pipeline
Preserving Transaction Boundaries in the Detail Pipeline
Dropping Transaction Boundaries for Two Pipelines
Creating a Joiner Transformation
Lookup Source Types
Relational Lookups
Flat File Lookups
Pipeline Lookups
Connected and Unconnected Lookups
Connected Lookup Unconnected Lookup
Connected Lookup Transformation
Unconnected Lookup Transformation
Lookup Components
Lookup Source
Lookup Ports
♦“Lookup Properties” on page 227
Lookup Properties
Configuring Lookup Properties in a Session
Lookup Query
Default Lookup Query
Overriding the Lookup Query
Filtering Lookup Source Rows
Lookup Condition
Uncached or Static Cache
Dynamic Cache
Handling Multiple Matches
Configuring Unconnected Lookup Transformations
Step 1. Add Input Ports
Step 2. Add the Lookup Condition
Step 3. Designate a Return Value
Step 4. Call the Lookup Through an Expression
Creating a Lookup Transformation
♦“Creating a Reusable Pipeline Lookup Transformation” on page 241
♦“Creating a Non-Reusable Pipeline Lookup Transformation” on page 242
Creating a Reusable Pipeline Lookup Transformation
Creating a Non-Reusable Pipeline Lookup Transformation
Cache Comparison
Building Connected Lookup Caches
Sequential Caches
Concurrent Caches
Using a Persistent Lookup Cache
Using a Non-Persistent Cache
Using a Persistent Cache
Rebuilding the Lookup Cache
Working with an Uncached Lookup or Static Cache
Sharing the Lookup Cache
Sharing an Unnamed Lookup Cache
Sharing a Named Lookup Cache
Dynamic Lookup Properties
NewLookupRows
Associated Input Ports
Null Values
Ignore Ports in Comparison
SQL Override
Lookup Transformation Values
Initial Cache Values
Input Values
Lookup Values
Output Values
Updating the Dynamic Lookup Cache
Configuring the Upstream Update Strategy Transformation
Configuring the Lookup Transformation
Ports Tab
Properties Tab
Normalizer Tab
Normalizer Transformation Generated Keys
Storing Generated Key Values
Changing the Generated Key Values
VSAM Normalizer Transformation
VSAM Normalizer Ports Tab
VSAM Normalizer Tab
Steps to Create a VSAM Normalizer Transformation
Pipeline Normalizer Transformation
Pipeline Normalizer Ports Tab
Pipeline Normalizer Tab
Steps to Create a Pipeline Normalizer Transformation
Using a Normalizer Transformation in a Mapping
Generating Key Values
Ranking String Values
Rank Caches
Rank Transformation Properties
Ports in a Rank Transformation
Rank Index
Defining Groups
Creating a Rank Transformation
Working with Groups
Input Group
Output Groups
Using Group Filter Conditions
Adding Groups
Connecting Router Transformations in a Mapping
Creating a Router Transformation
Common Uses
Creating Keys
Replacing Missing Values
Sequence Generator Ports
NEXTVAL
CURRVAL
Transformation Properties
Start Value and Cycle
Increment By
End Value
Current Value
Number of Cached Values
Reset
Creating a Sequence Generator Transformation
Sorting Data
Sorter Transformation Properties
Sorter Cache Size
Case Sensitive
Work Directory
Distinct Output Rows
Tracing Level
Null Treated Low
Creating a Sorter Transformation
Transformation Datatypes
Target Load Order
Datetime Values
Parameters and Variables
Source Qualifier Transformation Properties
Default Query
Viewing the Default Query
Overriding the Default Query
Joining Source Data
Default Join
Custom Joins
Heterogeneous Joins
Creating Key Relationships
Adding an SQL Query
Entering a User-Defined Join
Outer Join Support
Informatica Join Syntax
Normal Join Syntax
Left Outer Join Syntax
Creating an Outer Join
Common Database Syntax Restrictions
Entering a Source Filter
Using Sorted Ports
Select Distinct
Overriding Select Distinct in the Session
Adding Pre- and Post-Session SQL Commands
Creating a Source Qualifier Transformation
Creating a Source Qualifier Transformation By Default
Creating a Source Qualifier Transformation Manually
Configuring Source Qualifier Transformation Options
Database Connections Rules and Guidelines
Session Processing
♦“High Availability” on page 349
Transaction Control
High Availability
Input Row to Output Row Cardinality
Query Statement Processing
Number of Rows Affected
Maximum Output Row Count
Understanding Error Rows
Continuing on SQL Error
SQL Transformation Properties
SQL Settings Tab
SQL Ports Tab
SQL Statements
Creating an SQL Transformation
Dynamic Update Example
Defining the Source File
Creating a Target Definition
Creating the Database Table
Configuring the Expression Transformation
Defining the SQL Transformation
Configuring Session Attributes
Target Data Results
Dynamic Connection Example
Creating the Database Tables
Creating the Database Connections
Stored Procedure Transformation
Input and Output Data
♦Input/output parameters
Input/Output Parameters
Connected and Unconnected
Specifying when the Stored Procedure Runs
Using a Stored Procedure in a Mapping
Writing a Stored Procedure
Sample Stored Procedure
Creating a Stored Procedure Transformation
Importing Stored Procedures
Manually Creating Stored Procedure Transformations
Setting Options for the Stored Procedure
Changing the Stored Procedure
Configuring a Connected Transformation
Configuring an Unconnected Transformation
Calling a Stored Procedure From an Expression
Calling a Pre- or Post-Session Stored Procedure
Error Handling
Pre-Session Errors
Post-Session Errors
Session Errors
Supported Databases
SQL Declaration
Parameter Types
Input/Output Port in Mapping
Type of Return Value Supported
Expression Rules
Using a Union Transformation in a Mapping
Configuring the Unstructured Data Option
Configuring the Data Transformation Repository Directory
Data Transformation Service Types
Unstructured Data Transformation Components
UDT Settings Tab
Viewing Status Tracing Messages
Unstructured Data Transformation Ports
Ports by Input and Output Type
Adding Ports
Creating Ports From a Data Transformation Service
Defining a Service Name
Relational Hierarchies
Exporting the Hierarchy Schema
Mappings
Parsing Word Documents for Relational Tables
Creating an Excel Sheet from XML
Parsing Word Documents and Returning A Split XML File
Steps to Create an Unstructured Data Transformation
Flagging Rows Within a Mapping
Forwarding Rejected Rows
Update Strategy Expressions
Aggregator and Update Strategy Transformations
Lookup and Update Strategy Transformations
Setting the Update Strategy for a Session
Specifying an Operation for All Rows
Specifying Operations for Individual Target Tables
Update Strategy Checklist
XML Source Qualifier Transformation
XML Parser Transformation
XML Generator Transformation Overview
0 of .
Results for:
No results containing your search query
P. 1
Transformation Guide

Transformation Guide

Ratings: (0)|Views: 30,791|Likes:
Published by ramasikhinam
INFORMATIICA 8.0
INFORMATIICA 8.0

More info:

Published by: ramasikhinam on Dec 13, 2009
Copyright:Attribution Non-commercial

Availability:

Read on Scribd mobile: iPhone, iPad and Android.
download as PDF, TXT or read online from Scribd
See more
See less

12/30/2012

pdf

text

original

You're Reading a Free Preview
Pages 10 to 49 are not shown in this preview.
You're Reading a Free Preview
Pages 59 to 283 are not shown in this preview.
You're Reading a Free Preview
Pages 293 to 359 are not shown in this preview.
You're Reading a Free Preview
Pages 369 to 406 are not shown in this preview.
You're Reading a Free Preview
Pages 416 to 458 are not shown in this preview.

Activity (136)

You've already reviewed this. Edit your review.
1 hundred reads
1 thousand reads
addubey2 liked this
rohit01234567890 liked this
iamkatherbasha liked this
swayam liked this
anilkonakatiamar liked this
Vasudha Sayee liked this

You're Reading a Free Preview

Download
/*********** DO NOT ALTER ANYTHING BELOW THIS LINE ! ************/ var s_code=s.t();if(s_code)document.write(s_code)//-->