Search Results for: ibm

MANTA 3.26: IBM DataStage, erwin, and Detailed Lineage in EDC!

Leaves are gently falling to the ground in front of MANTA’s engineering office here in Prague as autumn arrives together with Software Release 3.26. What masterpiece have our developers put together this time? Read all about it in our release blog post.

Leaves are gently falling to the ground in front of MANTA’s engineering office here in Prague as autumn arrives together with Software Release 3.26. What masterpiece have our developers put together this time? Read all about it in our release blog post.

Not Just Any Ol’ Scanners

As always, we bring you the new and greatly improved as well as the old BUT tuned and tweaked. In this release, we have added two new scanners. The first one is an experimental version of the ETL tool from the IBM InfoSphere family, IBM InfoSphere DataStage. Experimental means that we are looking for pioneers for testing. But you had better be quick because the waiting list for this scanner was quite long, and so is the list of prospective testers!

MANTA analyzes DataStage parallel jobs provided by users, then creates a detailed visualization of the data lineage that can be pushed into any third-party metadata management solution or viewed in MANTA’s native visualization. This allows you to plug information such as data validation rules and other data from separate databases into DataStage, all visualized in the lineage showing the complete end-to-end journey of your data.

The second scanner we’ve added is erwin Data Modeler. MANTA can scan erwin and automatically pull physical and logical models that can then be added to your data lineage. This can come in extremely handy when it comes to your database architecture projects, as you can add complex data models from erwin to MANTA and use them to accurately project a situation—an enormously valuable asset for your database engineers.

Up a Notch

We have worked hard to perfect our Cognos scanner. MANTA’s scanner now processes Framework Manager report specifications retrieved from Cognos’ report storage (Content Store). Using the extracted information and other scanners, MANTA can create complete end-to-end data lineage (from database data sources through analytical models to reports in Cognos Analytics).

We are also happy to inform you that we have stepped our Informatica EDC integration up a notch. We have added more filtering options to detailed lineage in EDC, allowing you to see both the big picture as well as the finest details all the way down to the column level, and you can filter dataflows based on what information you want in your final lineage map. Now, MANTA helps you see not only complex SQL code in your EDC Catalog but also information from all the other scanners and integrations that MANTA supports—all ETL, analytics, and reporting tools. This causes user productivity and workflow efficiency to skyrocket!

Last but Not Least

Last but not least, we have made some improvements to the install and update process. Now, the magic happens automatically. When you download a new update packet and the installer notices that you need to update MANTA, it can automatically run your updater when needed, saving you a wrinkle or two in the process!

That’s all for MANTA 3.26. Any questions? Want to become a pioneer? Write to us at manta@getmanta.com.

MANTA 3.25: Microsoft Excel, IBM Cognos, SAP PowerDesigner, and more!

It has been a long time since we swore our 3-new-supported-technologies-every-release oath, and we have kept it every new software release since. And this version of MANTA is no different. In Release 3.25, we bring you support for Microsoft Excel (yes, Excel!), IBM Cognos, and SAP (Sybase) PowerDesigner. Read more in our regular blog post.

It has been a long time since we swore our 3-new-supported-technologies-every-release oath, and we have kept it every new software release since. And this version of MANTA is no different. In Release 3.25, we bring you support for Microsoft Excel (yes, Excel!), IBM Cognos, and SAP (Sybase) PowerDesigner. Read more in our regular blog post.

No time to read? Watch a video or dip into the details below:

Data Lineage for Excel? From Excel? With Excel? YES

No, this is not a drill. We have just released support for Microsoft Office’s Excel. The reason for this, which may seem like a weird flex to some, is that many of our customers still have disturbing amounts of data in Excel databases, which was more challenging for our customers to include in their data lineage.

MANTA now tracks data lineage in Excel, being able to read multiple sheets, pivot tables, slides, and graphs. We also have a detection algorithm with which MANTA can automatically reveal aggregated lists and tables that have formula relations among each other. MANTA is able to track data lineage from database tables and CSV files through tables and graphs among multiple Excel workbooks and push the whole picture into MANTA’s native visualization, as well as into third-party solutions.

Reporting Tools Are Our Friends…

The next connector that MANTA added to its technology portfolio is Cognos, a reporting tool from IBM. MANTA is able to create complete end-to-end data lineage from the database data sources, analytical models, and reports in Cognos Analytics by scanning:

• Reports (including queries)
• Interactive reports
• Framework Manager models
• Database connections

MANTA then pushes them into its own data visualization as well as into third-party solutions. (Visit our Tech Hub to learn more.)

Modeling Tools Too!

The third connector we have added is the modeling tool SAP (Sybase) PowerDesigner, our second after adding ER/Studio in Release 3.24. MANTA can scan PowerDesigner and automatically pull physical, logical, and conceptual models that can then be added to your data lineage to create end-to-end logical data lineage.

Behind the Scenes

Besides broadening MANTA’s Tech Hub, we have also made some improvements to existing supported technologies. The most work was probably done on SSAS, where we have added support to the newer version (level 1200) of the tabular models.

We also detect a connection between SSAS and SSRS from our Microsoft family, and these technologies are currently sharp crisp alfa versions. MANTA is also able to export more and more technologies into third-party solutions, including transformation logic.

And, as of MANTA 3.25, ETL Tools (SSIS, ODI, Talend) and reporting tools (SSAS, SSRS) from our tech hub are now exported into IBM IGC, Informatica EDC. and other third-party solutions.

Anything you want to ask us? Go ahead and write to us at manta@getmanta.com or chat with our friendly MANTA Bot. 

MANTA Introduces Connectors for IBM Netezza and DB2

June 27, 2017 by

MANTA is swimming deeper into the world of IBM. 

MANTA is swimming deeper into the world of IBM. 

We’ve already mentioned both IBM DB2 and IBM Netezza in our introductory article to the latest version, but maybe it’s time to explain how all it works. Take a look at the picture:

Manta is great at understanding logic hidden in programming code and it can parse:

  • NZPLSQL scripts, stored procedures, and more
  • DB2 scripts, stored procedures, and more
  • Other technologies you might have in your BI

After the initial parsing, Manta reconstructs the lineage and visualizes it (take a look on DB2 screenshot!) or pushes it into a 3rd party metadata solution – such as Informatica Metadata Manager (along with other technologies). “But I’ve purchased IBM IGC with my Netezza/DB2 databases!” Say no more, we’ve got you covered.

Get a Boost for Your Information Governance Catalog

Our goal was to create a seamless way to push complete lineage into IGC. Manta is now able to naturally connect to it and is simply present as a new metamodel (called, unsurprisingly, MantaModel). If some of your lineage is missing or hidden in Netezza or DB2 scripts and stored procedures, Manta is the ultimate solution for your problem.

Take a look at how smooth the integration is (Oracle is used in the video, but for DB2 and Netezza it works the same). We strongly recommend watching it full screen. 

Interested? Then you should know there’s a 30-day free trial and assisted pilot, if your organization requires one. Get in touch with us at manta@getmanta.com or use this form.

How Manta Flow Now Works with IBM Information Governance Catalog

November 22, 2016 by

We are expanding our support for 3rd party metadata managers – to help our customers get the most out of their existing data governance solutions.

We are expanding our support for 3rd party metadata managers – to help our customers get the most out of their existing data governance solutions.

Our key product, Manta Flow, already complements Informatica Metadata Manager very well. With the addition of IBM InfoSphere Information Governance Catalog, we are able to deliver the same level of highly specialized code crunching to folks who use IBM’s tools as well. And how does that work? Well, it’s simple:

1. Manta Flow crunches programming code based on our supported technologies (Teradata, Oracle, Microsoft SQL and others).

2. After connecting to IGC, Manta Flow will create a new metamodel and perfectly integrate with the existing structure within IGC.

3. The customer can browse IGC as he or she is used to – it’s just going to have way more accurate data lineage ready to use.

Seamless integration into IGC is the key to success. We’ve created a short video to explain a little bit more how Manta Flow is integrated into Information Governance Catalog. And what’s inside?

1. A Brief Explanation of a New Metamodel in IGC: 0:10
2. How It Works with Queries: 1:40
3. Integration of Data Lineage Visualization: 2:13

A frinedly suggestion: Run the video on fullscreen.

And if you are not ready for IGC, stay tuned, we will soon present you our newest video about our oldest love – IMM. In the meantime, read the introductory article right here.

