1.Difference between Informatica 8x and 9x?

Here are the main differences between Informatica PowerCenter 8x and 9x:

Architecture and Performance

- Informatica 8x: Uses a service-oriented architecture (SOA) and a Java-based framework.
- Informatica 9x: Built on a microservices-based architecture, providing better scalability, flexibility, and
performance.
Big Data and Cloud Integration
- Informatica 8x: Supports big data and cloud integrations, but with limited functionality.
- Informatica 9x: Offers enhanced big data and cloud integration capabilities, including support for
Apache Spark, Hadoop, and cloud-based data lakes.
Data Security and Governance
- Informatica 8x: Provides basic data security and governance features.
- Informatica 9x: Includes advanced data security and governance features, such as data masking,
encryption, and data lineage.
User Interface and Experience
- Informatica 8x: Has a traditional, desktop-based user interface.
- Informatica 9x: Offers a modern, web-based user interface with improved usability and collaboration
features.
Licensing and Pricing
- Informatica 8x: Typically licensed on a perpetual basis, with additional costs for maintenance and
support.
- Informatica 9x: Available through subscription-based licensing models, including cloud-based and on-
premises deployments.
Overall, Informatica 9x represents a significant upgrade over Informatica 8x, with improved architecture,
performance, and functionality.

2.Difference between connected and unconnected lookup transformation in

Informatica?
In Informatica, Lookup transformations are used to retrieve data from a lookup source, such as a table
or file. There are two types of Lookup transformations:

Connected Lookup
A Connected Lookup is a Lookup transformation that is connected to the mapping pipeline. It receives
input data from the pipeline, performs the lookup, and returns the result to the pipeline.
Characteristics:
- Receives input data from the pipeline
- Performs the lookup in real-time
- Returns the result to the pipeline
- Supports caching for better performance
Unconnected Lookup
An Unconnected Lookup is a Lookup transformation that is not connected to the mapping pipeline. It
performs the lookup independently and returns the result as a variable or output.
Characteristics:
- Does not receive input data from the pipeline
- Performs the lookup independently
- Returns the result as a variable or output
- Does not support caching
Key Differences:
1. Input Data: Connected Lookup receives input data from the pipeline, while Unconnected Lookup does
not.
2. Lookup Timing: Connected Lookup performs the lookup in real-time, while Unconnected Lookup
performs the lookup independently.
3. Caching: Connected Lookup supports caching, while Unconnected Lookup does not.
4. Output: Connected Lookup returns the result to the pipeline, while Unconnected Lookup returns the
result as a variable or output.
When to use each:
- Use Connected Lookup when you need to perform a lookup based on input data from the pipeline.
- Use Unconnected Lookup when you need to perform a lookup independently, without relying on input
data from the pipeline.;

3.Difference between stop and abort in Informatica?

in Informatica, Stop and Abort are two different options to control the execution of a workflow
or session.

Stop
- Stops the workflow or session gracefully, allowing currently running tasks to complete.
- Ensures data integrity by committing or rolling back transactions as needed.
- Can be used to pause a workflow or session temporarily.
Abort
- Immediately terminates the workflow or session, canceling all running tasks.
- May result in data inconsistencies or incomplete transactions.
- Should be used with caution, as it can lead to data corruption or loss.
Key differences:
1. Immediate termination: Abort stops the workflow or session immediately, while Stop allows currently
running tasks to complete.
2. Data integrity: Stop ensures data integrity by handling transactions properly, while Abort may lead to
data inconsistencies.
3. Usage: Stop is suitable for pausing or stopping a workflow or session temporarily, while Abort should
be used with caution and only when necessary.
When to use each:
- Use Stop when you need to pause or stop a workflow or session temporarily, ensuring data integrity.
- Use Abort when you need to immediately terminate a workflow or session, but be aware of the
potential risks to data integrity.

4. Difference between Static and Dynamic caches?

In Informatica, caching is used to improve the performance of Lookup transformations by storing
frequently accessed data in memory. There are two types of caches: Static and Dynamic.

Static Cache
1. Pre-loaded: The cache is pre-loaded with data before the mapping starts.
2. Fixed size: The cache size is fixed and defined during design time.
3. No runtime updates: The cache is not updated during runtime.
4. Faster lookup: Since the cache is pre-loaded, lookups are faster.
Dynamic Cache
1. Runtime loading: The cache is loaded dynamically during runtime.
2. Variable size: The cache size can grow or shrink dynamically based on runtime conditions.
3. Runtime updates: The cache is updated during runtime as new data is processed.
4. Slower lookup: Since the cache is loaded dynamically, lookups might be slower compared to static
cache.
Key differences:
1. Cache loading: Static cache is pre-loaded, while dynamic cache is loaded during runtime.
2. Cache size: Static cache has a fixed size, while dynamic cache size can vary.
3. Runtime updates: Static cache is not updated during runtime, while dynamic cache is updated.
4. Lookup performance: Static cache generally provides faster lookups, while dynamic cache might be
slower.
When to use each:
1. Use Static Cache:
- When the lookup data is relatively small and doesn't change frequently.
- When fast lookup performance is critical.
2. Use Dynamic Cache:
- When the lookup data is large or changes frequently.
- When the cache needs to be updated during runtime.

5. What is Persistent Lookup cache? What is its significance?

In Informatica, a Persistent Lookup Cache (PLC) is a type of cache that stores lookup data in a
persistent storage, such as a file or database, across multiple sessions.

Key Characteristics of PLC

1. Persistent storage: PLC stores lookup data in a persistent storage, allowing it to retain data across
sessions.
2. Reusable cache: PLC can be reused across multiple sessions, reducing the need to reload the cache
each time.
3. Improved performance: PLC can improve performance by reducing the number of database queries
and minimizing data loading time.
Significance of PLC
1. Improved performance: PLC can significantly improve performance by reducing the time spent on
loading and querying lookup data.
2. Reduced database queries: By storing lookup data in a cache, PLC reduces the number of database
queries, which can help reduce database load and improve overall system performance.
3. Increased scalability: PLC can help increase scalability by allowing multiple sessions to share the same
cache, reducing the need for duplicate data loading and processing.
4. Better data management: PLC provides better data management by allowing you to manage and
update lookup data in a centralized location.

6. Difference between and reusable transformation and mapplet?

In Informatica, Reusable Transformations and Mapplets are two types of reusable objects that can be
used to simplify and standardize data integration processes.

Reusable Transformation
1. Single transformation: A Reusable Transformation is a single transformation that can be reused across
multiple mappings.
2. Specific function: It performs a specific function, such as aggregation, filtering, or data conversion.
3. Configurable: Reusable Transformations can be configured to accept input parameters and produce
output values.
4. Used within a mapping: Reusable Transformations are used within a mapping to perform a specific
task.
Mapplet
1. Group of transformations: A Mapplet is a group of transformations that can be reused across multiple
mappings.
2. Complex logic: Mapplets can contain complex logic, including multiple transformations, variables, and
parameters.
3. Reusable logic: Mapplets provide reusable logic that can be applied to different datasets and
mappings.
4. Used as a building block: Mapplets can be used as building blocks to create more complex mappings
and workflows.
Key differences
1. Scope: Reusable Transformations are single transformations, while Mapplets are groups of
transformations.
2. Complexity: Mapplets can contain complex logic, while Reusable Transformations are typically simpler.
3. Reusability: Both Reusable Transformations and Mapplets are reusable, but Mapplets provide more
flexibility and customization options.
4. Usage: Reusable Transformations are used within a mapping, while Mapplets can be used as building
blocks to create more complex mappings and workflows.

7. How the Informatica server sorts the string values in Rank transformation ?
In Informatica, the Rank transformation sorts string values based on the session properties and the
database code page. Here's how it works:

Sorting Mechanism
1. Session Properties: Informatica uses the session properties to determine the sorting order. Specifically,
the Code Page and Sort Order properties control how string values are sorted.
2. Database Code Page: If the session properties are not set, Informatica uses the database code page to
determine the sorting order.
3. ASCII Values: Informatica compares the ASCII values of each character in the string to determine the
sorting order.
4. Case Sensitivity: By default, Informatica performs a case-sensitive sort. However, you can change this
behavior by setting the Case Sensitive property in the Rank transformation.
Sorting Order
The sorting order for string values in the Rank transformation is as follows:
1. Null values: Null values are sorted first.
2. Empty strings: Empty strings are sorted next.
3. String values: String values are sorted based on their ASCII values, taking into account the session
properties and database code page.
Example
Suppose you have a string column with the following values:
- Apple
- Banana
- Cherry
- Date
- NULL
- "" (empty string)
The Rank transformation would sort these values as follows:
1. NULL
2. "" (empty string)
3. Apple
4. Banana
5. Cherry
6. Date
Note that the sorting order may vary depending on the session properties and database code page.

8. Is sorter an active or passive transformation? When do we consider it to be

active and passive?
In Informatica, the Sorter transformation can be both active and passive, depending on the context.

Passive Sorter
A Sorter transformation is considered passive when:
1. No aggregation: The Sorter is not performing any aggregation, such as grouping or summarizing data.
2. No data rejection: The Sorter is not rejecting any data, and all input rows are passed to the output.
3. Only sorting: The Sorter is only sorting the data based on the specified sort keys.
In this case, the Sorter transformation is passive because it does not modify the data or reject any rows.
Active Sorter
A Sorter transformation is considered active when:
1. Aggregation: The Sorter is performing aggregation, such as grouping or summarizing data.
2. Data rejection: The Sorter is rejecting data, and some input rows are not passed to the output.
3. Distinct or Group By: The Sorter is using the DISTINCT or GROUP BY options, which modify the data.
In this case, the Sorter transformation is active because it modifies the data or rejects rows.
Key differences
1. Data modification: Active Sorter modifies the data, while passive Sorter does not.
2. Data rejection: Active Sorter rejects data, while passive Sorter does not.
3. Aggregation: Active Sorter performs aggregation, while passive Sorter does not.

9. Explain about Informatica server Architecture?

Informatica Server Architecture is a multi-tiered architecture that enables scalable, secure, and high-
performance data integration. Here's an overview:

Components
1. Client Tier: Informatica PowerCenter Client, Informatica Developer, or other client tools connect to the
Informatica Server.
2. Web Tier: Informatica Web Services provide a web-based interface for administering and monitoring
the Informatica Server.
3. Application Tier: Informatica Server, which includes the following components:
1. Integration Service: Executes data integration tasks, such as workflows and mappings.
 2. Repository Service: Manages the Informatica Repository, which stores metadata, mappings, and
workflows.
3. Security Service: Handles authentication, authorization, and encryption for the Informatica Server.
4. Database Tier: Informatica Repository Database stores metadata, mappings, and workflows.
Architecture
1. N-Tier Architecture: Informatica Server follows an n-tier architecture, allowing for scalability and
flexibility.
2. Distributed Architecture: Informatica Server can be deployed in a distributed environment, with
multiple nodes and services.
3. Load Balancing: Informatica Server supports load balancing, ensuring high availability and
performance.
4. Failover: Informatica Server provides failover capabilities, minimizing downtime and ensuring business
continuity.
Benefits
1. Scalability: Informatica Server architecture allows for horizontal scaling, handling large volumes of
data and users.
2. High Performance: Optimized for performance, Informatica Server ensures fast data processing and
integration.
3. Security: Robust security features, including encryption and access control, protect sensitive data.
4. Flexibility: Informatica Server supports various data sources, targets, and formats, making it a versatile
data integration platform.

10. In update strategy Relational table or flat file which gives us more
performance? Why?
In Informatica, when using an Update Strategy transformation to update a relational table or a flat file,
the relational table typically provides better performance. Here's why:

Relational Table Advantages

1. Database Optimization: Relational databases like Oracle, SQL Server, or DB2 are optimized for updates,
with features like indexing, caching, and query optimization.
2. Row-Level Locking: Relational databases use row-level locking, which allows multiple updates to occur
concurrently, reducing contention and improving performance.
3. Buffering and Caching: Relational databases use buffering and caching mechanisms to reduce the
number of physical writes, improving update performance.
Flat File Limitations
1. Sequential Access: Flat files are accessed sequentially, which can lead to slower update performance,
especially for large files.
2. No Indexing: Flat files do not support indexing, which means that Informatica must scan the entire file
to locate the records to be updated.
3. No Row-Level Locking: Flat files do not support row-level locking, which can lead to contention and
slower update performance.
Performance Comparison
In general, updating a relational table is faster than updating a flat file, especially for large datasets. This
is because relational databases are optimized for updates, while flat files are not.
However, there are scenarios where updating a flat file might be faster, such as:
1. Small datasets: For small datasets, the overhead of database optimization and locking mechanisms
might outweigh the benefits.
2. Simple updates: If the updates are simple and don't require complex database operations, updating a
flat file might be faster.
In summary, relational tables generally provide better performance for updates due to database
optimization, row-level locking, and buffering mechanisms. However, the performance difference
depends on the specific use case and dataset characteristics.

11. What are the out put files that the Informatica server creates during running a
session?
When running a session, the Informatica server creates several output files that contain information
about the session execution, errors, and data processing. Here are some of the common output files
created by the Informatica server:

Session Log File

1. File name: session_log.txt (or session_log.log)
2. Contents: Detailed log of the session execution, including start and end times, errors, and warnings.
Session Summary File
1. File name: session_summary.txt (or session_summary.log)
2. Contents: Brief summary of the session execution, including number of rows processed, errors, and
warnings.
Error Log File
1. File name: error_log.txt (or error_log.log)
2. Contents: Detailed log of errors encountered during the session execution.
Bad File
1. File name: bad_data.txt (or bad_data.log)
2. Contents: Data that failed validation or processing during the session execution.
Reject File
1. File name: reject_data.txt (or reject_data.log)
2. Contents: Data that was rejected during processing, such as duplicate records or invalid data.
Output Files
1. File name: varies depending on the target definition
2. Contents: Processed data that meets the target definition criteria.
These output files provide valuable information about the session execution and can be used for
troubleshooting, auditing, and data analysis.

12. Can you explain what are error tables in Informatica are and how we do error
handling in Informatica?
Error tables in Informatica are tables that store data that fails validation or processing during a mapping
or workflow execution. These tables help in error handling and provide a way to track and manage
errors.
Types of Error Tables

1. Error Table: Stores data that fails validation or processing due to errors such as invalid data, data type
mismatch, or constraint violations.
2. Reject Table: Stores data that is rejected during processing, such as duplicate records or invalid data.
3. Exception Table: Stores data that fails processing due to exceptions such as database connectivity
issues or network errors.
Error Handling in Informatica

1. Error Handling Options: Informatica provides various error handling options, such as:
- Abort on Error: Stops the workflow or mapping execution when an error occurs.
- Continue on Error: Continues the workflow or mapping execution even if an error occurs.
- Use Error Table: Stores error data in an error table.
2. Error Tables Configuration: Error tables can be configured to store specific error data, such as error
codes, error messages, and error timestamps.
3. Error Handling Transformations: Informatica provides various transformations for error handling, such
as:
- Router Transformation: Routes data to different paths based on error conditions.
- Filter Transformation: Filters out data that meets specific error conditions.
- Expression Transformation: Uses expressions to handle error conditions.

Best Practices for Error Handling

1. Use Error Tables: Use error tables to store error data and track errors.
2. Configure Error Handling Options: Configure error handling options to suit your workflow or mapping
requirements.
3. Use Error Handling Transformations: Use error handling transformations to handle error conditions
and route data accordingly.
4. Monitor and Analyze Error Data: Monitor and analyze error data to identify and resolve errors.

13. Difference between constraint base loading and target load plan?
In Informatica, Constraint-Based Loading (CBL) and Target Load Plan (TLP) are two different approaches
to loading data into a target system.

Constraint-Based Loading (CBL)

1. Rule-based loading: CBL uses a set of predefined rules or constraints to determine the loading order of
tables.
2. Automatic loading order: Informatica automatically determines the loading order based on the
constraints defined.
3. Supports complex relationships: CBL supports complex relationships between tables, including self-
referential relationships.
4. Reduces manual effort: CBL reduces the manual effort required to define the loading order.

