|  | BEA eLink Data Integration Option 1.2 Information Center
HOME | SEARCH | CONTACT | PDF FILES | WHAT'S NEW
| TABLE OF CONTENTS | PREVIOUS TOPIC | NEXT TOPIC

Understanding the Data Integration Option

# Understanding the Data Integration Option

The BEA eLink Data Integration Option uses the eLink Integrator component with BEA TUXEDO for processing service requests for data mapping and data conversion.

This TUXEDO translation service takes an input buffer, performs a data translation on the buffer, and returns the translated data in an output buffer, exposing the Mercator wrapper for TUXEDO as a service. The data translations that can be performed corresponds to sets of Mercator maps. The service will advertise these as a set of service names that correspond to the map names. To perform a particular data translation, the service will be invoked with the appropriate service name - the service will invoke Mercator using the correspondingly named map.

For example, to call a map called TOEDI.MMC that produces EDI data in an FML format, the service name would be TOEDI.

Each map has at least one input card and one output card. The service passes the input data to input card 1 and returns data back to the service-requester via output card 1. There may be any number of additional input or output cards (to read from a file or create a file, for example). Output card 1 has a "header" with control information set in the map. This card determines the destination and format of the output buffer. This header is required. See the section entitled "Control Information for TUXEDO /Q" in this document for more details.

This document will describe the following topics:

- Using the BEA Solution for Data Mapping

- Using Data Mapping with a Mainframe Environment

- Using Data Mapping with SAP R/3 IDOCs

- Using Data Mapping with Other eLink Integrators

- Requirements for Data Mapping

- Overview of the eLink Integrator Data Mapping Process

  - Development Phase

  - Execution Phase

## Using the BEA Solution for Data Mapping

The BEA eLink Data Integration Option uses a TUXEDO environment that includes the BEA TUXEDO product as well as the eLink Mercator Integrator for DIO component for data mapping and conversion. Other products, such as the BEA eLink for Mainframe product and eLink Integrators can be integrated into your TUXEDO environment and assist in your Enterprise Application Integration (EAI) solution.

### Using Data Mapping with a Mainframe Environment

Figure 1-1 shows how the products and components work together to convert buffers between an FML and COBOL copybook format and transfer the buffers between a UNIX or Windows NT environment and a mainframe environment.

The BEA eLink for Mainframe gateway asynchronously calls external TUXEDO services, a feature which will be used to call the elinkmerc server. The elinkmerc server is a standard TUXEDO MSSQ server that receives a TUXEDO buffer as input, invokes the Mercator data mapping engine, and returns a TUXEDO buffer as output.

> Figure 1-1 Data Mapping Scenario of FML to COBOL Copybook to FML

The following description explains the process flow in Figure 1-1 of a TUXEDO client making a request to send an FML buffer from a UNIX environment to a CICS region on a mainframe and return an FML buffer to the TUXEDO client.

1. A TUXEDO client issues a request to send an FML buffer to the mainframe.

2. The request passes the FML buffer to the BEA eLink for Mainframe gateway. The service name in the request causes the gateway to pass the FML buffer to the eLink Mercator Integrator for DIO component to convert the FML buffer to a COBOL copybook format.

3. The eLink Mercator Integrator for DIO component converts the FML buffer to a COBOL copybook and passes it back to the BEA eLink for Mainframe gateway.

4. The BEA eLink for Mainframe gateway passes the converted COBOL copybook to the CICS or IMS region on the mainframe.

5. After the requested transaction is complete, the mainframe returns a response by sending the COBOL copybook back to the BEA eLink for Mainframe gateway.

6. The BEA eLink for Mainframe gateway passes the copybook to the eLink Integrator for conversion back to an FML buffer.

7. After the copybook is converted to an FML buffer, it is passed back to the BEA eLink for Mainframe gateway.

8. The BEA eLink for Mainframe gateway then passes the FML buffer response to the TUXEDO client.