Any thoughts? Comments? Or do you simply want to try it out for yourself? Just let us know at manta@mantatools.com or use the form on the right.

Licensing Policy

    November 15, 2019 by

    This licensing policy (“Policy”) defines specific licensing rules and conditions for MANTA Product. The use of the Product is subject to the Licensee’s compliance with the End User License Agreement (“EULA”) of which this Policy is a part.

    This licensing policy (“Policy”) defines specific licensing rules and conditions for MANTA Product. The use of the Product is subject to the Licensee’s compliance with the End User License Agreement (“EULA”) of which this Policy is a part.

    1. Definitions

    1.1. Script is a unique code element defined by the Product implementation, taking into account specifics of each particular technology.

    1.2. MANTA Instance is the Licensed Software deployed, within the limits granted to the Licensee, to a computing resource where it is managed and accessed as a single unit.

    1.3. Source Environment is a set of one or more systems, other than MANTA Instances, that contain Scripts to be processed by a MANTA Instance. One MANTA Instance can only be associated with one Source Environment.

    1.4. Source Environment Set is a set of one or more Source Environments where all the scripts stored or executed within any of the Source Environments are used exclusively for the development and QA associated with a single Source Environment designated as a Production Source Environment. Each Source Environment Set may only contain one Production Source Environment.

    1.5. MANTA Instance Set is one or more MANTA Instances where all the Scripts processed by any of the MANTA Instances are otherwise being stored or executed in Source Environments belonging to a single Source Environment Set.

    1.6. Unique is a property of a Script meaning that no other Script in the context of the particular MANTA Instance exhibits both the same binary content and the same associated data flow as analyzed by the respective MANTA Instance.

    1.7. User Controlled Metadata is the set of metadata stored by any MANTA Instance that is under the control of the Licensee to keep or remove.

    1.8. Instance Script Count is the amount calculated as the union of the amount of Unique Scripts for which User Controlled Metadata is stored in the repository of a MANTA Instance, and the amount of Unique Scripts processed by the MANTA Instance in the last 30 days.

    1.9. Instance Set Script Count is the largest Instance Script Count of any MANTA Instance out of a MANTA Instance Set.

    2. Basic information

    A Licensed Configuration specifies usage parameters for a single MANTA Instance Set. Specifically, any limit on the number of scripts applies to an Instance Set Script Count.
    The definitions below are intended for the purpose of estimating the number of Scripts in each particular technology. They do not replace or override the definition of Script as stated earlier in this Policy. MANTA made a substantial effort to make these definitions as accurate as possible, however it is not feasible to make them conform exactly to the Product implementation.

    For an updated Policy containing script definitions for newly introduced technologies and other updates, please contact your account executive or send an email to: legal@getmanta.com.

    3. Currently supported technologies

    Teradata – MANTA Flow supports data dictionaries, SQL, BTEQ, stored procedures, macros, TPT, and database query logs.

    Definition of Script
    These analyzed objects extracted from the database count as Scripts:
    • Views
    • Macros
    • Stored procedures (only SQL)
    Files that contain the following code provided to Manta Flow count as Scripts:
    • SQL code
    • BTEQ code
    • TPT code

    How to indicatively count the number of Scripts
    SQL, BTEQ and TPT scripts should be counted as the number of files with SQL, BTEQ and TPT code on the filesystem. Customer can use this command to count in-database objects:
    SELECT d.DatabaseName, t.TableKind, count(1)
    FROM dbc.TVM as t JOIN dbc.DBase as d on t.DatabaseId = d.DatabaseId
    WHERE t.TableKind in (‘V’,’M’,’P’)
    GROUP BY d.DatabaseName, t.TableKind
    ;

    Oracle – MANTA Flow supports data dictionaries, SQL, PL/SQL, stored procedures, packages, functions, and triggers.

    Definition of “Script”
    These analyzed objects extracted from the database count as Scripts:
    • Views and Materialized views
    • Procedures
    • Functions (user defined)
    • Triggers
    • PL/SQL packages (body)
    • PL/SQL types (body)
    Files that contain the following code provided to Manta Flow count as Scripts:
    • SQL code
    • PL/SQL code

    How to indicatively count the number of Scripts
    SQL and PL/SQL scripts should be counted as the number of files with SQL and PL/SQL code on the filesystem. Customer can use this command to count in-database objects:

    select owner, count(1)
    from dba_objects
    where object_name not like ‘SYS_PLSQL_%’
    and (
    (
    object_type in (‘PROCEDURE’,’PACKAGE BODY’,’TRIGGER’,’VIEW’,’FUNCTION’,’TYPE BODY’)
    and status = ‘VALID’
    ) or (
    object_type = ‘MATERIALIZED VIEW’
    )
    )
    group by owner;

    Microsoft SQL Server – MANTA Flow supports Microsoft PDW, Azure SQL Database, Azure SQL Data Warehouse. Among those, it supports data dictionaries, SQL, T-SQL, stored procedures, functions, and triggers.

    Definition of Script
    These analyzed objects extracted from the database count as Scripts:
    • Views
    • Procedures
    • Functions (user defined)
    • Triggers
    Files that contain the following code provided to Manta Flow count as Scripts:
    • SQL code
    • T-SQL code

    How to indicatively count the number of Scripts
    SQL and T-SQL scripts should be counted as the number of files with SQL and T-SQL code on the filesystem. Customer can use this command to count global objects (a need to run the query once for each SQL Server instance included):
    select count(1) from sys.server_triggers WHERE type = ‘TR’
    Customer can use this command to count database-bound objects (a need to run the query in every database included):
    select
    (select count(1) from INFORMATION_SCHEMA.ROUTINES where ROUTINE_TYPE in (‘PROCEDURE’, ‘FUNCTION’)) +
    (select count(1) from INFORMATION_SCHEMA.VIEWS) +
    (select count(1) from sys.triggers WHERE type = ‘TR’)

    SAP ASE (former Sybase ASE) – MANTA Flow supports data dictionaries, SQL, T-SQL, stored procedures, functions, and triggers. Please note that we do not support SAP IQ.

    Definition of Script
    These analyzed objects extracted from the database count as Scripts:
    • Views
    • Procedures
    • Functions (user defined)
    • Triggers
    Files that contain the following code provided to Manta Flow count as Scripts:
    • SQL code
    • T-SQL code

    How to indicatively count the number of Scripts
    SQL and T-SQL scripts should be counted as the number of files with SQL and T-SQL code on the filesystem. Customer can use this command to count database-bound objects (run the query in every database included):
    select count(1) from sysobjects WHERE type in (‘V’, ‘P’, ‘TR’)

    Hive – MANTA Flow supports data dictionaries and HiveQL.

    Definition of Script
    These analyzed objects extracted from the database count as Scripts:
    • Views
    Files that contain the following code provided to Manta Flow count as Scripts:
    • SQL code
    • Hive QL code

    How to indicatively count the number of Scripts
    SQL and Hive QL scripts should be counted as the number of files with SQL and Hive QL code on the filesystem.
    To list views in Hive (2.3.0+):

    SHOW VIEWS [in/from ]
    To count views directly in the underlying metastore database:
    select count(1) from tbls where tbl_type = ‘VIRTUAL_VIEW’

    IBM Netezza – MANTA Flow supports NZPLSQL scripts, stored procedures, and views from IBM Netezza.

    Definition of Script
    These analyzed objects extracted from the database count as Scripts:
    • Views
    • Procedures
    Files that contain the following code provided to Manta Flow count as Scripts:
    • SQL code
    • NZPLSQL code

    How to indicatively count the number of Scripts
    SQL and NZPLSQL scripts should be counted as the number of files with SQL and NZPLSQL code on the filesystem.
    This is the command customer may use to count in-database objects (a need to run the query in every database included):
    select (
    (select count(distinct procedure) from _v_procedure where UPPER(OBJTYPE) = ‘PROCEDURE’ and BUILTIN = false) +
    (select count(1) from _v_view where UPPER(OBJTYPE) in (‘VIEW’, ‘MATERIALIZED VIEW’))
    )

    IBM DB2 – MANTA Flow supports data dictionaries, scripts, stored procedures, SQL, modules, functions, triggers, and Oracle compatibility mode.

    Definition of Script
    These analyzed objects extracted from the database count as Scripts:
    • Views
    • Procedures
    • Functions (stand-alone as well as module-and type-bound methods)
    • Triggers
    • Packages (body)
    Files that contain the following code provided to Manta Flow count as Scripts:
    • SQL code
    • PL/SQL code

    How to indicatively count the number of Scripts
    SQL and PL/SQL scripts should be counted as the number of files with SQL and PL/SQL code on the filesystem.
    This is the command customer may use to count in-database objects:
    values (
    (select count(1) from SYSCAT.ROUTINES where ORIGIN <> ‘S’ and OWNERTYPE <> ‘S’) +
    (select count(1) from SYSCAT.TRIGGERS where OWNERTYPE <> ‘S’) +
    (select count(1) from SYSCAT.TABLES where TYPE IN (‘V’, ‘W’) AND OWNERTYPE <> ‘S’) +
    (select count(1) from SYSCAT.MODULES where OWNERTYPE <> ‘S’ and MODULETYPE = ‘P’)
    )

    PostgreSQL, Greenplum and Amazon Redshift – MANTA Flow supports data dictionaries, PLpgSQL scripts, views, triggers, functions, and stored procedures.

    Definition of Script
    These analyzed objects extracted from the database count as Scripts:
    • Views
    • Procedures
    • Functions (user defined)
    • Triggers
    Files that contain the following code provided to Manta Flow count as Scripts:
    • SQL code
    • PLpgSQL code

    How to indicatively count the number of Scripts
    SQL and PLpgSQL scripts should be counted as the number of files with SQL and PLpgSQL code on the filesystem.
    This command should be used in each database extracted to get the number of scripts:
    SELECT schema_name, count(1) as count FROM (
    SELECT n.nspname AS schema_name
    FROM pg_namespace n
    INNER JOIN pg_class c ON n.oid = c.relnamespace
    WHERE c.relkind = ‘v’
    UNION ALL
    SELECT pn.nspname as schema_name
    FROM pg_proc pp
    LEFT JOIN pg_namespace pn on pn.oid = pp.pronamespace
    INNER JOIN pg_language pl ON pp.prolang = pl.oid
    WHERE lower(pl.lanname) in (‘sql’, ‘plpgsql’)
    ) dt
    GROUP BY schema_name;

    Informatica PowerCenter – MANTA Flow supports workflows, mappings, sessions, SQL overrides, repositories, and parameter files.

    Definition of Script
    Informatica PowerCenter Session Instance is a particular instance of a Session Definition used in a particular Workflow or Worklet definition. It is uniquely identified by its path: ///…/.
    Informatica PowerCenter Session Instance hash is computed as a result of a function which has a dataflow graph generated by Manta Flow dataflow analysis for the Informatica PowerCenter Session Instance as an input. This function returns the same outputs for the same inputs, but it can return different outputs for different inputs.
    Manta Flow counts each unique “Informatica PowerCenter Session Instance hash” in the whole environment as a Script.

    How to indicatively count the number of Scripts
    Indicative Session Instance count can be obtained from Informatica PowerCenter repository:
    SELECT SUBJECT_AREA, COUNT(1) FROM INFA.REP_SESSION_INSTANCES GROUP BY SUBJECT_AREA;

    Pig Latin – MANTA supports Pig Latin statements, relations, bags, tuples, and fields.

    Definition of Script
    These files provided to Manta Flow count as Scripts:
    • Pig Latin script
    • Pig Latin macro

    How to indicatively count the number of Scripts
    Customer can count number of files containing Pig Latin scripts and macros that should be analyzed by Manta.

    Talend – MANTA Flow supports projects, jobs and subjobs, connectors, components, expressions, and SQL overrides.

    Definition of Script
    Talend Job hash is computed as a result of a function which has a dataflow graph generated by Manta Flow dataflow analysis for the Talend Job as an input. This function returns the same outputs for the same inputs, but it can return different outputs for different inputs.
    Manta Flow counts each unique “Talend Job hash” in the whole environment as a Script.

    How to indicatively count the number of Scripts
    Customer can count Talend jobs in the repository via Talend Studio for Data Integration or by navigating to the repository root folder via file explorer and counting the number of files with .item extensions located in the process folder and its subfolders.
    For example, using Windows Command Line customer can count the number of scripts by executing:
    cd
    dir /S /B process\*.item | find /C /V “”

    Sqoop – MANTA Flow supports Sqoop import, export, and eval jobs.

    Definition of Script
    These Sqoop jobs (both extracted from a database and manually provided in form of files) count as Scripts:
    • Import job
    • Export job
    • Eval job

    How to indicatively count the number of Scripts
    If customer manually provides files with Sqoop jobs, it is possible to count all the calls for these jobs inside those files. (This can easily be done by counting all the non-empty lines.) If customer provides a connection to a relational database where Sqoop jobs are stored, customer can use this statement to count them:
    SELECT COUNT(DISTINCT job_name) FROM SQOOP_SESSIONS;

    Oracle Data Integrator – MANTA Flow support scenarios, projects, packages, and mappings.

    Definition of Script
    ODI Mapping hash is computed as a result of a function which has a dataflow graph generated by Manta Flow dataflow analysis for the ODI Mapping as an input. This function returns the same outputs for the same inputs, but it can return different outputs for different inputs.
    Manta Flow counts each unique “ODI Mapping hash” in the whole environment as a Script.

    How to indicatively count the number of Scripts
    This query can be used to indicatively count number of ODI Mappings in the ODI Repository:
    SELECT COUNT(*) from SNP_MAPPING where is_reusable = ‘N’;

    Microsoft SQL Server Integration Services – MANTA Flow supports SSIS project and packages.

    Definition of Script
    SSIS Task is a task contained in an SSIS Package. Manta Flow recognize these types of SSIS Tasks:
    • SQL Task
    • Bulk Insert Task
    • File System Task
    • Dataflow Task

    Microsoft SSIS Task hash is computed as a result of a function which has a dataflow graph generated by Manta Flow dataflow analysis for the SSIS Task as an input. This function returns the same outputs for the same inputs, but it can return different outputs for different inputs.
    Manta Flow counts each unique “Microsoft SSIS Task hash” in the whole environment as a Script.

    How to indicatively count the number of Scripts
    To count the number of tasks the steps are: unzip all the project files (if using project deployment), find all the package (*.dtsx) files and count the number of occurrences of “” inside those files, minus one for each package file.

    Microsoft SQL Server Analysis Services – MANTA Flow supports tabular models, and multidimensional models.

    Definition of Script
    Manta Flow recognizes these objects:
    • Dimension in a cube
    • Table in a tabular model

    Microsoft SSAS object hash is computed as a result of a function which has a dataflow graph generated by Manta Flow dataflow analysis for the dimension in a cube or the table in a tabular model as an input. This function returns the same outputs for the same inputs, but it can return different outputs for different inputs.
    Manta Flow counts each unique “Microsoft SSAS object hash” in the whole environment as a Script.

    How to indicatively count the number of Scripts
    To count the number of dimensions in all cubes, it is necessary to count the number of occurrences of “Dimension” tag under the “Cube” tag inside *.xmla or *.bim files for SSAS multidimensional model:
    xmllint –xpath “count(//*[local-name()=’Cube’]/*[local-name()=’Dimensions’]/*[local-name()=’Dimension’])” outputxml.xmla

    To count the number of tables in all tabular models inside *.xmla or *.bim files for SSAS tabular model, customer can use this command:
    cat outputjson.xmla | jq “first(..|select(.model?)).model.tables | length”
    type outputjson.xmla | jq “first(..|select(.model?)).model.tables | length”

    Microsoft SQL Server Reporting Services – MANTA Flow supports paginated reports.

    Definition of Script
    Microsoft SSRS Report hash is computed as a result of a function which has a dataflow graph generated by Manta Flow dataflow analysis for the SSRS report that is not a part of another SSRS report as an input. This function returns the same outputs for the same inputs, but it can return different outputs for different inputs.
    Manta Flow counts each unique “Microsoft SSRS Report hash” in the whole environment as a Script.

    How to indicatively count the number of Scripts
    To count the number of reports, customer can run this query in customer´s SQL Server database where the SSRS catalog is stored:
    SELECT count(*)
    FROM dbo.Catalog catalog
    WHERE type = 2;

    Microsoft Excel – MANTA Flow supports XLSX and XLSM workbooks, sheets, defined names, charts, tables, pivot tables, database connections, and queries.

    Definition of Script
    These files provided to Manta Flow count as Scripts:
    • XLSX workbook
    • XLSM workbook

    How to indicatively count the number of Scripts
    Customer can count all XLSX and XLSM files in the repository root folder.

    IBM Cognos – MANTA Flow supports reports and interactive reports (including queries with SQL), framework manager models, data modules, data sets, uploaded files and database connections.

    Definition of Script
    IBM Cognos Report hash is computed as a result of a function which has a dataflow graph generated by Manta Flow dataflow analysis for the IBM Cognos report. This function returns the same outputs for the same inputs, but it can return different outputs for different inputs.
    Manta Flow counts each unique “IBM Cognos Report hash” in the whole environment as a Script.

    How to indicatively count the number of Scripts
    Customer can run the following script against the Content Store database to get an approximate number of scripts:
    select count from .cmobjects where classid in (10,234)

    ER/Studio – MANTA Flow supports physical models, logical models, and conceptual models.

    Definition of Script
    Manta Flow recognizes these ER/Studio models:
    • Physical model
    • Logical model

    ER/Studio model hash is computed as a result of a function which has a dataflow graph generated by Manta Flow dataflow analysis for the ER/Studio model. This function returns the same outputs for the same inputs, but it can return different outputs for different inputs.
    Manta Flow counts each unique “ER/Studio logical or physical model hash” in the whole environment as a Script.

    How to indicatively count the number of Scripts
    To count the number of logical and physical models in an ER/Studio file, customer can use this shell script:
    #!/bin/bash
    for i in “$@”
    do
    cat “$i” | tr -d ‘\015’ | # Convert CRLF Windows endings to the Unix ones
    sed -ne ‘/^Model$/,/^$/p’ | # Get the CSV tables with models
    sed -ne ‘/^[0-9]/p’ | # Get rid of headers, process entries. ModelType is at fourth position in the CSV, count only those models that we process (types 1,2 and 5)
    awk -F’,’ ‘ BEGIN { count = 0; } { if ($4 == 1 || $4 == 2 || $4 == 5) count++ } END { print “Number of Data Models in file \”‘”$i”‘\” is ” count }’
    done

    SAP PowerDesigner – MANTA Flow supports physical, logical and conceptual models.

    Definition of Script
    Manta Flow recognizes these SAP PowerDesigner models:
    • Physical model
    • Logical model
    • Conceptual model
    SAP PowerDesigner model hash is computed as a result of a function which has a dataflow graph generated by Manta Flow dataflow analysis for the SAP PowerDesigner model. This function returns the same outputs for the same inputs, but it can return different outputs for different inputs.
    Manta Flow counts each unique “SAP PowerDesigner model hash” in the whole environment as a Script.

    How to indicatively count the number of Scripts
    Customer can count number of .cdm, .pdm and .ldm files that should be analyzed by Manta.

    Erwin – MANTA Flow supports physical, physical/logical and logical models.

    Definition of Script
    Manta Flow recognizes these Erwin models:
    • Physical model
    • Logical model
    • Conceptual model
    Erwin model hash is computed as a result of a function which has a dataflow graph generated by Manta Flow dataflow analysis for the Erwin model. This function returns the same outputs for the same inputs, but it can return different outputs for different inputs.
    Manta Flow counts each unique “Erwin model hash” in the whole environment as a Script.

    How to indicatively count the number of Scripts
    To count total number of scripts used by Erwin look through all used model files (.xml) and find tag under under under (XML root) which specifies type of the model.
    Type values:
    1 = Logical model, counts as 1 script.
    2 = Physical model, counts as 1 script.
    3 = Logical/Physical model, counts as 2 scripts.

    IBM InfoSphere DataStage – MANTA Flow supports parallel jobs.

    Definition of Script
    IBM InfoSphere DataStage Job hash is computed as a result of a function which has a dataflow graph generated by Manta Flow dataflow analysis for the IBM InfoSphere DataStage Job as an input. This function returns the same outputs for the same inputs, but it can return different outputs for different inputs.
    Manta Flow counts each unique “IBM InfoSphere DataStage Job hash” in the whole environment as a Script.

    How to indicatively count the number of Scripts
    To count the number of jobs the steps are: find all the DataStage (*.xml) files and count the number of occurrences of “” inside those files.

    Last update 2019-11-04

    We cherish your privacy.

    And we need to tell you that this site uses cookies. Learn more in our Privacy Policy.