Target Load Plan (TLP)

1. User-defined loading order: TLP allows users to define the loading order of tables manually.
2. Flexibility: TLP provides more flexibility in defining the loading order, as users can customize the order
based on specific requirements.
3. Supports simple relationships: TLP supports simple relationships between tables.
4. Requires manual effort: TLP requires manual effort to define the loading order.

Key differences
1. Loading order: CBL determines the loading order automatically, while TLP requires manual definition.
2. Complexity: CBL supports complex relationships, while TLP supports simple relationships.
3. Manual effort: CBL reduces manual effort, while TLP requires manual effort.
4. Flexibility: TLP provides more flexibility in defining the loading order.

When to use each

1. Use CBL:
- When you have complex relationships between tables.
- When you want to reduce manual effort in defining the loading order.
2. Use TLP:
- When you have simple relationships between tables.
- When you need more flexibility in defining the loading order.

14. Difference between IIF and DECODE function?

In Informatica, IIF (Inline If) and DECODE are two functions used for conditional logic. Here's a
comparison of the two:

IIF Function
1. Syntax: IIF(condition, true_value, false_value)
2. Usage: Evaluates a condition and returns one of two values based on the condition.
3. Flexibility: Limited to two possible outcomes (true or false).
4. Readability: Simple and easy to read.

DECODE Function
1. Syntax: DECODE(column, search1, result1, search2, result2, ..., default)
2. Usage: Compares a column value to multiple search values and returns a corresponding result.
3. Flexibility: Can handle multiple search values and return different results.
4. Readability: Can be more complex and harder to read, especially with multiple search values.

Key differences
1. Conditional logic: IIF uses a simple true/false condition, while DECODE uses multiple search values.
2. Flexibility: DECODE is more flexible, handling multiple search values and results.
3. Readability: IIF is simpler and easier to read, while DECODE can be more complex.
When to use each.

1. Use IIF:
- For simple true/false conditions.
- When you need to evaluate a single condition.
2. Use DECODE:
- For more complex conditional logic.
- When you need to compare a column value to multiple search values.

15. How to import oracle sequence into Informatica?

To import an Oracle sequence into Informatica, you can follow these steps:

Method 1: Using Informatica PowerCenter Designer

1. Open Informatica PowerCenter Designer: Launch the Informatica PowerCenter Designer tool.
2. Create a new source definition: In the Designer, create a new source definition by clicking on "Source"
in the toolbar and selecting "Create Source".
3. Select Oracle as the database type: In the "Create Source" dialog box, select "Oracle" as the database
type.
4. Connect to the Oracle database: Enter the connection details for the Oracle database, including the
username, password, and database name.
5. Navigate to the sequence: In the "Source" navigator, navigate to the sequence you want to import.
6. Drag and drop the sequence: Drag and drop the sequence into the "Source" definition.
7. Save the source definition: Save the source definition.

Method 2: Using Informatica PowerCenter Workflow Manager

1. Open Informatica PowerCenter Workflow Manager: Launch the Informatica PowerCenter Workflow
Manager tool.
2. Create a new workflow: Create a new workflow by clicking on "Workflow" in the toolbar and selecting
"Create Workflow".
3. Add a new session: Add a new session to the workflow by clicking on "Session" in the toolbar and
selecting "Create Session".
4. Select Oracle as the database type: In the "Create Session" dialog box, select "Oracle" as the database
type.
5. Connect to the Oracle database: Enter the connection details for the Oracle database, including the
username, password, and database name.
6. Navigate to the sequence: In the "Session" navigator, navigate to the sequence you want to import.
7. Add the sequence to the session: Add the sequence to the session by dragging and dropping it into
the session.
8. Save the session: Save the session.

Method 3: Using Informatica PowerCenter Command Line Interface

1. Open a command prompt: Open a command prompt and navigate to the Informatica PowerCenter
installation directory.
2. Use the pmcmd command: Use the pmcmd command to import the Oracle sequence into Informatica.
Example command:
pmcmd importsequence -s <sequence_name> -d <database_name> -u <username> -p <password>
Replace <sequence_name> with the name of the Oracle sequence you want to import,
<database_name> with the name of the Oracle database, <username> with the username to use for the
connection, and <password> with the password to use for the connection.

By following these steps, you can import an Oracle sequence into Informatica using the method that best
suits your needs.

16. What is parameter file?

In Informatica, a parameter file is a file that contains a set of parameters and their values, which can be
used to control the behavior of a mapping, workflow, or session.

Purpose of a Parameter File

1. Dynamic configuration: Parameter files allow you to dynamically configure your mappings, workflows,
and sessions without having to modify the underlying code.
2. Reusability: Parameter files enable you to reuse the same mapping, workflow, or session with different
sets of parameters, reducing the need for duplicate code.
3. Flexibility: Parameter files provide flexibility in controlling the behavior of your mappings, workflows,
and sessions, making it easier to adapt to changing requirements.

Types of Parameters
1. String parameters: Parameters that store string values.
2. Integer parameters: Parameters that store integer values.
3. Date parameters: Parameters that store date values.

How to Use a Parameter File

1. Create a parameter file: Create a file with a .param extension and define the parameters and their
values.
2. Reference the parameter file: Reference the parameter file in your mapping, workflow, or session.
3. Use the parameters: Use the parameters in your mapping, workflow, or session to control the
behavior.

Example of a Parameter File:

$PMParamFile
# Define a string parameter
$Param(MyStringParam) = 'Hello World'
# Define an integer parameter
$Param(MyIntegerParam) = 123
# Define a date parameter
$Param(MyDateParam) = '2022-01-01'
In this example, the parameter file defines three parameters: MyStringParam, MyIntegerParam, and
MyDateParam. These parameters can be used in a mapping, workflow, or session to control the behavior.

17. Difference between Normal load and Bulk load?

In Informatica, Normal Load and Bulk Load are two different methods of loading data into a target
system.

Normal Load
1. Row-by-row loading: Normal Load loads data into the target system one row at a time.
2. SQL INSERT statements: Normal Load uses SQL INSERT statements to load data into the target system.
3. Target system logging: Normal Load logs each insert operation in the target system's transaction log.
4. Error handling: Normal Load provides detailed error messages for each row that fails to load.
5. Performance: Normal Load is generally slower than Bulk Load, especially for large volumes of data.

Bulk Load
1. Batch loading: Bulk Load loads data into the target system in batches, rather than one row at a time.
2. Native load utilities: Bulk Load uses native load utilities, such as Oracle's SQL*Loader or Microsoft's
BCP, to load data into the target system.
3. Minimal logging: Bulk Load minimizes logging in the target system's transaction log, which improves
performance.
4. Error handling: Bulk Load provides summary-level error messages, rather than detailed error messages
for each row.
5. Performance: Bulk Load is generally faster than Normal Load, especially for large volumes of data.
Key differences
1. Loading method: Normal Load loads data row-by-row, while Bulk Load loads data in batches.
2. SQL statements: Normal Load uses SQL INSERT statements, while Bulk Load uses native load utilities.
3. Logging: Normal Load logs each insert operation, while Bulk Load minimizes logging.
4. Error handling: Normal Load provides detailed error messages, while Bulk Load provides summary-
level error messages.
5. Performance: Bulk Load is generally faster than Normal Load.

When to use each

1. Use Normal Load:
- When loading small volumes of data.
- When detailed error messages are required.
- When data needs to be loaded into a target system that does not support bulk loading.
2. Use Bulk Load:
- When loading large volumes of data.
- When high-performance loading is required.
- When data needs to be loaded into a target system that supports bulk loading.

18. How u will create header and footer in target using Informatica?
In Informatica, you can create a header and footer in a target file using a combination of transformations
and target properties. Here's a step-by-step guide:

Creating a Header
1. Create a new transformation: In the Informatica Mapping Designer, create a new transformation, such
as an Expression transformation or a Transaction Control transformation.
2. Add a header variable: In the transformation, add a new variable to store the header text. For
example, you can add a string variable called HEADER_TEXT.
3. Assign the header text: Assign the desired header text to the HEADER_TEXT variable. You can use a
constant value or an expression to generate the header text.
4. Use the header variable in the target: In the target definition, use the HEADER_TEXT variable as the
header text. You can do this by adding a new field to the target definition and assigning the
HEADER_TEXT variable to it.

Creating a Footer
1. Create a new transformation: In the Informatica Mapping Designer, create a new transformation, such
as an Expression transformation or a Transaction Control transformation.
2. Add a footer variable: In the transformation, add a new variable to store the footer text. For example,
you can add a string variable called FOOTER_TEXT.
3. Assign the footer text: Assign the desired footer text to the FOOTER_TEXT variable. You can use a
constant value or an expression to generate the footer text.
4. Use the footer variable in the target: In the target definition, use the FOOTER_TEXT variable as the
footer text. You can do this by adding a new field to the target definition and assigning the FOOTER_TEXT
variable to it.

Target Properties
1. Set the header and footer properties: In the target definition, set the Header and Footer properties to
the corresponding variables (HEADER_TEXT and FOOTER_TEXT).
2. Specify the header and footer formats: You can also specify the format of the header and footer text
using the Header Format and Footer Format properties.
By following these steps, you can create a header and footer in your target file using Informatica.

19. What are the session parameters?

In Informatica, session parameters are variables that can be used to control the behavior of a session.
These parameters can be set at runtime, allowing you to customize the session behavior without having
to modify the underlying mapping or workflow.

Types of Session Parameters

1. User-defined parameters: These are parameters that are defined by the user and can be used to pass
values to a session.
2. System-defined parameters: These are parameters that are defined by Informatica and provide
information about the session, such as the session name, start time, and end time.
3. Workflow parameters: These are parameters that are defined at the workflow level and can be used to
pass values to multiple sessions within the workflow.

Common Session Parameters

1. _$PMSourceFileDir*: Specifies the directory path for source files.
2. _$PMTargetFileDir*: Specifies the directory path for target files.
3. _$PMFileName*: Specifies the file name for the source or target file.
4. _$PMDateFormat*: Specifies the date format for date columns.
5. _$PMDecimalSeparator*: Specifies the decimal separator for numeric columns.

How to Use Session Parameters

1. Define the parameter: Define the session parameter in the Informatica PowerCenter Designer or
Workflow Manager.
2. Set the parameter value: Set the value of the session parameter at runtime, either through the
Informatica PowerCenter Workflow Manager or by passing the value as a command-line argument.
3. Use the parameter in the session: Use the session parameter in the session, such as in a mapping or
transformation, to control the behavior of the session.
By using session parameters, you can make your Informatica sessions more flexible and dynamic, and
reduce the need for manual modifications to the underlying mappings or workflows.

20. Where does Informatica store rejected data? How do we view them?
In Informatica, rejected data is stored in a file or database table, depending on the configuration of the
session. Here are the common locations where Informatica stores rejected data:

1. Reject File: By default, Informatica stores rejected data in a reject file, which is a text file that contains
the rejected records. The reject file is usually named <session_name>_reject.txt and is stored in the
Informatica server's temporary directory.
2. Reject Table: If you configure the session to store rejected data in a database table, Informatica will
store the rejected records in a table specified by you. This table is usually named <session_name>_reject
and is stored in the target database.

To view rejected data, you can follow these steps:

Viewing Reject File
1. Log in to the Informatica PowerCenter Workflow Manager.
2. Navigate to the Session tab.
3. Click on the Session Log icon for the session that generated the rejected data.
4. In the Session Log window, click on the Reject File tab.
5. The reject file will be displayed in a text format, showing the rejected records.

Viewing Reject Table

1. Log in to the Informatica PowerCenter Workflow Manager.
2. Navigate to the Session tab.
3. Click on the Session Log icon for the session that generated the rejected data.
4. In the Session Log window, click on the Reject Table tab.
5. The reject table will be displayed in a grid format, showing the rejected records.
Alternatively, you can also view rejected data by querying the reject table directly in the target
database, using a SQL client tool such as SQL Developer or Toad.

21. What is difference between partitioning of relational target and file targets?
In Informatica, partitioning is a technique used to divide large amounts of data into smaller, more
manageable pieces, called partitions. Partitioning can be applied to both relational targets and file
targets, but there are differences in how partitioning is implemented and used for each type of target.

Relational Target Partitioning

1. Partitioning based on database features: Relational target partitioning is based on the partitioning
features provided by the database management system (DBMS), such as Oracle, Microsoft SQL Server, or
DB2.
2. Partitioning methods: Relational targets support various partitioning methods, including range
partitioning, list partitioning, hash partitioning, and composite partitioning.
3. Partitioning keys: The partitioning key is a column or set of columns that determines how data is
distributed across partitions.
4. Benefits: Relational target partitioning improves query performance, reduces storage requirements,
and enhances data management.

File Target Partitioning

1. Partitioning based on file format: File target partitioning is based on the file format, such as CSV, XML,
or fixed-length files.
2. Partitioning methods: File targets support simple partitioning methods, such as partitioning by file
name, file size, or number of records.
3. Partitioning keys: The partitioning key is typically a file-level attribute, such as file name or file size.
4. Benefits: File target partitioning improves data organization, reduces file sizes, and enhances data
exchange.

Key differences
1. Partitioning complexity: Relational target partitioning is more complex and powerful than file target
partitioning.
2. Partitioning methods: Relational targets support more advanced partitioning methods, such as range
and hash partitioning, while file targets support simpler methods.
3. Partitioning keys: Relational targets use column-level attributes as partitioning keys, while file targets
use file-level attributes.
4. Benefits: Relational target partitioning provides more benefits, such as improved query performance
and reduced storage requirements, while file target partitioning focuses on data organization and
exchange.

22. What are mapping parameters and variables in which situation we can use
them?
In Informatica, mapping parameters and variables are used to make mappings more flexible and
reusable. Here's a brief overview of each:

Mapping Parameters
1. Defined at the mapping level: Mapping parameters are defined at the mapping level and can be used
throughout the mapping.
2. Passed as input: Mapping parameters can be passed as input to the mapping from the workflow or
session.
3. Used for filtering, sorting, and aggregating: Mapping parameters can be used for filtering, sorting, and
aggregating data within the mapping.
4. Example: A mapping parameter can be used to specify the date range for which data needs to be
extracted.

Mapping Variables
1. Defined within the mapping: Mapping variables are defined within the mapping and can be used
within the mapping.
2. Initialized with a value: Mapping variables can be initialized with a value, which can be a constant, an
expression, or a parameter.
3. Used for calculations and transformations: Mapping variables can be used for calculations and
transformations within the mapping.
4. Example: A mapping variable can be used to store the result of a calculation, such as the total sales
amount.

Situations where mapping parameters and variables can be used

1. Dynamic filtering: Mapping parameters can be used to dynamically filter data based on user input or
external factors.
2. Data transformation: Mapping variables can be used to perform complex data transformations, such
as aggregations, calculations, and string manipulations.
3. Reusability: Mapping parameters and variables can be used to make mappings more reusable by
allowing them to be easily customized for different use cases.
4. Debugging and testing: Mapping parameters and variables can be used to simplify debugging and
testing by allowing developers to easily modify input values and test different scenarios.

Best practices
1. Use meaningful names: Use meaningful names for mapping parameters and variables to make them
easy to understand and use.
2. Document usage: Document the usage of mapping parameters and variables to ensure that they are
used correctly and consistently.
3. Test thoroughly: Test mappings thoroughly to ensure that mapping parameters and variables are
working as expected.
23. What do you mean by direct loading and Indirect loading in session
properties?
In Informatica, Direct Loading and Indirect Loading are two loading methods that can be specified in the
Session Properties to control how data is loaded into a target database or file.

Direct Loading
1. Loads data directly into the target: Direct Loading loads data directly into the target database or file,
without creating a temporary file or staging area.
2. Faster loading times: Direct Loading is generally faster than Indirect Loading, since it eliminates the
need to create and manage temporary files.
3. Less disk space required: Direct Loading requires less disk space, since no temporary files are created.

Indirect Loading
1. Loads data into a temporary file first: Indirect Loading loads data into a temporary file or staging area,
which is then loaded into the target database or file.
2. More flexible and recoverable: Indirect Loading provides more flexibility and recoverability, since the
temporary file can be used to restart the loading process in case of failures.
3. More disk space required: Indirect Loading requires more disk space, since temporary files are
created.