### Using Data Mapping with SAP R/3 IDOCs

The data mapping process uses a TUXEDO environment that includes the BEA TUXEDO and the BEA eLink Mercator Integrator for DIO component. Figure 1-2 shows how the products and components work together to convert buffers between an FML and SAP Intermediate Documents (IDOCs) format.

The elinkmerc server is a standard TUXEDO MSSQ server that receives a TUXEDO buffer as input, invokes the Mercator data mapping engine, converts the buffer to another format and then passes it to multiple destinations.

> Figure 1-2 Converting FML to New Format and Passing to Multiple Destinations

The following description explains the process flow in Figure 1-2 of a TUXEDO client making a request to send an FML buffer to multiple applications.

1. A TUXEDO client issues a request to send an FML buffer to multiple applications.

2. The request passes the FML buffer to the eLink Data Integration Option to convert the FML buffer to another buffer format, such as SAP R/3 IDOCs.

3. The eLink Data Integration Option converts the FML buffer to the new format and passes it to the appropriate applications.

   Note: The mapping to multiple destinations is done through Mercator input and output cards. For information on defining input and output cards, refer to the Mercator documentation.

#### FML32 Value Buffers with SAP R/3

A particular use of the BEA eLink Mercator Integrator for DIO component with SAP R/3 is with the conversion and processing of FML32 Value buffers. Figure 1-3 shows how to map a Mercator tag to an FML32 field that then points to the actual data buffer. Once the actual data buffer is located, only it is passed to the BEA eLink Mercator Integrator for DIO application for conversion.

> Figure 1-3 Passing an FML32 Value Buffer from SAP R/3 Outbound

1. The MERCATOR_FV_IN field identifies the name of the FML32 field.

2. The FML32 name contains the actual data buffer to be passed to the eLink Integrator component.

3. The data is extracted from the FML32 field and sent directly to Mercator for mapping.

### Using Data Mapping with Other eLink Integrators

The data mapping process uses a TUXEDO environment that includes the BEA TUXEDO and the BEA eLink Integrator component as well as other eLink Adapters. For example, Figure 1-4 shows how the products and components work together to convert buffers between an FML and a non-FML format and then pass a request to an eLink Adapter.

> Figure 1-4 Data Mapping Scenario of FML with eLink Integrators

The following description explains the process flow for invoking eLink DIO directly from the client to transform data prior to sending it to an eLink Adapter. The same process could be used after receiving data from an eLink Adapter to transform it back to a TUXEDO format.

1. A TUXEDO client calls eLink DIO to transform data to a format usable by an eLink Adapter.

2. The eLink DIO software sends the transformed data back to TUXEDO.

3. TUXEDO calls the eLink Adapter to process the data.

4. After the eLink Adapter processes the data, it passes the response back to TUXEDO.

5. The resulting data from the eLink Adapter is passed to the eLink DIO to be transformed into a TUXEDO-compatible format, such as FML.

6. The eLink DIO transforms the data to a TUXEDO-compatible format, such as FML, and passes it back to TUXEDO.

## Requirements for Data Mapping

The following software, components, and files must be used to issue a TUXEDO service request that maps data between an FML buffer and a non-TUXEDO data format, such as COBOL copybook or SAP R/3 IDOCs.

- BEA eLink Integrator Components

- Mercator Components

### BEA eLink Integrator Components

The following sections describe the different eLink Integrator components necessary for defining the data mapping rules in the development environment and execution of the mapping operation.

#### TUXEDO elinkmerc Server

The elinkmerc server is an executable program that runs on HP-UX, SUN Solaris, AIX or Windows NT. It runs in a TUXEDO environment performing the following functions:

- Advertises the maps specified by the -s option of the CLOPT parameter in the SERVERS section of the UBBCONFIG file. In other words, the Mercator maps are advertised as TUXEDO services.