When to use each

1. Use Direct Loading:
- When loading small to medium-sized datasets.
- When loading data into a target database or file that supports direct loading.
- When speed is a priority.
2. Use Indirect Loading:
- When loading large datasets.
- When loading data into a target database or file that does not support direct loading.
- When flexibility and recoverability are priorities.
In summary, Direct Loading is a faster and more efficient method, but it requires less flexibility and
recoverability. Indirect Loading provides more flexibility and recoverability, but it requires more disk
space and may be slower.

24. How do we implement recovery strategy while running concurrent batches?

Implementing a recovery strategy while running concurrent batches is crucial to ensure that the batches
can recover from failures and maintain data consistency. Here are some steps to implement a recovery
strategy:

1. Use checkpoints: Checkpoints are points in the batch process where the current state of the process is
saved. If a failure occurs, the batch can restart from the last checkpoint.
2. Implement transactional control: Use transactional control to ensure that multiple operations are
treated as a single, atomic unit. If any part of the transaction fails, the entire transaction can be rolled
back.
3. Use batch IDs and sequence numbers: Assign a unique batch ID and sequence number to each batch.
This allows you to track the progress of each batch and recover from failures.
4. Log batch progress: Log the progress of each batch, including any errors or exceptions that occur. This
log can be used to recover from failures and diagnose issues.
5. Implement retry logic: Implement retry logic to handle transient failures, such as network connectivity
issues.
6. Use a message queue or event-driven architecture: Consider using a message queue or event-driven
architecture to handle batch processing. This allows you to decouple the batch processing from the main
application and provides a more robust recovery mechanism.
7. Monitor batch progress: Monitor the progress of each batch and alert administrators if any issues
arise.
8. Implement a recovery process: Establish a recovery process that can be triggered in case of a failure.
This process should include steps to recover from the failure and restart the batch from the last
checkpoint.

Concurrent batch considerations

1. Use a thread-safe recovery mechanism: Ensure that the recovery mechanism is thread-safe to prevent
conflicts between concurrent batches.
2. Use a locking mechanism: Use a locking mechanism to prevent multiple batches from accessing the
same data simultaneously.
3. Implement a batch prioritization mechanism: Implement a batch prioritization mechanism to ensure
that high-priority batches are processed before low-priority batches.
By implementing these strategies, you can ensure that your concurrent batches can recover from failures
and maintain data consistency.

25. Explain the versioning concept in Informatica?

In Informatica, versioning is a concept that allows you to manage different versions of a mapping,
workflow, or other objects. This feature enables you to track changes, collaborate with others, and
maintain a history of modifications.

Types of versioning in Informatica

1. Versioning of mappings: Informatica allows you to create multiple versions of a mapping. Each version
is stored separately, and you can revert to a previous version if needed.
2. Versioning of workflows: Similar to mappings, you can create multiple versions of a workflow. This
feature is useful when you need to make changes to a workflow without affecting the existing version.
3. Versioning of other objects: Informatica also supports versioning of other objects, such as sessions,
sources, and targets.

Benefits of versioning in Informatica

1. Change tracking: Versioning allows you to track changes made to a mapping or workflow over time.
2. Collaboration: Multiple developers can work on different versions of a mapping or workflow, and then
merge their changes.
3. Backup and recovery: Versioning provides a backup of previous versions, which can be recovered in
case of errors or unintended changes.
4. Auditing and compliance: Versioning helps with auditing and compliance by providing a record of
changes made to mappings and workflows.

How to use versioning in Informatica

1. Create a new version: To create a new version of a mapping or workflow, right-click on the object and
select "Create New Version".
2. Check out and check in: To make changes to a mapping or workflow, check it out, make the changes,
and then check it back in.
3. Compare versions: You can compare different versions of a mapping or workflow to see the changes
made.
4. Revert to a previous version: If needed, you can revert to a previous version of a mapping or workflow.

26. What is Data driven?

Data-driven refers to an approach or process that is guided by data, rather than by intuition, personal
experience, or assumptions. In a data-driven approach, data is collected, analyzed, and used to inform
decision-making, drive business outcomes, and optimize processes.

Characteristics of a data-driven approach

1. Data collection: Data is collected from various sources, such as databases, files, and applications.
2. Data analysis: Data is analyzed using statistical and analytical techniques to identify trends, patterns,
and correlations.
3. Insight generation: Insights are generated from the analyzed data, which are used to inform decision-
making.
4. Decision-making: Decisions are made based on the insights generated from the data.
5. Continuous monitoring: Data is continuously monitored and analyzed to refine decision-making and
optimize processes.

Benefits of a data-driven approach

1. Improved decision-making: Data-driven decisions are more informed and less prone to bias.
2. Increased efficiency: Data-driven processes are more streamlined and efficient.
3. Enhanced customer experience: Data-driven insights can be used to personalize customer
experiences.
4. Competitive advantage: Organizations that adopt a data-driven approach can gain a competitive
advantage.

Applications of data-driven approach

1. Business intelligence: Data-driven approach is used in business intelligence to analyze data and
generate insights.
2. Marketing analytics: Data-driven approach is used in marketing analytics to measure campaign
effectiveness and optimize marketing strategies.
3. Operational optimization: Data-driven approach is used in operational optimization to streamline
processes and improve efficiency.
4. Predictive maintenance: Data-driven approach is used in predictive maintenance to predict equipment
failures and optimize maintenance schedules.
In summary, a data-driven approach is a methodology that uses data to inform decision-making, drive
business outcomes, and optimize processes. It has numerous benefits, including improved decision-
making, increased efficiency, and enhanced customer experience.

27. What is batch? Explain the types of the batches?

In computing, a batch refers to a group of tasks or jobs that are executed together as a single unit.
Batches are used to automate repetitive tasks, improve efficiency, and reduce manual intervention.

Types of Batches
1. Scheduled Batch: A scheduled batch is a batch that is executed at a specific time or interval, such as
daily, weekly, or monthly. Scheduled batches are used for tasks that need to be performed regularly, such
as data backups or report generation.
2. On-Demand Batch: An on-demand batch is a batch that is executed manually by a user or
administrator. On-demand batches are used for tasks that need to be performed immediately, such as
data imports or exports.
3. Real-Time Batch: A real-time batch is a batch that is executed in real-time, as soon as the data is
available. Real-time batches are used for tasks that require immediate processing, such as transactional
data processing or event-driven processing.
4. Parallel Batch: A parallel batch is a batch that is executed concurrently, with multiple tasks or jobs
running simultaneously. Parallel batches are used for tasks that require high processing power, such as
data processing or scientific simulations.
5. Sequential Batch: A sequential batch is a batch that is executed one task or job at a time, in a
sequential order. Sequential batches are used for tasks that require a specific order of execution, such as
data imports or exports.

Batch Processing Characteristics

1. Automated: Batches are automated, reducing manual intervention and errors.
2. Repetitive: Batches are used for repetitive tasks, improving efficiency and productivity.
3. Grouping: Batches group tasks or jobs together, simplifying management and monitoring.
4. Scheduling: Batches can be scheduled to run at specific times or intervals, improving resource
utilization.
5. Scalability: Batches can be scaled up or down, depending on the processing requirements.

28. What are the types of meta data repository stores?

A metadata repository is a centralized storage location that holds metadata, which is data that describes
and provides context to other data. There are several types of metadata repository stores:

Types of Metadata Repository Stores

1. Relational Database Management System (RDBMS)
- Stores metadata in a structured format using tables, rows, and columns.
- Examples: Oracle, Microsoft SQL Server, IBM DB2.

2. NoSQL Database
- Stores metadata in a variety of formats, such as key-value, document, graph, or column-family stores.
- Examples: MongoDB, Cassandra, Couchbase.

3. Cloud-based Repository
- Stores metadata in a cloud-based storage service, such as Amazon S3 or Microsoft Azure Blob Storage.
- Examples: AWS Glue, Azure Data Catalog.

4. Graph Database
- Stores metadata as nodes and edges in a graph structure.
- Examples: Neo4j, Amazon Neptune.

5. Object-oriented Database
- Stores metadata in an object-oriented format, using classes and objects.
- Examples: Gemstone, Matisse.

6. XML Database
- Stores metadata in an XML format, using XML documents and schemas.
- Examples: MarkLogic, Tamino.

7. Ontology-based Repository
- Stores metadata as ontologies, which are formal representations of knowledge.
- Examples: Protégé, TopBraid Composer.

8. Big Data Repository

- Stores large amounts of metadata, often using distributed storage and processing.
- Examples: Hadoop Distributed File System (HDFS), Apache Cassandra.

9. Data Warehouse
- Stores metadata in a centralized repository, often used for business intelligence and data analytics.
- Examples: Amazon Redshift, Google BigQuery.

10. Custom-built Repository

- Stores metadata in a custom-built repository, often using a combination of the above types.
- Examples: Custom-built solutions using programming languages like Java or Python.

29. Can you use the mapping parameters or variables created in one mapping into
another mapping?
In Informatica, mapping parameters and variables are specific to each mapping. However, there are ways
to share and reuse them across multiple mappings:

Mapping Parameters
1. Global Parameters: You can create global parameters that can be shared across multiple mappings.
Global parameters are defined at the workflow or folder level.
2. Parameter Files: You can store mapping parameters in a parameter file, which can be shared across
multiple mappings.
3. Workflow Variables: You can create workflow variables that can be used to pass values between
mappings.

Mapping Variables
1. Workflow Variables: You can create workflow variables that can be used to pass values between
mappings.
2. Parameter Files: You can store mapping variables in a parameter file, which can be shared across
multiple mappings.
3. Global Variables: You can create global variables that can be shared across multiple mappings. Global
variables are defined at the workflow or folder level.

Best Practices
1. Use meaningful names: Use meaningful names for mapping parameters and variables to make them
easy to understand and reuse.
2. Document usage: Document the usage of mapping parameters and variables to ensure that they are
used correctly across multiple mappings.
3. Test thoroughly: Test mappings thoroughly to ensure that shared parameters and variables are
working as expected.

30.Why did we use stored procedure in our ETL Application?

Stored procedures are a common component in ETL (Extract, Transform, Load) applications, including
Informatica. Here are some reasons why stored procedures are used in ETL applications:

Advantages of Stored Procedures in ETL

1. Improved Performance: Stored procedures can improve performance by reducing the amount of data
that needs to be transferred between the ETL tool and the database. By executing the transformation
logic within the database, stored procedures can reduce network traffic and improve overall throughput.
2. Better Data Integrity: Stored procedures can help ensure data integrity by enforcing business rules and
validation logic within the database. This can prevent incorrect or inconsistent data from being loaded
into the target system.
3. Reduced Network Traffic: By executing transformation logic within the database, stored procedures
can reduce the amount of data that needs to be transferred over the network. This can improve
performance and reduce the load on network resources.
4. Simplified Maintenance: Stored procedures can simplify maintenance by providing a centralized
location for transformation logic. This makes it easier to modify or update transformation logic without
affecting other parts of the ETL process.
5. Improved Security: Stored procedures can improve security by providing an additional layer of
protection against unauthorized access to sensitive data. By encapsulating transformation logic within
stored procedures, you can reduce the risk of data breaches or unauthorized data modifications.
6. Reusability: Stored procedures can be reused across multiple ETL workflows, reducing the need to
duplicate transformation logic and improving overall efficiency.
7. Error Handling: Stored procedures can provide robust error handling mechanisms, allowing you to
handle errors and exceptions in a centralized and consistent manner.

Use Cases for Stored Procedures in ETL

1. Data Validation: Use stored procedures to validate data against business rules or constraints, ensuring
that only valid data is loaded into the target system.
2. Data Transformation: Use stored procedures to perform complex data transformations, such as
aggregations, calculations, or data conversions.
3. Data Cleansing: Use stored procedures to cleanse data by removing duplicates, handling null values, or
performing data normalization.
4. Data Integration: Use stored procedures to integrate data from multiple sources, performing joins,
unions, or other data integration operations.

By using stored procedures in ETL applications, you can improve performance, data integrity, and
maintainability, while reducing network traffic and improving overall efficiency.

31.When we can join tables at the Source qualifier itself, why do we go for joiner
transformation?
While it's true that you can join tables at the Source Qualifier level, there are scenarios where using a
Joiner transformation is more suitable or even necessary. Here are some reasons why:
Reasons to use Joiner transformation
1. Complex join conditions: When you have complex join conditions, such as multiple join conditions,
conditional joins, or joins with aggregations, a Joiner transformation provides more flexibility and
control.
2. Multiple join types: Joiner transformation allows you to perform different types of joins, such as inner
join, left outer join, right outer join, full outer join, and cross join. In contrast, Source Qualifier joins are
typically limited to inner joins.
3. Joining data from different sources: When you need to join data from different sources, such as
databases, files, or applications, a Joiner transformation provides a more flexible and scalable solution.
4. Data transformation and aggregation: Joiner transformation allows you to perform data
transformations and aggregations on the joined data, which may not be possible or efficient at the
Source Qualifier level.
5. Performance optimization: In some cases, using a Joiner transformation can improve performance by
reducing the amount of data being joined or by allowing for more efficient join algorithms.
6. Reusability and modularity: Joiner transformation can be reused across multiple mappings and
workflows, making it a more modular and maintainable solution.
7. Debugging and troubleshooting: Joiner transformation provides more detailed logging and debugging
capabilities, making it easier to troubleshoot join-related issues.

Scenarios where Source Qualifier joins are sufficient

1. Simple inner joins: When you have a simple inner join with a single join condition, a Source Qualifier
join may be sufficient.
2. Small datasets: When working with small datasets, a Source Qualifier join may be faster and more
efficient.
In summary, while Source Qualifier joins can be useful for simple inner joins, Joiner transformation
provides more flexibility, control, and scalability for complex join scenarios, data transformation, and
aggregation.

32.What is the default join operation performed by the look up transformation?

The default join operation performed by the Lookup transformation in Informatica is an "Inner Join".

Inner Join behavior in Lookup transformation

When you configure a Lookup transformation, it performs an inner join between the input data and the
lookup data. This means that only the rows that have a match in both the input data and the lookup data
are returned.

How Inner Join works in Lookup transformation

Here's a step-by-step explanation of how the inner join works in a Lookup transformation:
1. The Lookup transformation receives input data from the previous transformation or source.
2. The Lookup transformation searches for matching values in the lookup table.
3. If a match is found, the Lookup transformation returns the matched row(s) from the lookup table.
4. If no match is found, the Lookup transformation returns a null value or a default value specified in the
transformation properties.
Other join options in Lookup transformation
While the default join operation is an inner join, you can also configure the Lookup transformation to
perform other types of joins, such as:
- Left Outer Join
- Right Outer Join
- Full Outer Join
- Cross Join
To change the join type, you need to modify the Lookup transformation properties and select the desired
join type.

33.What is hash table Informatica?

In Informatica, a hash table is a data structure used in the Aggregator, Joiner, and Lookup
transformations to store and retrieve data efficiently.

How Hash Table works

Here's a simplified explanation of how a hash table works in Informatica:

1. Data is divided into groups: The transformation divides the input data into groups based on a specific
key or set of keys.
2. Hash function is applied: A hash function is applied to each group to generate a unique hash value.
3. Data is stored in a table: The data is stored in a table, with the hash value serving as the index.
4. Data is retrieved using the hash value: When the transformation needs to retrieve data, it uses the
hash value to locate the corresponding data in the table.

Advantages of Hash Table

1. Fast data retrieval: Hash tables enable fast data retrieval, as the transformation can quickly locate the
required data using the hash value.
2. Efficient data storage: Hash tables store data efficiently, as each group of data is stored in a single
location, reducing data duplication.
3. Improved performance: Hash tables improve the performance of transformations, such as Aggregator,
Joiner, and Lookup, by reducing the time required to process data.

Types of Hash Tables in Informatica

1. In-Memory Hash Table: Stores data in memory (RAM) for fast access.
2. On-Disk Hash Table: Stores data on disk, which is useful for large datasets that don't fit in memory.
In summary, hash tables in Informatica are a powerful data structure that enables fast and efficient
data retrieval, storage, and processing, which improves the performance of various transformations.

34.In a joiner transformation, you should specify the table with lesser rows as the
master table. Why?
In a Joiner transformation, specifying the table with lesser rows as the master table is a best practice for
performance optimization. Here's why:

Benefits of specifying the smaller table as the master table

1. Reduced memory usage: By specifying the smaller table as the master table, the Joiner transformation
can store the entire master table in memory, reducing the need for disk I/O operations.
2. Faster join processing: With the smaller table in memory, the Joiner transformation can quickly match
rows from the detail table, resulting in faster join processing.
3. Improved performance: By minimizing disk I/O operations and reducing the amount of data being
joined, specifying the smaller table as the master table can significantly improve the performance of the
Joiner transformation.

What happens if the larger table is specified as the master table?

1. Increased memory usage: If the larger table is specified as the master table, the Joiner transformation
may require more memory to store the entire table, potentially leading to memory issues.
2. Slower join processing: With the larger table as the master table, the Joiner transformation may need
to perform more disk I/O operations, resulting in slower join processing.
3. Decreased performance: Specifying the larger table as the master table can lead to decreased
performance, as the Joiner transformation needs to handle more data and perform additional disk I/O
operations.
In summary, specifying the table with lesser rows as the master table in a Joiner transformation is a
best practice for performance optimization, as it reduces memory usage, improves join processing
speed, and enhances overall performance.

35.Difference between Cached lookup and Un-cached lookup?

In Informatica, a Lookup transformation can be configured to use either a Cached Lookup or an
Uncached Lookup. The main difference between these two approaches lies in how the lookup data is
stored and retrieved:

Cached Lookup
1. Stores lookup data in memory: The lookup data is cached in memory, allowing for faster lookup
operations.
2. Faster lookup performance: Since the data is stored in memory, lookup operations are faster and more
efficient.
3. Reduced database queries: By storing the lookup data in memory, the number of database queries is
reduced, resulting in improved performance.
4. Suitable for static or infrequently changing data: Cached Lookup is suitable for lookup data that does
not change frequently, as the cached data can be reused.

Uncached Lookup
1. Retrieves lookup data from the database in real-time: The lookup data is retrieved from the database
in real-time, without caching.
2. Slower lookup performance: Since the data is retrieved from the database in real-time, lookup
operations can be slower.
3. Increased database queries: Uncached Lookup results in more database queries, which can impact
performance.
4. Suitable for dynamic or frequently changing data: Uncached Lookup is suitable for lookup data that
changes frequently, as the latest data is always retrieved from the database.

Key differences
1. Performance: Cached Lookup is generally faster than Uncached Lookup.
2. Data freshness: Uncached Lookup ensures that the latest data is always retrieved, while Cached
Lookup may use stale data if the cache is not updated.
3. Database queries: Cached Lookup reduces database queries, while Uncached Lookup increases them.
In summary, Cached Lookup is suitable for static or infrequently changing data, while Uncached
Lookup is suitable for dynamic or frequently changing data. The choice between Cached and Uncached
Lookup depends on the specific requirements of your ETL process.

36.Explain what DTM does when you start a work flow?

When you start a workflow in Informatica, the DTM (Data Transformation Manager) performs the
following steps:

Initialization
1. Workflow validation: DTM validates the workflow configuration, including the mappings,
transformations, and session properties.
2. Resource allocation: DTM allocates the necessary resources, such as memory and CPU, for the
workflow.

Session Creation
1. Session creation: DTM creates a new session for the workflow, which includes the session properties,
such as the source and target connections.
2. Session initialization: DTM initializes the session, including setting up the logging and error handling
mechanisms.

Data Processing
1. Data reading: DTM reads the data from the source systems, according to the mapping and session
configurations.
2. Data transformation: DTM applies the transformations, such as aggregations, filters, and joins, to the
data according to the mapping configuration.
3. Data writing: DTM writes the transformed data to the target systems, according to the mapping and
session configurations.

Monitoring and Logging

1. Monitoring: DTM monitors the workflow execution, including tracking the progress, performance, and
errors.
2. Logging: DTM logs the workflow execution, including the session logs, error logs, and performance
metrics.

Completion
1. Workflow completion: DTM completes the workflow execution, including releasing the allocated
resources and updating the workflow status.
2. Post-session processing: DTM performs any post-session processing, such as sending notifications or
updating the workflow history.

37.Explain what Load Manager does when you start a work flow?
When you start a workflow in Informatica, the Load Manager performs the following steps:

Initialization
1. Workflow validation: Load Manager validates the workflow configuration, including the mappings,
transformations, and session properties.
2. Resource allocation: Load Manager allocates the necessary resources, such as memory and CPU, for
the workflow.

Load Balancing
1. Node selection: Load Manager selects the most suitable node(s) to execute the workflow, based on
factors such as node availability, workload, and resource utilization.
2. Load distribution: Load Manager distributes the workload across the selected nodes, ensuring optimal
resource utilization and minimizing bottlenecks.

Session Creation and Management

1. Session creation: Load Manager creates a new session for the workflow, which includes the session
properties, such as the source and target connections.
2. Session management: Load Manager manages the session, including monitoring its progress, handling
errors, and ensuring data consistency.

Monitoring and Control

1. Workflow monitoring: Load Manager monitors the workflow execution, including tracking the
progress, performance, and errors.
2. Control and recovery: Load Manager provides control and recovery mechanisms, such as pause,
resume, and restart, to manage the workflow execution.
By performing these steps, Load Manager ensures efficient and reliable workflow execution,
optimal resource utilization, and minimal downtime.

38.In a Sequential batch how do i stop one particular session from

running?
In a Sequential batch, you can stop a particular session from running by using the "Conditional
Execution" feature or by using a "Decision" object. Here are the steps:

Using Conditional Execution

1. Open the workflow: Open the Sequential batch workflow in the Informatica Workflow Manager.
2. Select the session: Select the session that you want to stop from running.
3. Set the conditional execution: Right-click on the session and select "Properties". In the "Properties"
window, go to the "Conditional Execution" tab.
4. Set the condition: Set the condition to "False" or a condition that will always be false. This will prevent
the session from running.

Using a Decision Object

1. Open the workflow: Open the Sequential batch workflow in the Informatica Workflow Manager.
2. Add a Decision object: Add a Decision object before the session that you want to stop from running.
3. Set the condition: Set the condition in the Decision object to "False" or a condition that will always be
false. This will route the workflow to the "False" path and skip the session.
By using either of these methods, you can stop a particular session from running in a Sequential
batch.

39.What are the types of the aggregations available in Informatica?

In Informatica, the Aggregator transformation provides several types of aggregations to perform
calculations on groups of data. Here are the types of aggregations available:

Aggregate Functions
1. Sum: Calculates the total value of a column.
2. Average: Calculates the average value of a column.
3. Count: Counts the number of rows in a group.
4. Count Distinct: Counts the number of unique values in a column.
5. Group By: Groups data by one or more columns.
6. Max: Returns the maximum value in a column.
7. Min: Returns the minimum value in a column.
8. Standard Deviation: Calculates the standard deviation of a column.
9. Variance: Calculates the variance of a column.

Advanced Aggregate Functions

1. First: Returns the first value in a column.
2. Last: Returns the last value in a column.
3. ListAgg: Concatenates values in a column into a single string.

User-Defined Aggregate Functions

1. Custom Aggregate Functions: Allows users to create custom aggregate functions using Java or other
programming languages.
These aggregate functions can be used to perform various calculations and data analysis tasks in
Informatica.

40.How do I create Indexes after the load process is done?

In Informatica, you can create indexes after the load process is complete using the "Post-Load" option in
the Session properties or by using a separate Index creation task. Here are the steps:

Method 1: Using Post-Load Option

1. Open the Session: Open the Session that loads the data into the target table.
2. Go to Session Properties: Go to the Session Properties window.
3. Click on Post-Load: In the Session Properties window, click on the "Post-Load" tab.
4. Select Index Creation: Select the "Create Indexes" option.
5. Specify Indexes: Specify the indexes you want to create, including the index name, columns, and index
type.
6. Save and Run: Save the Session properties and run the Session.

Method 2: Using a Separate Index Creation Task

1. Create a New Task: Create a new task in the workflow, such as a SQL task or a Command task.
2. Specify Index Creation SQL: Specify the SQL command to create the indexes, including the index name,
columns, and index type.
3. Link to Load Task: Link the Index creation task to the load task, so that it runs after the load task is
complete.
4. Run the Workflow: Run the workflow, which will load the data and then create the indexes.
By using either of these methods, you can create indexes after the load process is complete, which
can improve query performance and data retrieval efficiency.
41.How do we improve the performance of the aggregator
transformation?
The Aggregator transformation is a powerful tool in Informatica, but it can be a performance bottleneck
if not optimized properly. Here are some tips to improve the performance of the Aggregator
transformation:

Optimizing Aggregator Performance

1. Optimize Aggregate Functions
- Use the minimum number of aggregate functions required.
- Avoid using unnecessary aggregate functions, such as COUNT(*) when you only need
COUNT(column_name).

2. Optimize Group By Clauses

- Use the minimum number of columns in the GROUP BY clause.
- Avoid using unnecessary columns in the GROUP BY clause.

3. Use Indexes
- Create indexes on the columns used in the GROUP BY clause and aggregate functions.
- Ensure that the indexes are properly maintained and updated.

4. Optimize Data Types

- Use the smallest possible data type for the columns used in the aggregate functions.
- Avoid using large data types, such as VARCHAR(255), when a smaller data type, such as VARCHAR(50),
would suffice.

5. Partition Data
- Partition the data into smaller chunks to reduce the amount of data being processed.
- Use partitioning techniques, such as range partitioning or hash partitioning.

6. Use Multiple Aggregator Transformations

- Break down complex aggregations into multiple Aggregator transformations.
- Use each Aggregator transformation to perform a specific aggregation.

7. Optimize Memory Allocation

- Ensure that the Aggregator transformation has sufficient memory allocated.
- Adjust the memory allocation settings as needed to optimize performance.

8. Avoid Using Distinct

- Avoid using the DISTINCT keyword in aggregate functions, as it can slow down performance.
- Instead, use the GROUP BY clause to eliminate duplicate values.

9. Use a Sorted Input

- Ensure that the input data is sorted on the columns used in the GROUP BY clause.
- Use a Sorted Input transformation to sort the data before passing it to the Aggregator transformation.

10. Monitor Performance

- Monitor the performance of the Aggregator transformation using Informatica's built-in monitoring
tools.
- Analyze the performance metrics to identify bottlenecks and optimize the transformation accordingly.
By following these tips, you can significantly improve the performance of the Aggregator transformation
and optimize your Informatica workflows.

42.What are the different types of the caches available in Informatica?

Explain in detail?
In Informatica, caching is a technique used to improve performance by storing frequently accessed data
in memory. Informatica provides several types of caches to optimize different aspects of data processing.
Here are the different types of caches available in Informatica:

1. Lookup Cache
- Purpose: Improves the performance of Lookup transformations by storing lookup data in memory.
- How it works: The Lookup Cache stores the lookup data in memory, allowing the Integration Service to
quickly retrieve the data without having to query the lookup source.
- Benefits: Reduces the number of queries to the lookup source, improving performance and reducing
the load on the lookup source.

2. Aggregator Cache
- Purpose: Improves the performance of Aggregator transformations by storing aggregated data in
memory.
- How it works: The Aggregator Cache stores the aggregated data in memory, allowing the Integration
Service to quickly retrieve the data without having to re-aggregate it.
- Benefits: Reduces the time required to perform aggregations, improving performance and reducing the
load on the system.

3. Joiner Cache
- Purpose: Improves the performance of Joiner transformations by storing join data in memory.
- How it works: The Joiner Cache stores the join data in memory, allowing the Integration Service to
quickly retrieve the data without having to re-join it.
- Benefits: Reduces the time required to perform joins, improving performance and reducing the load on
the system.

4. Data Cache
- Purpose: Improves the performance of data processing by storing frequently accessed data in memory.
- How it works: The Data Cache stores frequently accessed data in memory, allowing the Integration
Service to quickly retrieve the data without having to access the underlying data source.
- Benefits: Reduces the time required to access data, improving performance and reducing the load on
the underlying data source.

5. Index Cache
- Purpose: Improves the performance of data processing by storing index data in memory.
- How it works: The Index Cache stores index data in memory, allowing the Integration Service to quickly
retrieve the data without having to access the underlying index.
- Benefits: Reduces the time required to access index data, improving performance and reducing the
load on the underlying index.
6. Pushdown Optimization Cache
- Purpose: Improves the performance of data processing by storing pushdown optimization data in
memory.
- How it works: The Pushdown Optimization Cache stores pushdown optimization data in memory,
allowing the Integration Service to quickly retrieve the data without having to re-optimize it.
- Benefits: Reduces the time required to perform pushdown optimization, improving performance and
reducing the load on the system.
In summary, Informatica provides several types of caches to optimize different aspects of data
processing. By using these caches, you can improve performance, reduce the load on the system, and
optimize data processing.

43.What is polling in informatica?

In Informatica, polling refers to the process of repeatedly checking the status of an external device or
system by a client program. This is often used in input/output (I/O) operations, where the client program
waits for the external device to become ready or to complete a task.¹
Think of it like a server checking on the status of a printer. The server will repeatedly send a signal to the
printer, asking if it's ready to print, until the printer responds with a "yes" or "no". This process is called
polling.

Polling can be used in various scenarios, such as:

- Checking the status of an external device: Polling can be used to check if an external device, like a
printer or a scanner, is ready to perform a task.
- Waiting for data to become available: Polling can be used to wait for data to become available from an
external source, like a database or a file.
- Monitoring the status of a process: Polling can be used to monitor the status of a process, like a
workflow or a job, and take action when the process completes or reaches a certain state.
While polling can be an effective way to manage external devices or systems, it can also be
resource-intensive and may lead to performance issues if not implemented carefully.

44.What are the limitations of the joiner transformation?

The Joiner transformation in Informatica is a powerful tool for combining data from multiple sources, but
it does have some limitations. Here are some of the key limitations:

1. Data Volume Limitation: The Joiner transformation can handle large volumes of data, but it may not
perform well with extremely large datasets.
2. Memory Limitation: The Joiner transformation requires sufficient memory to store the data from both
sources. If the data is too large, it may not fit in memory, leading to performance issues.
3. Complex Join Conditions: The Joiner transformation supports simple join conditions, but complex join
conditions may not be supported.
4. Multiple Master Tables: The Joiner transformation only supports one master table. If you need to join
multiple master tables, you may need to use multiple Joiner transformations.
5. Self-Joins: The Joiner transformation does not support self-joins, where the same table is used as both
the master and detail tables.
6. Full Outer Joins: The Joiner transformation does not support full outer joins, where all records from
both tables are returned, even if there is no match.
7. Data Type Limitations: The Joiner transformation may not support all data types, such as LOB (Large
OBject) data types.
8. Performance Overhead: The Joiner transformation can introduce performance overhead, especially
when dealing with large datasets or complex join conditions.
9. Limited Support for Unstructured Data: The Joiner transformation may not support unstructured data,
such as XML or JSON data.
10. Limited Support for Real-Time Data: The Joiner transformation may not support real-time data, such
as data from messaging systems or streaming data sources.

It's essential to consider these limitations when designing your Informatica workflow and to choose the
most suitable transformation for your specific use case.

45.What is Mapplet?
In Informatica, a Mapplet is a reusable transformation object that contains a set of transformations and
mappings. It's a self-contained unit of work that can be used to perform a specific data transformation
task.

Think of a Mapplet as a mini-workflow that can be easily reused across multiple mappings and
workflows. Mapplets are particularly useful when you need to perform a common data transformation
task, such as data cleansing, data aggregation, or data formatting.

Here are some key features and benefits of Mapplets:

Key Features:
1. Reusability: Mapplets can be reused across multiple mappings and workflows.
2. Modularity: Mapplets are self-contained units of work that can be easily maintained and updated.
3. Flexibility: Mapplets can be used to perform a wide range of data transformation tasks.