- Maintains other command line information for execution of the Mercator Mapping Library.

- Executes TuxRunMap library which calls the Mercator Mapping Library to perform data mapping.

- Receives the FML buffer and converts it into an internal format for use by Mercator.

#### FML and VIEW Importer

The eLink Integrator FML and VIEW Importer reads the FML Field Definition file and an FML Group Format file to create a type tree file. This component reads the FML Field Definition file and creates a Type Tree Maker Command file (`.mts`) which is then run through the type tree maker.

### Mercator Components

The following sections describe the different Mercator components necessary for defining the data mapping rules in the development environment.

#### Importers

Use the Mercator Importers to create type tree files. For example, to convert an FML buffer to a COBOL Copybook, use the COBOL Copybook Importer to create a COBOL type tree. For information about using Importers, refer to the Mercator documentation.

#### Type Editor

Use the Mercator Type Editor to make any modifications to the type tree files, such as adding the Control information to the header. The Type Editor also provides an Export feature that will produce a type tree file in a suitable format for different platforms. For information about using the Type Editor, refer to the Mercator Type Editor Reference Guide.

#### Map Editor

The data translations are sets of Mercator maps. The TUXEDO service will advertise these as a set of service names that correspond to the map names. To perform a particular data translation, the service will be invoked with the appropriate service name - the service will invoke Mercator using the correspondingly named map.

Each map has at least one input card and one output card. The service passes the input data to input card 1 and returns data back to the service-requester via output card 1. There may be any number of additional input or output cards (for example, to read from a file or create a file). Output card 1 has a header with control information set in the map. This card determines the destination and format of the output buffer.

Note: The header information is required in the output card. For information about defining Control information with /Q, refer to the "Control Information for TUXEDO /Q."

Use the Mercator Map Editor to define the mapping rules and compile a map file. For information about creating a Mercator map file, refer to the Mercator Map Editor Reference Guide.

## Overview of the eLink Integrator Data Mapping Process

The data mapping process includes two phases: the development phase and the execution phase. The development phase sets up the environment and mapping rules for data conversion. For example, this phase includes the process of taking a file type, such as a COBOL copybook, and creating a type tree file (such as `cob.mtt`) using the appropriate Mercator Importer. This phase also includes taking an FML Field Definition file and an FML Group Format file and creating an associated FML type tree file (`fml.mtt`) using the eLink Integrator FML and View Importer. The FML and View Importer in the eLink Integrator component also creates a Meta-Type Information (`.mti`) file which the TUXEDO `elinkmerc` server uses during execution. After both the COBOL and the FML type trees are created for both the copybook and the FML files, a Mercator map file (`.mmc`) is created and compiled using the type tree files. The execution phase issues the TUXEDO service request for data mapping. It is during execution that the actual mapping occurs.

Figure 1-5 describes the data mapping development process flow. Simply put, the process flow begins with an input file, such as a COBOL copybook or an FML Field Definition File and an FML Group Format file (`.fgf`) and creates a compiled Mercator map file (`.mmc`).

> Figure 1-5 Data Map Development

### Development Phase

The development phase is separated into two parts, the creation of Mercator type tree files and the creation of the Mercator map file. You must have a source type tree, such as a COBOL type tree, and a destination type tree, such as an FML type tree. Use the Mercator and eLink Data Integration Option tools to create the type tree files. Before creating the type tree files, you must describe your input data as well as the format of your output data.

Note: The development phase is only supported on Windows NT.

#### Using Importers to Create Mercator Type Tree Files

Use a Mercator Importer to input a type of file and create a type tree file as output. For more information on how to use the Mercator Importers, refer to the Mercator documentation. Use the eLink Integrator FML and View Importer to create an FML type tree.

Note: For conversions to COBOL copybook, the COBOL type tree does not contain the eLink Integrator header, so you must edit the type tree using the Type Editor. You must add the eLink Integrator control header from the FML type tree to output COBOL copybooks.