Benefits:
1. Improved Productivity: Mapplets can save time and effort by reducing the need to recreate common
data transformation tasks.
2. Consistency: Mapplets can help ensure consistency across multiple mappings and workflows by
providing a standardized approach to data transformation.
3. Easier Maintenance: Mapplets can make it easier to maintain and update data transformation tasks by
providing a single point of maintenance.
Mapplets are a powerful feature in Informatica that can help simplify data transformation tasks,
improve productivity, and ensure consistency across multiple mappings and workflows.

46.What are active and passive transformations?

In Informatica, transformations can be classified into two categories: Active and Passive transformations.
Active Transformations
Active transformations are those that can change the number of rows or columns in the data flow. They
can perform operations such as aggregations, filtering, and sorting, which can alter the data flow.

Examples of Active transformations:

1. Aggregator
2. Filter
3. Sorter
4. Joiner
5. Router

Passive Transformations
Passive transformations, on the other hand, do not change the number of rows or columns in the data
flow. They only perform operations that modify the data values, such as conversions, calculations, and
data masking.
Examples of Passive transformations:
1. Expression
2. Converter
3. Data Masking
4. Calculator
Key differences between Active and Passive transformations:
1. Data flow modification: Active transformations can modify the data flow, while Passive
transformations do not.
2. Row and column changes: Active transformations can change the number of rows or columns, while
Passive transformations do not.
3. Data value modification: Both Active and Passive transformations can modify data values, but Passive
transformations only perform this type of operation.
Understanding the difference between Active and Passive transformations is essential for designing
efficient and effective data integration workflows in Informatica.

47.What are the options in the target session of update strategy

transformation?
In Informatica, the Update Strategy transformation allows you to specify how to update data in a target
table. In the Target session, the Update Strategy transformation provides the following options:

Update Strategy Options

1. DD_INSERT: Inserts new rows into the target table.
2. DD_UPDATE: Updates existing rows in the target table.
3. DD_DELETE: Deletes rows from the target table.
4. DD_REJECT: Rejects rows that do not meet the update criteria.

Additional Options
1. Update as Update: Treats all updates as updates, even if the row already exists in the target table.
2. Update as Insert: Treats all updates as inserts, even if the row already exists in the target table.
3. Insert Else Update: Inserts a new row if the row does not exist in the target table; otherwise, updates
the existing row.

Custom Options
1. Custom: Allows you to specify a custom update strategy using a SQL query or a stored procedure.
These options enable you to control how data is updated in the target table, ensuring that your data
integration workflow meets your specific business requirements.

48.What is a code page? Explain the types of the code pages?

In Informatica, a code page is a character encoding scheme that defines how characters are represented
as numerical values. It's essential for ensuring that data is correctly interpreted and processed, especially
when working with international characters.

Types of Code Pages in Informatica

Informatica supports various code pages, which can be categorized into the following types:
1. ASCII (American Standard Code for Information Interchange): A 7-bit code page that supports English
characters.
2. ISO 8859-1 (Latin-1): An 8-bit code page that supports Western European languages, such as French,
German, and Italian.
3. Windows Code Pages (e.g., Windows-1252): A set of code pages developed by Microsoft, which
support various languages, including English, European languages, and some Asian languages.
4. Unicode Code Pages (e.g., UTF-8, UTF-16): A set of code pages that support a wide range of languages,
including Asian languages, and can handle characters that require more than one byte to represent.
5. EBCDIC (Extended Binary Coded Decimal Interchange Code): An 8-bit code page used on IBM
mainframe systems, which supports a limited set of characters.
6. DBCS (Double-Byte Character Set) Code Pages: A set of code pages used to support Asian languages,
such as Chinese, Japanese, and Korean.

Importance of Code Pages in Informatica

Correctly specifying the code page is crucial in Informatica to ensure that:

1. Data is correctly interpreted and processed.
2. International characters are properly handled.
3. Data is accurately converted between different code pages.
By understanding the different types of code pages in Informatica, you can ensure that your data
integration workflows correctly handle character encoding and provide accurate results.

49.What do you mean rank cache?

In Informatica, a Rank Cache is a type of cache used in the Rank transformation to improve performance.
Here's what it's all about:

What is Rank Cache?

Rank Cache is a memory-based cache that stores the ranking data temporarily while the Rank
transformation is processing. This cache allows the Rank transformation to quickly retrieve and update
ranking information without having to re-read the data from the source.

How does Rank Cache work?

Here's a simplified overview:

1. Initial Load: The Rank transformation loads the initial data into the Rank Cache.
2. Ranking: The Rank transformation calculates the rankings based on the specified columns and criteria.
3. Cache Update: The Rank transformation updates the Rank Cache with the new ranking information.
4. Subsequent Processing: For subsequent rows, the Rank transformation retrieves the ranking
information from the Rank Cache instead of re-reading the data from the source.
Benefits of Rank Cache

Using Rank Cache provides several benefits:

1. Improved Performance: Rank Cache reduces the time required for ranking calculations, resulting in
faster processing times.
2. Reduced Memory Usage: By storing only the ranking data in memory, Rank Cache reduces memory
usage compared to loading the entire dataset into memory.

In summary, Rank Cache is a performance optimization technique used in the Rank transformation to
improve processing times and reduce memory usage.

50.How can you delete duplicate rows with out using Dynamic Lookup?
Tell me any other ways using lookup delete the duplicate rows?
Deleting duplicate rows without using a Dynamic Lookup can be achieved through various methods.
Here are a few approaches using Lookup transformations:

Method 1: Using an Aggregator and Lookup

1. Aggregator: Group the data by the columns you want to check for duplicates. Use the COUNT function
to count the number of occurrences of each group.
2. Lookup: Perform a Lookup on the aggregated data to identify the duplicate rows. Use the COUNT
value to determine if a row is a duplicate.
3. Filter: Use a Filter transformation to remove the duplicate rows based on the Lookup result.

Method 2: Using a Sorted Input and Lookup

1. Sorter: Sort the input data by the columns you want to check for duplicates.
2. Lookup: Perform a Lookup on the sorted data to identify the duplicate rows. Use the sorted columns
to determine if a row is a duplicate.
3. Filter: Use a Filter transformation to remove the duplicate rows based on the Lookup result.

Method 3: Using a Rank Transformation and Lookup

1. Rank: Use a Rank transformation to assign a unique rank to each row based on the columns you want
to check for duplicates.
2. Lookup: Perform a Lookup on the ranked data to identify the duplicate rows. Use the rank value to
determine if a row is a duplicate.
3. Filter: Use a Filter transformation to remove the duplicate rows based on the Lookup result.
These methods can be used to delete duplicate rows without using a Dynamic Lookup. However, the
choice of method depends on the specific requirements and constraints of your data integration project.

51.Can u copy the session in to a different folder or repository?

In Informatica, you can copy a session into a different folder or repository using the following methods:

Method 1: Copy and Paste

1. Navigate to the folder containing the session you want to copy.
2. Right-click on the session and select Copy.
3. Navigate to the destination folder or repository.
4. Right-click and select Paste.
Method 2: Drag and Drop
1. Navigate to the folder containing the session you want to copy.
2. Select the session by clicking on it.
3. Drag the session to the destination folder or repository.
4. Drop the session into the new location.

Method 3: Using the Repository Manager

1. Open the Repository Manager.
2. Navigate to the folder containing the session you want to copy.
3. Select the session by clicking on it.
4. Click on Copy in the toolbar or right-click menu.
5. Navigate to the destination folder or repository.
6. Click on Paste in the toolbar or right-click menu.
Regardless of the method you choose, the session will be copied to the new location, and you can then
modify it as needed.

52.What is tracing level and what are its types?

In Informatica, the Tracing Level is a setting that controls the amount of detail logged during a session or
workflow execution. Tracing levels help you monitor and troubleshoot your data integration processes.

Types of Tracing Levels:

Informatica provides the following tracing levels:
1. None: No tracing information is logged.
2. Terse: Logs only high-level information, such as session start and end times.
3. Normal: Logs detailed information about the session, including data flow and transformation details.
4. Verbose: Logs extensive information about the session, including detailed data flow and
transformation details, as well as performance metrics.
5. Debug: Logs highly detailed information about the session, including internal debugging information.
By adjusting the tracing level, you can control the amount of information logged during a session or
workflow execution. This helps you balance the need for detailed logging with the potential performance
impact of excessive logging.

53.What is a command that used to run a batch?

In Informatica, the command used to run a batch is:
pmcmd
pmcmd is a command-line utility that allows you to run, monitor, and manage Informatica workflows and
batches.

To run a batch using pmcmd, you would use the following syntax:
pmcmd startbatch -b <batch_name>

Replace <batch_name> with the actual name of the batch you want to run.

For example:
pmcmd startbatch -b my_batch
This command would start the batch named "my_batch".

54.What are the unsupported repository objects for a mapplet?

In Informatica, when creating a Mapplet, there are certain repository objects that are not supported.
Here are the unsupported repository objects for a Mapplet:

Unsupported Repository Objects for a Mapplet

1. Workflows: Mapplets cannot contain workflows.

2. Sessions: Mapplets cannot contain sessions.
3. Batch Sessions: Mapplets cannot contain batch sessions.
4. Command Tasks: Mapplets cannot contain command tasks.
5. Event Wait Tasks: Mapplets cannot contain event wait tasks.
6. Email Tasks: Mapplets cannot contain email tasks.
7. Decision Tasks: Mapplets cannot contain decision tasks.
8. Link Parameters: Mapplets do not support link parameters.
9. Reusable Transformations: Mapplets do not support reusable transformations.

These objects are not supported within a Mapplet because Mapplets are designed to be reusable,
modular transformations that can be easily integrated into workflows. By limiting the types of objects
that can be included in a Mapplet, Informatica ensures that Mapplets remain simple, flexible, and easy
to maintain.

55.If your workflow is running slow, what is your approach towards

performance tuning?
When a workflow is running slow, a structured approach to performance tuning is essential. Here's a
step-by-step approach to help you optimize your workflow's performance:
Step 1: Identify Performance Bottlenecks
- Use Informatica's built-in monitoring tools, such as the Workflow Monitor or Session Log, to identify
performance bottlenecks.
- Analyze the workflow's execution time, CPU usage, memory usage, and disk I/O.

Step 2: Optimize Session Properties

- Review session properties, such as:
- Batch size and commit interval.
- Data loading options (e.g., bulk loading, direct path loading).
- Error handling and logging settings.
- Adjust session properties to optimize performance.

Step 3: Optimize Transformation Settings

- Review transformation settings, such as:
- Aggregator and Joiner transformation settings.
- Filter and Router transformation settings.
- Expression and Calculator transformation settings.
- Adjust transformation settings to optimize performance.
Step 4: Optimize Data Flow and Pipelining
- Review data flow and pipelining, including:
- Data flow architecture and design.
- Pipelining and parallel processing.
- Optimize data flow and pipelining to reduce latency and improve throughput.

Step 5: Optimize Database and Storage

- Review database and storage settings, including:
- Database configuration and indexing.
- Storage configuration and disk space.
- Optimize database and storage settings to improve performance.

Step 6: Optimize Informatica Server Configuration

- Review Informatica server configuration, including:
- Server resources (CPU, memory, disk space).
- Server configuration settings (e.g., thread pool size).
- Optimize Informatica server configuration to improve performance.

Step 7: Test and Validate Performance

- Test the optimized workflow to validate performance improvements.
- Monitor workflow execution time, CPU usage, memory usage, and disk I/O.
- Make further adjustments as needed to achieve optimal performance.
By following this structured approach, you'll be able to identify and address performance bottlenecks,
optimize your workflow's performance, and achieve faster execution times.

56.What are the types of mapping wizards available in Informatica?

In Informatica, Mapping Wizards are tools that help you create mappings quickly and efficiently. There
are several types of Mapping Wizards available in Informatica, including:

Types of Mapping Wizards

1. Source-to-Target Mapping Wizard: This wizard helps you create a simple mapping from a single source
to a single target.
2. Aggregator Mapping Wizard: This wizard helps you create an Aggregator transformation to perform
calculations and aggregations on your data.
3. Joiner Mapping Wizard: This wizard helps you create a Joiner transformation to combine data from
multiple sources.
4. Lookup Mapping Wizard: This wizard helps you create a Lookup transformation to retrieve data from a
reference table.
5. Router Mapping Wizard: This wizard helps you create a Router transformation to route data to
different targets based on conditions.
6. Union Mapping Wizard: This wizard helps you create a Union transformation to combine data from
multiple sources.
7. Sorter Mapping Wizard: This wizard helps you create a Sorter transformation to sort data in ascending
or descending order.
8. Normalizer Mapping Wizard: This wizard helps you create a Normalizer transformation to normalize
data into a standard format.
9. Denormalizer Mapping Wizard: This wizard helps you create a Denormalizer transformation to
denormalize data from a normalized format.
These Mapping Wizards simplify the process of creating complex mappings and help you get started
quickly with your data integration projects.

57.After dragging the ports of three sources (Sql server, oracle,

Informix) to a single source qualifier, can we map these three ports
directly to target?
No, you cannot map the three ports directly to the target after dragging them to a single Source
Qualifier.

Why?
When you drag multiple sources to a single Source Qualifier, Informatica creates a Union transformation
implicitly. This Union transformation combines the data from the multiple sources into a single data
stream.

What happens next?

To map the combined data stream to the target, you need to create a mapping that includes the Union
transformation. The Union transformation will output a single set of ports that represent the combined
data from the multiple sources.

Mapping to the target

ou can then map the output ports of the Union transformation to the target. This way, you can transform
and load the combined data from the multiple sources into the target.

So, to summarize:
1. Dragging multiple sources to a single Source Qualifier creates an implicit Union transformation.
2. The Union transformation combines the data from the multiple sources into a single data stream.
3. You need to create a mapping that includes the Union transformation to map the combined data
stream to the target.
Hope that helps clarify things!

58.Why we use stored procedure transformation?

In Informatica, the Stored Procedure transformation is used to execute a stored procedure in a relational
database management system (RDBMS). Here are some reasons why you might use a Stored Procedure
transformation:

Reasons to use Stored Procedure Transformation

1. Reusability: Stored procedures can be reused across multiple mappings and workflows, reducing the
need to recreate similar logic.
2. Performance: Stored procedures can improve performance by reducing the amount of data that needs
to be transferred between the Informatica server and the database.
3. Complex logic: Stored procedures can handle complex logic and calculations that might be difficult or
impossible to implement using Informatica transformations.
4. Database-specific functionality: Stored procedures can leverage database-specific functionality, such
as Oracle's PL/SQL or Microsoft SQL Server's T-SQL.
5. Security: Stored procedures can provide an additional layer of security by encapsulating sensitive logic
and data within the database.
6. Auditing and logging: Stored procedures can provide auditing and logging capabilities, making it easier
to track changes and errors.

When to use Stored Procedure Transformation

1. Complex data processing: Use a Stored Procedure transformation when you need to perform complex
data processing that involves multiple steps or calculations.
2. Database-specific operations: Use a Stored Procedure transformation when you need to perform
database-specific operations, such as creating or dropping tables, or executing database-specific
functions.
3. Reusing existing logic: Use a Stored Procedure transformation when you want to reuse existing logic or
code that is already implemented in a stored procedure.
By using a Stored Procedure transformation, you can leverage the power and flexibility of stored
procedures to simplify your data integration workflows and improve performance.

59.Which object is required by the debugger to create a valid debug

session?
The object required by the Debugger to create a valid debug session is:

Mapping
The Debugger requires a valid mapping to create a debug session. The mapping defines the data flow
and transformations that will be executed during the debug session.

When you create a debug session, the Debugger uses the mapping to:
1. Identify the sources and targets involved in the data flow.
2. Determine the transformations and operations that will be executed.
3. Set up the necessary connections and configurations for the debug session.
Without a valid mapping, the Debugger cannot create a debug session, and you will not be able to debug
your data integration workflow.

60.Can we use an active transformation after update strategy

transformation?
No, you cannot use an Active transformation after an Update Strategy transformation.

Update Strategy transformation is used to specify the update strategy for target table, and it must be the
last transformation in the mapping.

According to Informatica, "You cannot use an Active transformation after an Update Strategy
transformation. The Update Strategy transformation must be the last transformation in the mapping."

61.Explain how we set the update strategy transformation at the

mapping level and at the session level?
In Informatica, you can set the Update Strategy transformation at both the mapping level and the
session level.
Mapping Level

To set the Update Strategy transformation at the mapping level:

1. Open the mapping in the Mapping Designer.

2. Go to the Mappings menu and select Properties.
3. In the Mapping Properties window, click on the Update Strategy tab.
4. Select the desired update strategy (e.g., DDU (Data Direct Update), DDI (Data Direct Insert), etc.).
5. Configure the update strategy settings as needed.

Session Level

To set the Update Strategy transformation at the session level:

1. Open the workflow in the Workflow Manager.

2. Select the session that corresponds to the mapping.
3. Go to the Properties tab.
4. Click on the Mapping tab.
5. In the Update Strategy section, select the desired update strategy.
6. Configure the update strategy settings as needed.

Note that the update strategy set at the session level overrides the update strategy set at the mapping
level.

62.What is exact use of 'Online' and 'Offline' server connect Options

while defining Work flow in Work flow monitor? The system hangs
when 'Online' Server connect option. The Informatica is installed on a
Personal laptop.
In Informatica Workflow Monitor, the "Online" and "Offline" server connect options determine how the
workflow connects to the Informatica Server.

Online Server Connect Option

- Connects to the Informatica Server in real-time.
- Allows for immediate execution and monitoring of workflows.
- Enables real-time updates and feedback.

Offline Server Connect Option

- Connects to the Informatica Server in batch mode.
- Allows for scheduling workflows to run at a later time.
- Enables workflows to run without real-time monitoring.

Why the System Hangs with 'Online' Option

When you select the "Online" server connect option on a personal laptop, the system may hang
due to:
1. Resource constraints: Informatica requires significant system resources. Running it on a personal
laptop can consume CPU, memory, and disk resources, leading to performance issues.
2. Network connectivity: Online mode requires a stable and fast network connection. If your laptop's
network connection is slow or unstable, it can cause the system to hang.
3. Server overload: If the Informatica Server is handling a large workload or is experiencing performance
issues, it can cause the client application to hang.

Best Practice
To avoid system hangs, consider the following:
1. Use Offline mode: When working on a personal laptop, use the Offline server connect option to
reduce the load on your system and network resources.
2. Optimize system resources: Ensure your laptop has sufficient CPU, memory, and disk resources to run
Informatica smoothly.
3. Check network connectivity: Verify that your network connection is stable and fast before using the
Online server connect option.

63.What is change data capture?

Change Data Capture (CDC) is a process that captures and tracks changes made to data in a database or
other data storage system. CDC identifies, captures, and delivers changes made to data in real-time or
near-real-time, allowing for:

1. Data replication: CDC enables the replication of data changes to other systems, ensuring data
consistency and synchronization.
2. Data integration: CDC facilitates the integration of data changes with other systems, applications, or
processes.
3. Auditing and compliance: CDC provides a record of all changes made to data, supporting auditing,
compliance, and regulatory requirements.
4. Real-time analytics: CDC enables real-time analytics and reporting by providing timely and accurate
data changes.

CDC typically involves the following steps:

1. Data source identification: Identify the data sources to be monitored for changes.
2. Change detection: Detect changes made to the data, such as inserts, updates, or deletes.
3. Change capture: Capture the changes and store them in a format suitable for processing.
4. Change delivery: Deliver the captured changes to target systems, applications, or processes.

CDC is commonly used in various industries, including:

1. Finance and banking: For real-time transaction processing and auditing.

2. Healthcare: For tracking patient data changes and ensuring compliance.
3. E-commerce: For real-time inventory management and order processing.

CDC can be implemented using various technologies, including:

1. Database triggers: Database triggers can be used to capture changes made to data.
2. Log-based CDC: Log-based CDC involves reading database logs to capture changes.
3. API-based CDC: API-based CDC involves using APIs to capture changes made to data.

64.Write a session parameter file which will change the source and
targets for every session. i.e different source and targets for each
session run ?
Here's an example of a session parameter file (.spf) that allows you to change the source and targets for
every session run:

$$SOURCE_DB=database_name
$$SOURCE_SCHEMA=schema_name
$$SOURCE_TABLE=table_name

$$TARGET_DB=database_name
$$TARGET_SCHEMA=schema_name
$$TARGET_TABLE=table_name

To use this session parameter file:

1. Create a new file with a .spf extension (e.g., session_params.spf).

2. Add the above parameters to the file.
3. Save the file.
4. In Informatica, create a new session or edit an existing one.
5. In the Session Properties, click on the "Parameter File" tab.
6. Browse to the location of the session_params.spf file and select it.
7. Click "OK" to save the changes.

Now, every time you run the session, you can modify the source and target parameters by editing the
session_params.spf file.
For example:

- To change the source database, update the $$SOURCE_DB parameter in the file.
- To change the target table, update the $$TARGET_TABLE parameter in the file.

By using a session parameter file, you can easily switch between different sources and targets for each
session run.

65.What are partition points?

In Informatica, partition points are points in a mapping where the data can be divided into multiple
partitions, allowing for parallel processing and improved performance.

Partition points are used to:

1. Split data: Divide large datasets into smaller, more manageable partitions.
2. Parallelize processing: Process multiple partitions concurrently, improving overall performance.
3. Optimize data processing: Partition data to optimize processing, such as aggregating data or
performing joins.

Types of partition points:

1. Partitioner: A transformation that divides data into multiple partitions based on a specified
partitioning strategy.
2. Aggregator: A transformation that groups data and performs aggregate calculations, such as SUM or
COUNT.
3. Joiner: A transformation that combines data from multiple sources based on a common key.

Benefits of partition points:

1. Improved performance: Parallel processing of partitions improves overall performance.
2. Increased scalability: Partitioning allows for processing large datasets.
3. Better data management: Partitioning enables efficient data management and processing.

To use partition points in Informatica:

1. Create a mapping: Design a mapping that includes a partitioner, aggregator, or joiner transformation.
2. Configure partition points: Configure the partitioning strategy and settings for each transformation.
3. Run the mapping: Execute the mapping, and Informatica will process the data in parallel, using the
partition points.

66.What are the different threads in DTM process?

In Informatica, the DTM (Data Transformation Manager) process uses multiple threads to manage and
execute data transformations. Here are the different threads involved in the DTM process:

1. Reader Thread
The Reader thread reads data from the source system, such as a database or file.

2. Transformation Thread
The Transformation thread applies the data transformation rules, such as aggregations, joins, and data
conversions.

3. Writer Thread
The Writer thread writes the transformed data to the target system, such as a database or file.

4. Sorter Thread (Optional)

The Sorter thread sorts the data before it is written to the target system.

5. Aggregator Thread (Optional)

The Aggregator thread performs aggregate calculations, such as SUM or COUNT, on the data.

6. Joiner Thread (Optional)

The Joiner thread combines data from multiple sources based on a common key.

7. DTM Thread
The DTM thread manages the overall DTM process, including thread creation, synchronization, and error
handling.
These threads work together to efficiently process and transform data, improving overall performance
and scalability.

67.Can we do ranking on two ports? If yes explain how?

Yes, you can do ranking on two ports in Informatica.
Ranking on two ports is also known as "composite ranking" or "multi-column ranking". This allows you to
rank data based on the combination of two or more columns.
To do ranking on two ports in Informatica, you can use the RANK function in the Aggregator
transformation.
Here's an example:
Suppose you have a table with two columns: Sales and Region. You want to rank the sales data by region,
and then by sales amount within each region.
1. In the Aggregator transformation, create two input ports: Sales and Region.
2. Create a new output port, e.g., Rank.
3. In the Rank port, use the RANK function with the following syntax:
RANK( Sales, Region, 'DESC', 'DENSE')
This will rank the data by Sales in descending order, and then by Region in ascending order (default). The
'DENSE' option ensures that there are no gaps in the ranking.
1. Configure the Aggregator transformation to perform the ranking.
The resulting output will have the ranked data based on the combination of Sales and Region.
Note that you can adjust the ranking order, density, and other options as needed.

68.What is Transformation?
In Informatica, a transformation is a repository object that performs a specific operation on data, such as
aggregating, filtering, or converting data.
Transformations are used to manipulate and transform data as it flows through a mapping, which is a set
of instructions that defines how data is extracted, transformed, and loaded (ETL) into a target system.
There are several types of transformations in Informatica, including:

1. Aggregator: Performs aggregate calculations, such as SUM, COUNT, or AVG.

2. Filter: Filters data based on conditions, such as selecting only rows that meet certain criteria.
3. Joiner: Combines data from multiple sources based on a common key.
4. Lookup: Retrieves data from a reference table or file.
5. Expression: Performs calculations or data conversions using expressions.
6. Router: Routes data to different targets based on conditions.
7. Sorter: Sorts data in ascending or descending order.
8. Union: Combines data from multiple sources into a single output.
Transformations can be connected to each other to create a complex data flow, allowing for
sophisticated data manipulation and transformation.

69.What does stored procedure transformation do in special as

compared to other transformation?
The Stored Procedure transformation in Informatica is a special transformation that allows you to
execute a stored procedure on a relational database management system (RDBMS).
Here's what makes it special compared to other transformations:
1. Execution of stored procedures: This transformation enables you to execute stored procedures on a
database, which can perform complex operations, such as data manipulation, calculations, or data
validation.
2. Database-specific operations: Stored Procedure transformation allows you to perform database-
specific operations, such as executing Oracle PL/SQL or Microsoft SQL Server T-SQL code.
3. Input and output parameters: You can pass input parameters to the stored procedure and retrieve
output parameters, enabling data exchange between the mapping and the stored procedure.
4. Error handling: The Stored Procedure transformation provides error handling capabilities, allowing you
to manage errors and exceptions returned by the stored procedure.
5. Reusability: Stored procedures can be reused across multiple mappings, reducing development time
and improving maintainability.
In summary, the Stored Procedure transformation offers a unique set of capabilities that enable you to
leverage the power of stored procedures on relational databases, making it a valuable addition to your
data integration toolkit.

70.How do you recognize whether the newly added rows got inserted
or updated?
To recognize whether newly added rows got inserted or updated, you can use the following methods:

Method 1: Using Informatica's Built-in Auditing

1. Enable auditing in Informatica.
2. Configure the auditing to capture the necessary information, such as the operation type (INSERT,
UPDATE, DELETE).
3. After running the mapping, check the audit logs to see if the newly added rows were inserted or
updated.

Method 2: Using a Flag or Indicator

1. Add a flag or indicator column to the target table.
2. In the mapping, set the flag to 'I' for insert or 'U' for update.
3. After running the mapping, check the flag column to see if the newly added rows were inserted or
updated.

Method 3: Using a Timestamp or Date Column

1. Add a timestamp or date column to the target table.
2. In the mapping, update the timestamp or date column with the current date and time for updated
rows.
3. After running the mapping, check the timestamp or date column to see if the newly added rows were
inserted or updated.

Method 4: Using a Session Log

1. Enable session logging in Informatica.
2. Configure the session log to capture the necessary information, such as the operation type (INSERT,
UPDATE, DELETE).
3. After running the mapping, check the session log to see if the newly added rows were inserted or
updated.

71.What is data cleansing?

Data cleansing, also known as data cleaning or data scrubbing, is the process of identifying, correcting,
and transforming inaccurate, incomplete, or inconsistent data into a clean and reliable format.

Data cleansing involves:

1. Identifying errors: Detecting errors, inconsistencies, and inaccuracies in the data.
2. Correcting errors: Correcting or replacing incorrect or missing data with accurate and complete data.
3. Transforming data: Transforming data into a consistent format, such as converting date formats or
standardizing address formats.
4. Removing duplicates: Removing duplicate records or data entries.
5. Handling missing values: Handling missing values, such as replacing them with default values or
ignoring them.

Data cleansing is essential to ensure:

1. Data quality: Ensuring that data is accurate, complete, and consistent.
2. Data integrity: Ensuring that data is reliable and trustworthy.
3. Business decisions: Ensuring that business decisions are made based on accurate and reliable data.

Data cleansing can be performed using various techniques, including:

1. Data profiling: Analyzing data to identify errors and inconsistencies.
2. Data validation: Validating data against predefined rules and constraints.
3. Data standardization: Standardizing data formats and structures.
4. Data matching: Matching data records to identify duplicates or inconsistencies.
Data cleansing is a critical step in the data integration process, and it's essential to perform it
regularly to maintain high-quality data.

72.My flat file’s size is 400 MB and I want to see the data inside the FF
with out opening it? How do I do that?
You can use the head or tail command in Unix/Linux or the type command in Windows to view a portion
of the flat file without opening it.

Here are the steps:

Unix/Linux
1. Open a terminal and navigate to the directory where the flat file is located.
2. Use the head command to view the first few lines of the file:

head -n 10 filename
Replace filename with the name of your flat file, and 10 with the number of lines you want to view.
3. Alternatively, use the tail command to view the last few lines of the file:

tail -n 10 filename
Windows
1. Open a command prompt and navigate to the directory where the flat file is located.
2. Use the type command to view a portion of the file:
type filename | more
Replace filename with the name of your flat file. The more command will display the file one screen at a
time.
These methods allow you to view a portion of the flat file without opening it, which can be helpful for
large files like yours (400 MB).

73.Difference between Filter and Router?

In Informatica, both Filter and Router transformations are used to control the flow of data, but they
serve different purposes and have distinct differences:

Filter Transformation
1. Purpose: Filters out data that does not meet specific conditions.
2. Functionality: Evaluates each row of data against a condition, and if the condition is true, the row is
passed through; otherwise, it is discarded.
3. Output: Only one output is possible, which is the filtered data.

Router Transformation
1. Purpose: Routes data to different targets based on conditions.
2. Functionality: Evaluates each row of data against multiple conditions, and based on the condition met,
the row is routed to the corresponding target.
3. Output: Multiple outputs are possible, each corresponding to a specific condition.

Key differences:
- Filtering vs. Routing: Filter transformation filters out data, whereas Router transformation routes data
to different targets.
- Number of Outputs: Filter has only one output, whereas Router can have multiple outputs.
- Condition Evaluation: Filter evaluates data against a single condition, whereas Router evaluates data
against multiple conditions.
In summary, use Filter when you want to remove data that doesn't meet a specific condition, and
use Router when you want to direct data to different targets based on multiple conditions.

74.How do you handle the decimal places when you are importing the
flat file?
When importing a flat file, handling decimal places can be a bit tricky. Here are some ways to handle
decimal places:
1. Specify the decimal separator: In Informatica, you can specify the decimal separator in the flat file
definition. For example, if the decimal separator is a comma (,), you can specify it in the flat file
definition.
2. Use a data type with decimal places: When defining the flat file structure, use a data type that
supports decimal places, such as Decimal or Numeric.
3. Specify the precision and scale: When using a Decimal or Numeric data type, specify the precision
(total number of digits) and scale (number of digits after the decimal point).
4. Use a transformation to handle decimal places: If the flat file contains decimal places in a format that's
not supported by Informatica, you can use a transformation (such as an Expression transformation) to
handle the decimal places.
5. Use a format string: When importing the flat file, you can use a format string to specify the decimal
separator and other formatting options.

Some examples of format strings:

- DECIMAL(10,2) : specifies a decimal number with a total of 10 digits, 2 of which are after the decimal
point.
- NUMERIC(10,2) : similar to the previous example, but uses the Numeric data type.
- #,##0.00 : specifies a decimal number with a comma as the thousand separator and a dot as the
decimal separator.
By using these methods, you can handle decimal places when importing a flat file into
Informatica.

75.What is the difference between $ & $$ in mapping or parameter file?

In which case they are generally used?
In Informatica, $ and $$ are used to reference parameters in a mapping or parameter file. The difference
between them lies in the scope and usage:
- $ (Single Dollar Sign)