You can input into the eLink Integrator FML and View Importer an FML Field Definition file and an FML Group Format (`.fgf`) file. To define these groups, refer to "Data Mapping Conversion." After defining these groups in the FML Group Format file, you will use the eLink Integrator FML and View Importer to create a Meta-Type Information file (`.mti`) and create an output FML type tree file (`.mtt`).

The eLink Integrator reads the FML data to convert it to the proprietary format. The Meta-Type Information (`.mti`) file determines which FML fields will be retrieved and in what order.

#### Compiling Type Tree Files into Mercator Map Files

Mercator map files define adapters, source and destination type trees, and transformation rules. One map must be created for each message that is to be mapped. One map is needed to convert the FML buffer to another buffer type such as COBOL for a mainframe request, and another map is needed for the conversion from the buffer type (COBOL) back to FML for the mainframe response.

### Execution Phase

Prior to a TUXEDO service request executing a Mercator map file, be sure that you have specified the mapping operation in the UBBCONFIG file and the DMCONFIG file. To request a mapping operation, the gateway will use the service name as the data mapping operation specified in the INBUFTYPE parameter of the DM_GATEWAY_SERVICE section of the DMCONFIG file. For more information about the UBBCONFIG and DMCONFIG file entries for running the eLink Integrator, refer to "Configuring the Environment for eLink Integrator." The `elinkmerc` server will then use that service name as the base name for the map definition that Mercator is to use.

The execution phase requires that certain files exist in the execution environment. After moving the files to this environment, `elinkmerc` server can process a service request for data mapping.

#### Setting Up the Execution Environment

Certain files must be transferred from the development environment on Windows NT to the execution environment, which is also where APPDIR is pointing. If your execution environment is HP-UX, SUN Solaris, or AIX, use the Mercator Map>Port functionality to convert the Mercator map files (`*.mmc`) to a format that is suitable for these UNIX platforms.

Note: If your execution environment is Windows NT, you do not need to perform the Map>Port step.

After performing the Port process for the Mercator map files, transfer the required files to the execution environment. When transferring these files from the development environment on Windows NT to the execution environment, such as HP-UX, AIX, or SUN Solaris, specify the appropriate mode (ASCII or binary) to use during the transfer.

- `fml2cob``.mti` (ASCII file)

Note: This file is a copy of the `sample``.mti` renamed to match the name of the `fml2cob``.mmc` map file.

- `cob2fml``.mti` (ASCII file)

  Note: This file is a copy of the `sample``.mti` renamed to match the name of the `cob2fml``.mmc` map file.

- `sample``.fml` (ASCII file)

- `fml2cob``.mmc` (binary file)

- `cob2fml``.mmc` (binary file)

#### Initiating a Service Request for Data Mapping

After the execution environment is set up, you can issue a TUXEDO service request that will implement the data mapping rules defined in the map files. Before issuing the TUXEDO service request, be sure the following tasks are complete.

1. Edit the TUXEDO UBBCONFIG file to define the elinkmerc server and the conversion service names.

2. Edit the INBUFTYPE and OUTBUFTYPE parameters in the DM_GATEWAY_SERVICE section in the DMCONFIG file to specify the correct map name.

3. Transfer the required files to the execution environment.

4. Add `sample.fml` to FIELDTBLS and FIELDTBL32. Also add the path for `sample.fml` to FLDTBLDIR and FLDTBLDIR32.

5. Ensure that TUXDIR and APPDIR are appropriately set.

6. Initiate the BEA TUXEDO and BEA eLink for Mainframe software.

7. Issue the TUXEDO service request.

   Note: For information on the BEA TUXEDO software, refer to the BEA TUXEDO documentation. For information on the BEA eLink for Mainframe software, refer to the BEA eLink for Mainframe online documentation.

TABLE OF CONTENTS | PREVIOUS TOPIC | NEXT TOPIC