Used to reference a parameter that is defined within the same mapping or parameter file.
Example: $ParameterName

- $$ (Double Dollar Sign)

Used to reference a parameter that is defined at the session level or in a parent parameter file.
Example: $$ParameterName

When to use each:

- Use $ when referencing a parameter that is specific to the current mapping or parameter file.
- Use $$ when referencing a parameter that is shared across multiple mappings or sessions.

Best practices:
- Use $ for mapping-specific parameters to avoid conflicts with session-level parameters.
- Use $$ for session-level parameters to ensure they are accessible across multiple mappings.

By using $ and $$ correctly, you can effectively manage parameters in your Informatica mappings and
parameter files.

76.While importing the relational source definition from database, what

are the meta data of source U import?
When importing a relational source definition from a database, Informatica imports the following
metadata:

1. Table structure: Column names, data types, and lengths.

2. Column properties: Nullability, default values, and comments.
3. Primary keys: Primary key constraints, including the columns that make up the primary key.
4. Foreign keys: Foreign key constraints, including the columns that make up the foreign key and the
referenced table.
5. Indexes: Index names, index types, and columns included in the index.
6. Table comments: Comments associated with the table.
7. Column comments: Comments associated with each column.
8. Data type information: Information about the data types used in the table, such as the length and
precision of numeric columns.

This metadata is used to create a source definition in Informatica, which can then be used to extract data
from the relational database.

By importing this metadata, you can save time and effort in defining your source structure, and ensure
accuracy and consistency in your data integration processes.

77.Difference between Power mart & Power Center?

PowerMart and PowerCenter are both data integration tools developed by Informatica, but they serve
different purposes and have distinct differences:

PowerMart
1. Data mart-focused: Designed specifically for data mart and data warehouse environments.
2. Simplified architecture: Has a simpler architecture compared to PowerCenter.
3. Limited scalability: Suitable for smaller-scale data integration projects.
4. Fewer features: Offers a subset of features compared to PowerCenter.

PowerCenter
1. Enterprise-focused: Designed for large-scale, enterprise-wide data integration projects.
2. Robust architecture: Has a more robust and scalable architecture.
3. High scalability: Suitable for large-scale data integration projects.
4. Advanced features: Offers a wide range of advanced features, including real-time data integration,
data quality, and data governance.
In summary, PowerMart is ideal for smaller-scale data mart and data warehouse projects, while
PowerCenter is better suited for large-scale, enterprise-wide data integration initiatives.

78.What kinds of sources and of targets can be used in Informatica?

Informatica supports a wide range of sources and targets, including:
Sources
1. Relational databases (e.g., Oracle, Microsoft SQL Server, DB2)
2. Flat files (e.g., CSV, XML, JSON)
3. Cloud storage (e.g., Amazon S3, Azure Blob Storage)
4. NoSQL databases (e.g., MongoDB, Cassandra)
5. Big Data sources (e.g., Hadoop, Spark)
6. ERP systems (e.g., SAP, Oracle EBS)
7. CRM systems (e.g., Salesforce)
8. Mainframe systems (e.g., COBOL, VSAM)
9. Web services (e.g., SOAP, REST)
10. Messaging systems (e.g., JMS, MQ)
Targets
1. Relational databases (e.g., Oracle, Microsoft SQL Server, DB2)
2. Flat files (e.g., CSV, XML, JSON)
3. Cloud storage (e.g., Amazon S3, Azure Blob Storage)
4. NoSQL databases (e.g., MongoDB, Cassandra)
5. Big Data targets (e.g., Hadoop, Spark)
6. Data warehouses (e.g., Amazon Redshift, Google BigQuery)
7. Data lakes (e.g., Amazon S3, Azure Data Lake)
8. Messaging systems (e.g., JMS, MQ)
9. Web services (e.g., SOAP, REST)
10. ERP systems (e.g., SAP, Oracle EBS)

Informatica also supports various protocols and technologies, such as:

- ODBC, JDBC, and OLE DB for database connectivity
- FTP, SFTP, and HTTP for file transfers
- Web services and REST APIs for integration with web-based applications
- Messaging protocols like JMS, MQ, and AMQP for integration with messaging systems
This wide range of supported sources and targets enables Informatica to integrate data from various
systems and applications, making it a powerful tool for data integration and management.

79.If a sequence generator (with increment of 1) is connected to (say) 3

targets and each target uses the NEXTVAL port, what value will each
target get?
When a sequence generator is connected to multiple targets, each target will receive a unique value
from the sequence generator.
In this scenario, since the sequence generator has an increment of 1, each target will receive a
consecutive value from the sequence.
Here's what will happen:
1. The first target will receive the current value of the sequence (e.g., 1).
2. The second target will receive the next value in the sequence (e.g., 2), which is obtained by
incrementing the current value by 1.
3. The third target will receive the next value in the sequence (e.g., 3), which is obtained by incrementing
the previous value by 1.
So,each target will receive a unique and consecutive value from the sequence generator.
Here's a summary:
Target 1: 1
Target 2: 2
Target 3: 3
This behavior ensures that each target receives a unique identifier, which is useful in various scenarios,
such as generating primary keys or unique IDs.

80.What do you mean by SQL override?

In Informatica, a SQL override is a feature that allows you to override the default SQL query generated by
Informatica with a custom SQL query.
When you create a mapping in Informatica, the tool generates a default SQL query to extract data from
the source database. However, in some cases, you may need to customize this query to meet specific
requirements, such as:
- Optimizing query performance
- Handling complex data transformations
- Incorporating custom business logic

A SQL override enables you to replace the default SQL query with a custom query that meets your
specific needs. You can enter your custom SQL query in the SQL override editor, and Informatica will use
this query instead of the default one.
SQL overrides can be applied at various levels, including:
- Source qualifier
- Aggregator
- Joiner
- Target
By using SQL overrides, you can gain more control over the data extraction process, optimize query
performance, and implement custom business logic.

81.What is a shortcut in Informatica?

In Informatica, a shortcut is a reference to a transformation or a group of transformations that can be
reused in multiple mappings.
A shortcut is a way to:
1. Reuse transformations: Instead of recreating the same transformation in multiple mappings, you can
create a shortcut to the original transformation.
2. Simplify complex mappings: Break down a complex mapping into smaller, manageable pieces, and
then create shortcuts to these pieces.
3. Improve maintainability: When you need to make changes to a transformation, you only need to
update the original transformation, and the changes will be reflected in all the mappings that use the
shortcut.

To create a shortcut in Informatica:

1. Select the transformation(s) you want to reuse.
2. Right-click on the transformation(s) and select "Create Shortcut".
3. Give the shortcut a name and description.
Once you've created a shortcut, you can drag and drop it into any mapping, just like you would with
a regular transformation.

82.How does Informatica do variable initialization? Number/String/Date

In Informatica, variable initialization is done differently for different data types. Here's how Informatica
initializes variables for Number, String, and Date data types:
Number
- Default initialization value: 0 (zero)
- If you don't explicitly initialize a numeric variable, it will default to 0.
String
- Default initialization value: NULL (empty string)
- If you don't explicitly initialize a string variable, it will default to NULL.
Date
- Default initialization value: 12/31/1899 ( Informatica's default date)
- If you don't explicitly initialize a date variable, it will default to 12/31/1899.
To initialize variables in Informatica, you can use the following methods:
1. Parameter File: Define initial values for variables in a parameter file.
2. Mapping Variables: Initialize variables within a mapping using the "Variables" tab.
3. Expression Transformation: Use an Expression transformation to initialize variables with a specific
value or expression.
Remember to always explicitly initialize variables to ensure predictable behavior in your mappings.

83.How many different locks are available for repository objects

In Informatica, there are three different types of locks available for repository objects:
Types of Locks
1. Exclusive Lock: This lock prevents other users from accessing or modifying the object until the lock is
released.
2. Shared Lock: This lock allows multiple users to access the object simultaneously, but prevents any user
from modifying the object until all shared locks are released.
3. Break Lock: This lock is used to override an existing lock held by another user. When a break lock is
applied, the existing lock is released, and the new user gains exclusive access to the object.
These locks help prevent conflicts and ensure data consistency when multiple users are working with
repository objects.

84.What are the transformations that use cache for performance?

In Informatica, the following transformations use cache for performance:
- Aggregator Transformation
- Joiner Transformation
- Lookup Transformation
- Rank Transformation
- Sorter Transformation
These transformations use cache to store data temporarily, which improves performance by:
- Reducing the number of database queries
- Minimizing data movement between transformations
- Enabling faster data processing and sorting

By leveraging cache, these transformations can handle large datasets more efficiently and improve
overall mapping performance.

85.What is the use of Forward/Reject rows in Mapping?

In Informatica, the "Forward/Reject Rows" option in a mapping is used to control the flow of rows
through a transformation or target.
Forward Rows:
- Sends rows that meet the transformation or target conditions to the next transformation or target.
- Rows that are successfully transformed or loaded are forwarded.

Reject Rows:
- Sends rows that do not meet the transformation or target conditions to a reject pipeline or a separate
reject file.
- Rows that fail transformation or loading are rejected.

Using Forward/Reject Rows:

- Improves data quality by separating valid and invalid data.
- Enables error handling and debugging by capturing rejected rows.
- Enhances data governance by tracking and auditing data processing.
By controlling the flow of rows, you can ensure that only valid data is processed and loaded into
your target systems.

86.How many ways you can filter the records?

In Informatica, there are several ways to filter records:

Filtering Methods
1. Filter Transformation: Use a filter transformation to filter records based on conditions.
2. Source Qualifier: Use a source qualifier to filter records at the source level.
3. Aggregator Transformation: Use an aggregator transformation to filter records based on aggregated
values.
4. Router Transformation: Use a router transformation to filter records based on conditions and route
them to different targets.
5. Expression Transformation: Use an expression transformation to filter records based on complex
conditions.
6. Data Validation: Use data validation to filter records based on data quality rules.

Conditional Filtering
1. Conditional Statements: Use conditional statements (e.g., IF-THEN-ELSE) to filter records.
2. Case Statements: Use case statements to filter records based on specific conditions.

Other Filtering Methods

1. Parameter Files: Use parameter files to filter records based on parameter values.
2. Mapping Variables: Use mapping variables to filter records based on variable values.

By using these methods, you can filter records in various ways to achieve your data processing goals.

87.How to delete duplicate records from source database/Flat Files?

Can we use post sql to delete these records. In case of flat file, how can
you delete duplicates before it starts loading?
Deleting duplicate records can be achieved through various methods, depending on the source type
(database or flat file) and the desired approach. Here are some methods:

Database Source
Method 1: Using a Transformation
1. Aggregator Transformation: Use an Aggregator transformation to group the data by the desired
columns and then use a Router transformation to route the duplicate records to a separate pipeline for
deletion.
2. Delete Transformation: Use a Delete transformation to delete the duplicate records.

Method 2: Using Post-SQL

1. Post-SQL: Use a Post-SQL script to delete duplicate records after the data has been loaded into the
target. This method is useful when you want to delete duplicates based on a specific condition.
Example Post-SQL script:

DELETE FROM target_table

WHERE rowid NOT IN (
SELECT MIN(rowid)
FROM target_table
GROUP BY column1, column2, ...
)

Flat File Source

Method 1: Using a Sorter Transformation
1. Sorter Transformation: Use a Sorter transformation to sort the data by the desired columns.
2. Aggregator Transformation: Use an Aggregator transformation to group the sorted data by the desired
columns.
3. Router Transformation: Use a Router transformation to route the duplicate records to a separate
pipeline for deletion.

Method 2: Using a Pre-Load Script

1. Pre-Load Script: Use a pre-load script (e.g., Python, Perl) to delete duplicate records from the flat file
before loading it into Informatica.
2. Informatica Command: Use an Informatica command (e.g., pmcmd) to execute the pre-load script
before loading the flat file.

Example pre-load script (Python):

import pandas as pd

# Load the flat file into a Pandas dataframe

df = pd.read_csv('flat_file.csv')

# Drop duplicate rows

df.drop_duplicates(inplace=True)

# Save the updated dataframe to a new flat file

df.to_csv('updated_flat_file.csv', index=False)

In summary, you can use various methods to delete duplicate records from a database or flat file source,
including transformations, post-SQL scripts, and pre-load scripts. Choose the method that best fits your
specific use case.
88.You are required to perform “bulk loading” using Informatica on
Oracle, what action would perform at Informatica + Oracle level for a
successful load?
To perform a successful bulk loading using Informatica on Oracle, follow these steps:

Informatica Level
1. Create a Mapping: Design a mapping that extracts data from the source and loads it into the Oracle
target.
2. Use a Bulk Load Option: In the Informatica mapping, enable the "Bulk Load" option for the Oracle
target. This option allows Informatica to use Oracle's bulk loading capabilities.
3. Configure the Bulk Load Properties: Set the bulk load properties, such as the batch size, commit
interval, and error handling options.
4. Use a Direct Load: Use a direct load instead of a normal load. This will allow Informatica to load data
directly into the Oracle database without using an intermediate file.

Oracle Level
1. Grant Necessary Privileges: Ensure that the Oracle user account used by Informatica has the necessary
privileges to perform bulk loading, such as the "INSERT" and "SELECT" privileges.
2. Create a Directory Object: Create a directory object in Oracle that points to the location where
Informatica will store the data files.
3. Configure the Oracle Database: Configure the Oracle database to allow bulk loading by setting the
"compatible" parameter to a value that supports bulk loading (e.g., 10.2.0 or higher).
4. Disable Logging: Consider disabling logging for the bulk load operation to improve performance.
However, this may impact data recovery in case of failures.

Additional Considerations
1. Data File Format: Ensure that the data file format used by Informatica is compatible with Oracle's bulk
loading requirements.
2. Error Handling: Configure error handling options in Informatica and Oracle to handle errors that may
occur during the bulk load operation.
3. Performance Optimization: Optimize the bulk load performance by adjusting parameters such as batch
size, commit interval, and parallelism.
By following these steps and considering the additional factors, you can perform a successful bulk
loading operation using Informatica on Oracle.

89.What precautions do you need take when you use reusable

Sequence generator transformation for concurrent sessions?
When using a reusable Sequence Generator transformation for concurrent sessions, take the following
precautions:

Precautions for Concurrent Sessions

1. Synchronization: Ensure that the sequence generator is synchronized across all sessions to avoid
duplicate or skipped sequence values.
2. Locking Mechanism: Implement a locking mechanism to prevent multiple sessions from accessing the
sequence generator simultaneously.
3. Cache Management: Manage the cache effectively to prevent sequence values from being cached and
reused across sessions.
4. Sequence Value Range: Define a unique sequence value range for each session to avoid conflicts.
5. Error Handling: Implement robust error handling to handle scenarios where sequence values are
exhausted or sessions fail.
6. Monitoring: Monitor sequence generator performance and adjust settings as needed to ensure
optimal performance.
7. Configuration: Configure the sequence generator to use a thread-safe algorithm to generate sequence
values.

Informatica-Specific Precautions
1. Use a Shared Sequence: Use a shared sequence generator transformation that can be accessed by
multiple sessions.
2. Configure Sequence Options: Configure sequence options, such as the cache size and sequence step
value, to optimize performance for concurrent sessions.
3. Use a Sequence Generator with High-Performance Options: Use a sequence generator transformation
with high-performance options, such as the "High-Performance" option in Informatica PowerCenter.
By taking these precautions, you can ensure that your reusable Sequence Generator transformation
works correctly and efficiently in a concurrent session environment.

90.Is it possible negative increment in Sequence Generator? If yes, how

would you accomplish it?
Yes, it is possible to have a negative increment in a Sequence Generator.

Accomplishing Negative Increment

In Informatica, you can accomplish a negative increment in a Sequence Generator by:
1. Setting the Increment Value to a Negative Number: In the Sequence Generator transformation, set the
"Increment" value to a negative number. For example, if you want to decrement the sequence value by
1, set the increment value to -1.
2. Using a Negative Step Value: Alternatively, you can use a negative step value in the Sequence
Generator transformation. The step value determines the amount by which the sequence value is
incremented or decremented.

Example
Suppose you want to generate a sequence of values that start from 10 and decrement by 1. You can
configure the Sequence Generator transformation as follows:
- Start Value: 10
- Increment: -1
- Step Value: 1
In this example, the Sequence Generator will produce the following sequence of values: 10, 9, 8, 7, ...
By using a negative increment value or step value, you can generate a sequence of values that
decrement instead of increment.
91.Which directory Informatica looks for parameter file and what
happens if it is missing when start the session? Does session stop after
it starts?
Informatica looks for parameter files in the following directories:
- $PMParamFileDir (parameter file directory specified in the Informatica environment variable)
- $PMRootDir/pmparamfiles (default parameter file directory)
- $PMRootDir/pmparamfiles/<session_name> (session-specific parameter file directory)

If the parameter file is missing when starting the session:

- Informatica will throw an error message indicating that the parameter file is missing.
- The session will not start, and Informatica will terminate the session startup process.
- If the session is started using the pmcmd command, the command will exit with a non-zero status code.
The session will not start if the parameter file is missing, as Informatica relies on the parameter file to
configure the session settings and parameters.

92.Informatica is complaining about the server could not be reached?

What steps would you take?
A classic error! If Informatica is complaining that the server could not be reached, here are the steps I'd
take to troubleshoot and resolve the issue:

Step 1: Check the Network Connection

Ensure that the network connection is stable and working properly. Verify that the Informatica server
and client machines can communicate with each other.

Step 2: Verify Server Status

Check if the Informatica server is running and listening on the expected port. Use commands like netstat
or telnet to verify server connectivity.

Step 3: Check Informatica Configuration

Review the Informatica configuration files (e.g., pmserver.properties, pmclient.properties) to ensure that
the server details, such as hostname, port, and username, are correct.

Step 4: Verify Firewall Settings

Check if the firewall settings on the server and client machines are blocking the connection. Ensure that
the necessary ports are open and allowed.

Step 5: Check for Server-Side Issues

Investigate server-side issues, such as:
* Insufficient resources (e.g., memory, CPU)
* Server overload or high usage
* Configuration issues or corrupted files

Step 6: Check Client-Side Issues

Investigate client-side issues, such as:
* Incorrect or outdated client software
* Configuration issues or corrupted files
* Insufficient resources (e.g., memory, CPU)

Step 7: Restart Services and Try Again

Restart the Informatica services (e.g., pmserver, pmclient) and try connecting again.

Step 8: Analyze Logs and Error Messages

Review the Informatica logs and error messages to identify the root cause of the issue.

Step 9: Seek Additional Help

If none of the above steps resolve the issue, seek additional help from Informatica support,
documentation, or online forums.

93.You have more five mappings use the same lookup. How can you
manage the lookup?
When multiple mappings share the same lookup, it's essential to manage the lookup efficiently to avoid
duplication, inconsistencies, and performance issues. Here are some ways to manage the lookup:

Reusable Transformation
Create a reusable lookup transformation that can be shared across multiple mappings. This approach
ensures that the lookup logic is consistent and maintained in one place.

Shared Lookup Transformation

Create a shared lookup transformation that can be used by multiple mappings. This approach allows you
to maintain the lookup logic in one place and reuse it across multiple mappings.

Lookup Cache
Use a lookup cache to store the lookup data in memory. This approach improves performance by
reducing the number of database queries and allowing multiple mappings to share the same lookup
data.

Mapping Parameter
Use a mapping parameter to pass the lookup data to multiple mappings. This approach allows you to
maintain the lookup data in one place and pass it to multiple mappings using a parameter.

Mapplet
Create a mapplet that contains the lookup transformation and other related transformations. This
approach allows you to reuse the lookup logic and other transformations across multiple mappings.

Benefits
Managing the lookup efficiently provides several benefits, including:
- Improved performance
- Reduced maintenance efforts
- Consistent lookup logic across multiple mappings
- Simplified debugging and troubleshooting
By using one of these approaches, you can manage the lookup efficiently and ensure that your
mappings are consistent, efficient, and easy to maintain.
94.What will happen if you copy the mapping from one repository to
another repository and if there is no identical source?
If you copy a mapping from one repository to another repository, and there is no identical source in the
target repository, Informatica will:
Replace the Source
Informatica will replace the source definition in the copied mapping with a new source definition that
matches the source name, but it will not be connected to the actual source.

Create a New Source

Informatica will create a new source definition in the target repository with the same name as the
original source, but it will not be connected to the actual source.

Mapping Validation Errors

When you validate the copied mapping, Informatica will report errors indicating that the source is not
found or is not valid.

Resolving the Issue

To resolve this issue, you need to:
1. Create a new source definition in the target repository that matches the original source.
2. Update the copied mapping to use the new source definition.
3. Re-validate the mapping to ensure that it is correct and complete.

Best Practices
To avoid this issue, it's recommended to:
1. Use a consistent naming convention for sources across repositories.
2. Create a new source definition in the target repository before copying the mapping.
3. Use the "Replace Source" option when copying the mapping to ensure that the new source definition
is used.

By following these best practices, you can avoid issues related to missing or mismatched sources when
copying mappings between repositories.

95.How can you limit number of running sessions in a workflow?

To limit the number of running sessions in a workflow, you can use the following methods:

Using a Semaphore
1. Create a semaphore variable in the workflow.
2. Set the semaphore value to the maximum number of sessions you want to run concurrently.
3. Use a decision task to check the semaphore value before starting a new session.
4. If the semaphore value is greater than 0, decrement the value and start the session.
5. If the semaphore value is 0, wait until one of the running sessions completes and then decrement the
value and start the new session.

Using a Counter
1. Create a counter variable in the workflow.
2. Initialize the counter value to 0.
3. Use a decision task to check the counter value before starting a new session.
4. If the counter value is less than the maximum number of sessions you want to run concurrently,
increment the counter value and start the session.
5. If the counter value is equal to the maximum number of sessions, wait until one of the running
sessions completes and then decrement the counter value and start the new session.

Using a Queue
1. Create a queue in the workflow.
2. Set the queue size to the maximum number of sessions you want to run concurrently.
3. Use a decision task to check the queue size before starting a new session.
4. If the queue size is less than the maximum number of sessions, add the new session to the queue and
start the session.
5. If the queue size is equal to the maximum number of sessions, wait until one of the running sessions
completes and then remove the completed session from the queue and add the new session to the
queue.

Using Informatica's Built-in Concurrency Control

1. Use Informatica's built-in concurrency control feature to limit the number of concurrent sessions.
2. Set the concurrency limit in the workflow or session properties.
3. Informatica will automatically manage the concurrency and prevent more than the specified number
of sessions from running concurrently.
These methods can be used individually or in combination to limit the number of running sessions
in a workflow.

96.An Aggregate transformation has 4 ports (l sum (col 1), group by col
2, col3), which port should be the output?
In an Aggregate transformation, the output port is typically the one that represents the aggregated
value.
In this case, since the transformation has 4 ports:
1. sum (col 1) - This is the aggregated value port.
2. group by col 2 - This is a group by port.
3. col3 - This is another group by port.

The output port should be the one that represents the aggregated value, which is:
- sum (col 1)
This port will contain the aggregated sum of column 1 for each group defined by columns 2 and 3.
By connecting this port to the next transformation or target, you'll be able to use the aggregated value in
your mapping.

97.What is a dynamic lookup and what is the significance of

NewLookupRow? How will use them for rejecting duplicate records?
Dynamic Lookup
A dynamic lookup is a type of lookup transformation in Informatica that allows you to dynamically
update the lookup cache while the mapping is running. This is useful when you need to perform lookups
on a large dataset and the lookup table is constantly changing.
NewLookupRow
NewLookupRow is a property in the dynamic lookup transformation that determines how Informatica
handles new rows in the lookup cache. When NewLookupRow is set to TRUE, Informatica will add new
rows to the lookup cache as it encounters them during the mapping run.

Rejecting Duplicate Records

To reject duplicate records using a dynamic lookup and NewLookupRow, you can follow these steps:
1. Create a dynamic lookup transformation with NewLookupRow set to TRUE.
2. Connect the input data to the lookup transformation.
3. Configure the lookup transformation to use a unique key (e.g., primary key) to identify duplicate
records.
4. Set up a filter transformation to reject duplicate records based on the lookup result.
5. Connect the output of the filter transformation to the target.

Here's how it works:

1. As the input data flows into the lookup transformation, Informatica checks if the record already exists
in the lookup cache.
2. If the record is new (i.e., not found in the cache), Informatica adds it to the cache and sets
NewLookupRow to TRUE.
3. If the record is a duplicate (i.e., already found in the cache), Informatica sets NewLookupRow to FALSE.
4. The filter transformation uses the NewLookupRow value to reject duplicate records (i.e., those with
NewLookupRow = FALSE).
By using a dynamic lookup with NewLookupRow, you can efficiently reject duplicate records in real-
time, even when dealing with large datasets and constantly changing lookup tables.

98.If you have more than one pipeline in your mapping how will change
the order of load?
If you have multiple pipelines in your mapping and you want to change the order of load, you can use
the following methods:

Method 1: Using the "Pipeline Order" Option

1. Open the mapping in the Mapping Designer.
2. Go to the "Mappings" menu and select "Pipeline Order".
3. In the "Pipeline Order" dialog box, select the pipeline you want to move up or down in the order.
4. Use the "Move Up" or "Move Down" buttons to change the order of the pipeline.

Method 2: Using the "Source Qualifier" Transformation

1. Open the mapping in the Mapping Designer.
2. Go to the "Source Qualifier" transformation for the pipeline you want to move up or down in the
order.
3. In the "Source Qualifier" properties, go to the "Properties" tab.
4. In the "Properties" tab, change the "Execution Order" value to a higher or lower number to change
the order of the pipeline.
Method 3: Using the "Sequence" Object
1. Open the mapping in the Mapping Designer.
2. Go to the "Sequence" object in the mapping.
3. In the "Sequence" properties, go to the "Properties" tab.
4. In the "Properties" tab, change the "Sequence Order" value to a higher or lower number to change
the order of the pipeline.
By using one of these methods, you can change the order of load for multiple pipelines in your
mapping.

99.When you export a workflow from Repository Manager, what does

this xml contain? Workflow only?
When you export a workflow from Repository Manager, the resulting XML file contains more than just
the workflow definition. It includes a comprehensive set of metadata and configuration information
related to the workflow.

Here are some of the key components that are typically included in the exported XML file:
1. Workflow definition: This includes the workflow's structure, tasks, and dependencies.
2. Task definitions: Detailed information about each task in the workflow, including task type, properties,
and settings.
3. Session properties: Configuration details for each session in the workflow, such as source and target
connections, mapping, and transformation settings.
4. Mapping and transformation metadata: Information about the mappings and transformations used in
the workflow, including source and target metadata.
5. Connection information: Details about the connections used in the workflow, including database
connections, file locations, and other relevant settings.
6. Workflow variables: Definitions of workflow variables, including their data types, default values, and
scope.
7. Security and access control: Information about the security settings and access controls applied to the
workflow, including user and group permissions.

So, while the exported XML file does contain the workflow definition, it also includes a wealth of
additional metadata and configuration information that provides context and supports the workflow's
execution.

100. Your session failed and when you try to open a log file, it complains
that the session details are not available. How would do trace the error?
What log file would you seek for?
When a session fails and you're unable to access the session details, tracing the error can be a challenge.
Here's a step-by-step approach to help you identify the issue:

Step 1: Check the Informatica Logs

Look for the Informatica server logs, which typically include:

- Informatica Server Log: This log provides information about the Informatica server, including startup
and shutdown events, errors, and other significant events.
- Integration Service Log: This log contains information about the Integration Service, including session
starts, stops, and errors.

Step 2: Analyze the Session Log

If you can't access the session details, try to find the session log file. The session log typically includes:

- Session Start and End Times: Verify that the session started and ended as expected.
- Error Messages: Look for error messages related to the session failure.
- Transformation and Mapping Errors: Check for errors related to specific transformations or mappings.

Step 3: Check the Workflow Log

If the session is part of a workflow, check the workflow log for:

- Workflow Start and End Times: Verify that the workflow started and ended as expected.
- Task Errors: Look for errors related to specific tasks within the workflow.

Step 4: Review the Informatica Configuration Files

Check the Informatica configuration files for:

- Incorrect Settings: Verify that the configuration settings are correct and consistent.
- Missing or Corrupted Files: Check for missing or corrupted configuration files.

Step 5: Consult Informatica Documentation and Support

If you're still unable to identify the issue, consult the Informatica documentation and support resources:

- Informatica Documentation: Review the Informatica documentation for troubleshooting guides and
error messages.
- Informatica Support: Reach out to Informatica support for further assistance.

By following these steps, you should be able to identify the cause of the session failure and troubleshoot
the issue effectively.

101.You want to attach a file as an email attachment from a particular

directory using ‘email task’ in Informatica, How will you do it?
To attach a file as an email attachment from a particular directory using the "Email Task" in Informatica,
follow these steps:

Step 1: Create an Email Task

Create an Email Task in your Informatica workflow.

Step 2: Configure Email Task Properties

Configure the Email Task properties, such as the email recipient, subject, and body.

Step 3: Specify Attachment File

In the Email Task properties, specify the attachment file by providing the full path to the file, including
the file name and extension.
Step 4: Use a Variable for Dynamic File Name
If the file name changes dynamically, use a variable to specify the file name. You can create a variable in
the workflow and assign it the file name.

Step 5: Use a Directory Path

Specify the directory path where the file is located. You can use a parameter or a variable to specify the
directory path.

Step 6: Test the Email Task

Test the Email Task to ensure that the file is attached correctly and the email is sent successfully.

Here's an example of how you can specify the attachment file in the Email Task properties:

- Attachment File: C:\Files\Report.txt

- or using a variable: $$FILE_DIR$$\Report.txt

By following these steps, you can attach a file as an email attachment from a particular directory using
the "Email Task" in Informatica.

102. You have a requirement to alert you of any long running sessions in
your workflow. How can you create a workflow that will send you email
for sessions running more than 30 minutes. You can use any method,
shell script, procedure or Informatica mapping or workflow control?
To create a workflow that sends an email alert for long-running sessions, you can use a combination of
Informatica workflow features and a shell script. Here's one approach:

Informatica Workflow
1. Create a new workflow in Informatica.
2. Add a Session Monitor task to the workflow.
3. Configure the Session Monitor task to monitor the sessions you're interested in.
4. Set the Monitoring Interval to a suitable value (e.g., 5 minutes).
5. Create a new Variable in the workflow to store the session duration.
6. Use a Decision task to check if the session duration exceeds 30 minutes.
7. If the session duration exceeds 30 minutes, use a Send Email task to send an alert email.

Shell Script (optional)

If you prefer to use a shell script, you can create a script that:
1. Queries the Informatica repository for sessions running longer than 30 minutes.
2. Sends an email alert using a mail client like sendmail or mailx.

Here's an example shell script:

bash
#!/bin/bash
# Set Informatica repository connection details
INFA_REPO_USER="your_username"
INFA_REPO_PASSWORD="your_password"
INFA_REPO_URL="http://your_infa_server:6001"

# Set email recipient and subject

EMAIL_RECIPIENT="[email protected]"
EMAIL_SUBJECT="Long Running Session Alert"

# Query Informatica repository for long running sessions

SESSIONS=$(curl -u ${INFA_REPO_USER}:${INFA_REPO_PASSWORD} \
"${INFA_REPO_URL}/api/v2/sessions?filter=duration>30m")

# Check if any long running sessions are found

if [ -n "${SESSIONS}" ]; then
# Send email alert
echo "Long running sessions detected:" | mailx -s "${EMAIL_SUBJECT}" ${EMAIL_RECIPIENT}
echo "${SESSIONS}" | mailx -s "${EMAIL_SUBJECT}" ${EMAIL_RECIPIENT}
fi

Schedule this script to run at regular intervals (e.g., every 5 minutes) using a scheduler like cron.

By using either the Informatica workflow approach or the shell script approach, you can create a system
that alerts you to long-running sessions in your workflow.