SQLWays 免费快版

Ispirer复制器

演示视频文本：

           Hello! In this presentation you will see the replication between MICROSOFT SQL SERVER and ORACLE with the help of the ISPIRER SQLWAYS REPLICATOR.
For the purposes of this demonstration, we have prepared 4 tables:

Table called tab_pk_mult_cols with a primary key with several columns;
Table called tab_pk_single_col with a primary key with one column;
Table called tab_ui_mult_cols with a unique index with several columns;
Table called tab_uk_single_col with a unique index with one column.
For this demo we have migrated and uploaded these tables in Oracle. Let’s check the data in the tables. As you can see, the tables are empty both in SQL Server and Oracle. 
Currently the SQLWays Replicator utility supports trigger-based replication, that is, the replication is performed with the help of the additionally created triggers in the source database.

We will create additional triggers in the source database with the help of the Ispirer SQLWays Wizard. Here you can see the SQLWays Wizard Welcome page. 
 We just click next.

Here we need to specify a user or system DSN name for the ODBC connection for SQL Server. 
We also specify the user name and the password and go next.
On a «Choose a target database» page we need to choose the target database SQL Server from the list, in order to generate scripts with triggers that we need for replication. 

Than we specify -  the Server, - the Database, the user name and the password.

And one more thing here: 
We identify the path to the BIN directory in SQL Server that contains the program called sqlcmd.exe. It will be used for the uploading the generated scripts in SQL Server.

And we move on, on this page we have to choose all the tables from the source database. They will be checked for Primary keys or Unique indexes.

On a «Specify DDL and data options» page for the option “Omit schema names in SQL scripts” we choose “Yes in order to remove all schema names of the source objects while script generation. 
Than, it is required to enable the “Generate replication script” option. For these ends, we just need to select Tables from the drop-down list. 
On the right you will see additional options for tables. 

On DDL tab we choose “Generation Options” from the drop-down list.
Here we need to enable the Generate replication script option, 
required for the generation of additional triggers and the objects used by the SQLWays Replicator.

On a “Specify Export File Options” page we identify the «Export directory» which will serve as an intermediate repository for all the files that which will be generated.

All the other pages can be left as is. 

On “Migration Status” page we press the button “Start Export” and launch the export. And we can see the script generation process.

In order to review the results we press the button “View Export”.

Here we can see the files that were generated: 

swt_replication.sql file:
Contains DDL for the SWT_Replication table, which is the main replication control table that contains the name of the tables being replicated and the current and previous replication counters for each table being replicated.
Also it contains the INSERT statements that populate the SWT_Replication table with the table names being replicated and the RC and CRC initial values.

swr_tables.sql file:
Contains DDL statements for SWR_* tables, which are the replication tables created for each table in the replication process. These tables are updated by the replication triggers and contain information about the current iteration number, Primary Key or unique values for the data INSERTED, DELETED or UPDATED and the trigger action for the data.

SWR_Triggers.sql file:
Contains DDL for Replication triggers that are created on base tables and collect the actions and Primary key or /Unique key.

DropTriggersSts.sql file:
Supporting script that contains DROP TRIGGER statements for all the Replication triggers.

DeleteSts.sql file:
Supports the script that contains DELETE statement for each SWR_* replication table where SWC_RC is less or equal to the CRC value from SWT_Replication table.

TruncateSts.sql file:
Supports script that contains TRUNCATE statements for each SWR_* replication table.

TableList.sql file:
Contains the list of tables together with their Primary Key or Unique key columns. The table name and the list of corresponding columns follow each other one-by-one.

Now let’s import the generated scripts in SQL Server.
As the import is completed, let’s review the uploaded objects in the source base  called demorepl.

As we can see, additional triggers were created for the tables. 

Moreover, the generated tables were created in the SWD_RepDb base. These tables are needed for the replication process. 

And now let’s check the content of the tables in SQL Server and in Oracle.  They both are empty.

Let’s review the replication process. 

For these ends, we put test data in the tables of the source database. Let’s make sure that the data was successfully loaded in the tables. 
Also, we can see that the information about the executed INSERT Statements in the replicable tables was added into the SWR_* tables. 
We check the tables in Oracle once again – and reassure that they are still empty.

Now let’s launch  the Ispirer SQLWays Replicator, which is on the screen. 

On a “Source database settings” page we need to identify a user or system DSN name for the ODBC connection for SQL Server. We also specify the user name and the password and go next.
On a “Target settings” page we identify a user or system DSN name for the ODBC connection for Oracle, and again the appropriate user name and the password, and click next. 

On a “Replication options” page we need to enter the name of the base, in which the tables containing the information about replication were created. 
In our case it is the SWD_RepDb base in SQL Server.

Then it is required to specify the number of cycles. For example, we state 2. 
Also we need to indicate after how many seconds the new replication will be launched. 

An the last thing to do here, 

we need to specify the directory, where the file called TableList.sql is stored. This file was generated by the Ispirer SQLWays Wizard and it contains the list of tables with their Primary key and Unique key columns.

The option Trace level can be left with default value. This option expands the data output during replication process in log file.

To launch the replication, press “Next”.

And we can see the replication process on the screen. 
As soon as it is completed – we can review the output data of the replication process.

Now let’s output data from Oracle tables. 
As we can see, the replicable data was loaded in Oracle. 

Next let’s take a look on how the Ispirer SQLWays Replicator works when executing operations like  UPDATE and  DELETE.

Firstly, let’s execute SELECT from the table called tab_pk_mult_cols in order to review current data in the table.
And then execute  UPDATE Statement and DELETE Statement, that were prepared for the demonstration. 

We execute SELECT one more time in order to check data in the table after the completed operations.
As we can see, the data in column  col3 has changed, and the raw, for which we executed the  DELETE Statement, was deleted.

Next let us execute SELECT from the table called tab_pk_mult_cols in Oracle. 
And we see no changes with the data in the table.  

And now let’s launch the Ispirer SQLWays Replicator again. 
and again execute  SELECT from the tab_pk_mult_cols table in Oracle.

We see that the replication was successfully completed. 
The data in SQL Server and Oracle were replicated.

I’d like to thank you for your interest and time. Please contact Ispirer to get our free assistance and expertise support. Bye.

PL/I转成JAVA HIBERNATE演示视频

演示视频文本：

           大家好！本演示视频介绍Ispirer Systems的数据库与应用程序迁移的工具。具体的讲，从PL/I到Java Hibernate转换。

演示视频前，我介绍一下三个主要工具，其中有两个基于命令行的图形用户界面工具:
• Ispirer Migration and Modernization Engine – 是命令行工具， 可以在批处理模式下运行，它可执行在脚本中包含的应用程序所编码的自动转换。
• Ispirer Migration Studio –是图形用户界面工具， 是专为单个的应用程序脚本所分别转换设计的。同时转换一个脚本。
• Ispirer Migration Commander—是图形用户界面工具， 是专为多个应用程序脚本所分别转换设计的。同时转换几个脚本。 
我们原应用程序和数据库工作，它从数据库中生成报告。我们来看此报告。

我们从IspirerMigrationCommander开始。首先，我们应该选择原和目标语言，原语言应该是PL/I，目标呢—Java。 
在本工具中的左边，我们应该选择需要迁移的原文件，右边我们指定迁移效果的存储文件夹。

我们选择文件后，点击Run和OK。迁移过程需要几个分钟。

在本工具的尾中，涉及迁移过程的信息与注释提供的。它包含的信息是文件总数，其名与大小。
在此演示视频，我们有一个文件，它包含以PL/I写的编码。
我们将此文件和迁移效果打开。
迁移过程结束后，我们可以在Java项目中实现该效果，在Eclipse IDE中打开它，并编译和执行它。
您看，整个编码被编译，我们结果是同样的应用程序。 它生成的报告和原应用程序的一样。

我们在IspirerMigrationStudio中来看此编码。
本工具的左边，我们看原文件，指定的原和目标语言 -- PL/I 和 Java。点击Run。

在本工具的尾中，我们看涉及迁移过程的信息与注释。
右边是迁移效果。它看来和IspirerMigrationCommander中的一样。

从MICROSOFT SQL SERVER到AMAZON REDSHIFT数据库迁移演示视频

演示视频文本：

           大家好！本演示视频介绍Ispirer Systems的数据库与应用程序迁移的工具。具体的讲，从Microsoft SQL Server到Amazon RedShift数据库迁移。

我介绍一下在Ispirer工具所帮助下的从Microsoft SQL Server到Amazon RedShift的数据库迁移过程。
我们来使用四个主要工具:
• Ispirer Migration and Modernization Engine – 是命令行工具， 可以把它在批处理模式下运行，它可执行在脚本中包含的数据库或应用程序所代码的自动转换。
• Ispirer SQLWays Wizard –是专为数据库迁移设计的图形用户界面工具， 使用ODBC连接到原数据库。
• Ispirer Migration Studio –是图形用户界面工具， 是专为单个的应用程序或数据库脚本所转换设计的。同时转换一个脚本。
• Ispirer Migration Commander—是图形用户界面工具， 是专为多个应用程序或数据库脚本所转换设计的。同时转换几个脚本。 
我们从第一个工具（就是Ispirer SQLWays Wizard）开始演示迁移。该工具是专为数据库迁移开发的全功能工具。
首先，为了该展示的目的，我们准备了两个数据库：一个Microsoft SQL Server数据库和一个空的Amazon RedShift数据库。我们把Microsoft SQL Server的对象迁移到Amazon RedShift。
您一运行SQLWays Wizard就看欢迎页面。此页面上， 您需指定您收到的许可证，和包含需迁移所文件集的项目目录。好， 我选出它们， 点击下。
为了从Microsoft SQL Server迁移到Amazon RedShift数据库，您需调整为Microsoft SQL Server的ODBC DSN并在“Choose a Source Database”页面上指定它。也需要指定的是，用户与密码，它应该具有从Oracle系统表中做选出的适当权限。 
在“Choose a Target Database”页面上，您要从支持的数据库单中而选出目标数据库。您看，Amazon RedShift是指定的。为了让目标数据库的内建工具支持定义和数据加载，我们也应该填写其它凭证， 如主机、端口、数据库、用户与密码。此外，为了能够将数据导入到Amazon RedShift数据库中，需要指定路径到包含上传数据文件的Amazon S3文件夹，并指定访问密钥ID和秘密访问密钥。
SQLWays从Microsoft SQL Server提取的对象都在“Specify Database Objects or Query”页面上以树视图模式描述的。这儿您可选择所有需要迁移的对象。
此后，您可指定一些选项， 它们都可帮助您定制Microsoft SQL Server 到Amazon RedShift数据库的转到过程，如控制模式名的转换、保留字转换、数据类型转换所选项等。
在“Specify Export File Options”页面上，您需指定目录， 它作为整个迁移过程的中间存储库并保存所有自动生成的文件，如包含已经转换的代码所SQL文件、包含数据的TXT文件、BAT或SH文件。
在“Specify Import Options”页上，需要指定Bin目录。Bin Directory是到您机器上的包含psql.exe效用文件夹的路径。我们的工具将使用此路径来生成正确的导入命令。
为了开始转换过程，我们点击“Start Conversion”，本工具将提取关于指定对象的信息，并生成被转换的脚本。
当转换完成时，我们需要复制所有的txt文件（就是包含提取数据的文件），并将它们上传到Amazon RedShift S3文件夹。
为了启动导入过程，我们单击“Start Import”，本工具将该文件中的数据加载到Amazon RedShift数据库中。
从Microsoft SQL Server 到Amazon RedShift整个迁移的过程有两个具有不同登录信息的阶段。
为Export的过程sqlways.log文件提供的，该文件包括：Microsoft SQL Server数据库的每个移除表的对象、其数量、数据行数量、数据规模。在输出log文件的尾中，提供每个对象信息总结。
更易读的信息在sqlways_report.html文件提供的。是总结表，包括每个从源数据库输出的对象类型完整输出地位与统计。
至于输入过程，SQLWays生成sqlways_imp.log文件，它包含有关正在加载什么对象的信息，以及在导入过程中是否有任何问题。
现在，让我们从Microsoft SQL Server数据库的视图中选择。看来它返回一些数据。现在我在Redshift中做相同的选择。视图返回的数据是相同的。所以迁移的过程工作正确!
为此演示视频的信息结束。为查看有关Microsoft SQL Server 到Amazon RedShift迁移特点的信息，以及有关其他迁移方向的信息，请访问我们的网站www.ispirer.com或下一个演示。
非常感谢您的关注。再见。

PL/I转成JAVA JDBC API演示视频

POWERBUILDER转成JAVA JSF演示视频

演示视频文本：

         Hello!
 In this Demo we will show you how to automatically migrate  PowerBuilder to Java with JSF. 
    First of all, we will show how our demo application in PowerBuilder works before the migration. Our application is a book store, there are two datawindows. There is description of the chosen book in the upper datawindow, and in the second datawindow the list of stores is available. Also there are some options. For example, you can add a book or a store in pop-up windows. And you can delete them.
    So, it is a very simple application that will perfectly meet our demo requirements.
    Now let’s start the migration. First, we should launch Ispirer Migration Commander. This is the most powerful tool to migrate code from one language to another. At the left side we need to open source files. You can see PowerBuilder project here. Also we need to open target folder for conversion results. Then we need to choose “Options” and select “Migration”. In the dialog window, we need to choose the path to the ini file with information about migration options.Our file contains the following information: UI_TYPE=JSF. Once all these steps have been completed, we need to specify our source – PowerBuilder – and our target –Java. Then we select all files for conversion and we need to press the “Run” or F5 to start the conversion. The migration process can take some minutes. You can see the log of conversion at the bottom of the screen. Once the migration is done, we can find target project files at the right side of the tool. 
    So, let’s look at sra migration. In our source project we have a demo application file. For this file, we create a java class. If sra file has an open event, it means that we need to create a public void method inside this java class:
AppOpenEvent() { open();} 
public void open(){} 
    If sra file contains general variables, which are global for the whole application it means that we need to declare the same variables of corresponding type and make them public and static. 
    Let’s move on to srw files. First, we need to create a java class with the same name as the window name. This class should contain a simple constructor. If srw file has an open event it means the same as for sra file. (We need to create a public void method, and this method should be included into the constructor of this class:
public Main_w() {open();} 
public void open(){} )
    But the main part of this demo migration is conversion of controls. For almost every powerbuilder control it is necessary to divide conversion code into ui and logic parts. In addition, when a control is converted as the logic part, we need to create two java classes for both windows: where control is located and for control itself. 
One more common thing for all controls is that all of them are declared and initiated as singleton, so their describing classes contain this pattern realization. 
    Let’s look at the first control. For example, it is cb_cancel commanbutton control. 
    Declaration of this control in forward block in the source goes to java class which corresponds to window where control is placed and looks like Commandbutton cb_cancel; 
    I’d like to underline that Commandbutton is the interface for this control, and cb_cancel correspomds to the control name from the source.
    Then we need to migrate the control creation which is described in create block. In the same java class, the initialization of this control will be placed into the class constructor. It looks like:
public W_main() {
  cb_cancel = Cb_cancel.getInstance();
}
    Let’s move on. Now we can see a java class which corresponds to the control itself. It looks like this:
public class Cb_cancel implements Commandbutton {
  public static Cb_cancel instance = null;
  public static Cb_cancel getInstance() {
    if (instance == null) {
      instance = new Cb_cancel();
    }
    return instance;
  }
  @Override
  public void clicked() {
  }
}
    This class corresponds to the control and should implement corresponding interface, also it should contain the realization of all the necessary methods, which go after the control description in the source, in this case this method is “clicked”.
    As for the ui migration, we need to create the following tag with corresponding properties:
<p:commandButton id="cb_cancel" value="Exit" action="#{w_main.cb_cancel.clicked}" />
    As for other controls we have similar migration process but the difference is that they may have other fields or methods.
    In addition, PowerBuilder has specific sql statements. For example, we have such thing as cursor for sql queries. In the source, it looks like this:
DECLARE book_list_cursor CURSOR FOR 
SELECT title 
FROM powerbuilderdemo_book; 
Go to java classes and open corresponding file in target folder (W_store_add.java). After migration is done, we should get the following code:
try(ResultSet book_list_cursor = GlobalVariable.SQLCA.getConnection().prepareStatement("SELECT title FROM powerbuilderdemo_book").executeQuery();){      
boolean FetchStatus = false;
book_list_cursor.setString(1,title);
while(true){…}
} catch(SQLException se) {
se.printStackTrace();
}
    So, we need to declare variable with ResultSet type, its name is the same as cursor name. In try/catch block we need to initialize this variable. GlobalVariable is a java class with global variables and one of them is SQLCA; getConnection() is a method for SQLCA to get connection; input parameter is created as select query in cursor declaration (SOURCE: SELECT title FROM powerbuilderdemo_book) and it is double-quoted.
    Let’s see how our application works after the migration. The java application looks similar to the source PB application. We can find here two tables with information about books and stores. We can also add or delete a book or a 01:16 store. The only difference is that for these actions new windows (pages) open, but it is possible to use another option to make them pop-up window.
    This is how our tool can proceed with PBscripts. Hope this Demo was useful. Feel free to contact us for more information about our conversion tools and services. Thank you for your attention!

POWERBUILDER转成JAVA GWT演示视频

演示视频文本：

          Hello and welcome to this demonstration of the Ispirer tools for PowerBuilder to Java GWT migration. We’ll be taking a look at a product called Ispirer Migration and Modernization Toolkit. 

This software is designed to be a complete solution for the automatic conversion of the applications between various platforms and programming languages. 

In this brief demonstration video, I’d like to show you how easy the conversion of PowerBuilder program to Java with GWT option can be performed by the Ispirer Migration and Modernization Toolkit. 

The program can be converted in three ways: 

1.  utilizing Ispirer Migration Commander. This tool is convenient for reviewing a large set of source files and the entire application when doing the conversion. 

2.  Also, we can use Ispirer Migration Studio for the conversion. It is designed to convert the source code files or separate fragments one by one. It visualizes the results of the conversion in a convenient way, and it is used by developers to make a quick evaluation of a particular solution in the product. 

3.  And finally, the conversion can be performed through the command line. With this option you can, for example, set up the conversion scheduling, or even build the launch of conversion into your development process.

For this demo we have selected a demo application in PowerBuilder program, which connects to the database and manipulates with the data. 

  Now let’s run this program in PowerBuilder. 

Our application is a book store. There are two data windows. A description of the book selected in the data window and a list of stores. There are several options as well. For example, we can add a book. Enter the data for this new book. And we can click the “Press to choose picture” button in order to add an image. 

Besides, it is possible to add a store in another application window. Now let's enter the data for the new store and press the button “Add”. It is possible to delete them as well. So, it is a very simple application that will perfectly meet our demo requirements.

Now let’s take a look on how the PowerBuilder application can be migrated by Ispirer Migration Commander. 

After launching this tool, in its left pane we have to select the folder, which contains the source files, and in the right pane we have to specify the directory where all of the generated results of conversion will be sent to.

This program consists of seven files: 

demoapplication.sra – it is the main program file;
d_store_information.srd and d_book_information.srd - these are the DataWindow source files; 
m_menu.srm – it is the Menu source file;
w_main.srw, w_store_add.srw and w_book_add.srw these are the window source files which have all the controls. 

In order to begin the conversion process, we need to specify the source direction for this migration – is PowerBuilder, and the target direction – in our case is Java GWT. 

After that, in the left pane we have to select the source files for conversion, and then just click on the RUN button. 
The migration process can take some seconds.

After the conversion, the appropriate files will be generated: 

Among them, for example w_store_add.java,

Now let’s take a look on how the application can be migrated with the Ispirer Migration Studio. 

After the Migration Studio has been started, we have to open the source file of the PowerBuilder program. So, in this case it will be w_store_add.srw file.

Then we have to specify the source and the target directions of migration - Powerbuilder and Java GWT- and then click RUN. 

As we have changed the structure of the project folder, the result of the migration we'll be availavle in the Result Studio folder. 

Now let’s run the conversion using the command line tool. We have created a file with all the necessary options. Here we can see the source and the target directions of migration. Now let's run this file. 

As you can see, a folder with the conversion results has been generated. These results are identical to the results obtained in the Migration Commander and Migration Studio. 

After the migration process has been completed, we can integrate the results to Java project and open it in IntelliJ Idea IDE, compile it, and execute. 

As you can see, the Java application corresponds to the source PowerBuilder application. 
We can find here at the tables with the information about books and stores. We can also add a book, enter the data for the new book, click on the “Press to choose picture” button to add an image. And we can add a store in another application window, enter the data for the new store and press “Add”.  Also we can delete both this book and store.

This is all information about the tools that our company provides for the conversion from Powerbuilder to Java GWT.

It is just a review of the tools, so if you need additional information please contact us, and we will be glad to assist you in your migration projects. 

Thank you very much for your attention.

POWERBUILDER转成C# WPF MVVM演示视频

演示视频文本：

         大家好！本演示视频介绍Ispirer Systems的数据库与应用程序迁移的工具。具体的讲，从PowerBuilder到C# WPF MVVM转换。

演示视频前，我介绍一下三个主要工具，其中有两个基于命令行的图形用户界面工具:
• Ispirer Migration and Modernization Engine – 是命令行工具， 可以在批处理模式下运行，它可执行在脚本中包含的应用程序所编码的自动转换。
• Ispirer Migration Studio –是图形用户界面工具， 是专为单个的应用程序脚本所分别转换设计的。同时转换一个脚本。
• Ispirer Migration Commander—是图形用户界面工具， 是专为多个应用程序脚本所分别转换设计的。同时转换几个脚本。 

我们开始。在这次演示视频中，我们以Ispirer Migration Commander与Ispirer Migration Studio来转移应用程序。
我们的源应用程序显示数据库中的数据。在第一个窗口中，我们可以看到第一个数据库锁中的一些条目。第二个数据锁显示从第一个数据锁中选择的项目的信息。我们可以插入，删除或更新这些行。
至于第二个窗口，在这里我们可以看到按国家的客户的百分比。此外，我们还可以看到“关于”和“帮助”窗口以及一些像选定窗口一样的MDI特征。

我们从IspirerMigrationCommander开始。首先，我们应该选择原和目标语言，原语言应该是PowerBuilder，目标呢— C#。 
在本工具的左边，我们应该选择需要迁移的原文件，右边我们指定迁移效果的存储文件夹。
我们选择文件后，点击Run和OK。迁移过程需要几个秒。

一旦转换了，我们能看到一些结果，我们可以比较和源文件。
整个迁移过程完成后，我们可以将结果整合到C # WPF项目中，编译它，并执行。
您可以看到，整个代码已经编译成功，因此我们有同一窗口和功能相同的应用。

我们在IspirerMigrationStudio中来看此编码。
本工具的左边，我们看原文件，指定的原和目标语言 -- PowerBuilder和C#。点击Run。

右边是迁移效果。它看来和IspirerMigrationCommander中的一样。

这是我们公司提供的从PowerBuilder到C# WPF MVVM的转换工具的全部信息。
如果你需要一些补充信息，请与我们联系，我们将乐意协助您与您的迁移项目。
非常感谢你的关注。再见。

POWERBUILDER转成ASP.NET演示视频

演示视频文本：

          Hello!
Today I will show you how Ispirer Migration and Modernization Toolkit 2015 can automatically migrate a PowerBuilder application to a .NET web platform.
    First of all let’s look at the PowerBuilder application. It represents data from a Microsoft SQL Server database and sorts this data using a specific filter applied to the DataWindow object.
    Let’s look through the source code of this application. There is a main window and some controls: statictext, singlelineedit, commandbutton, and DataWindow.  Below we can see a definition of controls. When we click the button, the data is sorted by a specified criteria.
    The application has a simple menu. The menu contains several main items - “File” with 2 sub items: Item 1 and Item 2. 
    And like every application, it has an item “About”. When we click «About», a window «simple about» opens. 
    Let’s look at the window «simple about».  It is a window for the description of an application, and there is only a label with the text “This is a simple demo application”.
    In the application we have a PowerBuilder user object “n_simple_demo_connectservice”. It contains settings and options for connection to a database as well as some methods and functions necessary for manipulation of errors during connection to a database.  
    There is also one DataWindow with PBSELECT to represent data from simple_demo table for Name and Age columns.
    Let’s run the application and see how it works.  There is a menu with menu items. When we click the item “About”, the window with the definition of the application appears.
    There is the DataWindow with Name and Age columns. Below there is a filter for data sorting in the DataWindow. For example, we want to see names with the age equal to 19 – when we click “Show”, the sorted data appears and we can see only names with the age 19.  I have just shown you the PowerBuilder application. And now I’ll show you how Ispirer MnMTK 2015 can migrate it to a web .NET application. 
    Before the migration of this application we need to extract all the sources from the PowerBuilder library. For this purpose we can use the PowerBuilder environment – Source Edit, or we can use an Ispirer tool PowerBuilder Extractor which you can find on our website in the Download section.
    We have already extracted these objects from the PowerBuilder library. You can see, for example, the source code for the PowerBuilder DataWindow. Once the sources have been extracted, we should put them in one folder, SRC in our case. And then we need to run Ispirer MnMTK 2015. 
    For the migration of the PowerBuilder application we use Ispirer Migration and Modernization Engine. It is necessary to create a bat file – a command file to run the tool. Let’s look at the structure of this file. 
    First, there is a path to where Ispirer MnMTK 2015 was installed. The option /D=FIXED means that in this case we don’t need to migrate a database, it will remain the same.  We see that the source is PowerBuilder scripts and the target is C#. /F Option is a path to where the sources are located. /DIR is the folder where the results of the conversion will be put and /INI option is a path to our configuration file SQLWays ini  - in this file we put some options for specific needs of clients or options for a specific migration.
    In our case SQLWays ini file contains only one option. It means that the UI will be built using ASP.NET pages.  
    Let’s run this BAT file.  You can see that Ispirer MnMTK 2015 has started the process – all the files have been extracted, there are 6 files for the conversion.  First, the tool selects the information about the dependecies of variables and any information that can be useful when we migrate the whole application. Once the information has been collected, the tool starts to convert each script separately. 
    The result folder has been generated and you can see that all PowerBuilder objects have been converted. It is SQLWays log file. Here you can see the information about the migration.
    We can see that one application file, one data window, one menu file, one user object and two windows have been migrated. There are 6 scripts and it took only 40 seconds to complete the migration. 
    Let’s copy these conversion results to an empty .NET solution and run the application.  
    You can see that this application is written in Visual Studio 2010. Since we have added the migration results to an empty solution, the solution makes some dependencies and some references to these scripts.
    Now we can evaluate how Ispirer MnMTK 2015 converts PowerBuilder objects. First let’s look at the main window. PB controls have been migrated to ASP.NET controls and PowerBuilder events have been migrated to .NET events.
    Simple menu has been converted to a standard ASP.NET menu with items “File” and sub items “Item 1”, “Item 2” and a menu item “About”. When we click “About”, a page «Simple about» opens.  This page contains the information about this demo application. 
    The PowerBuilder user object has been converted to a C# class with the information about the connection specified, and PowerBuilder functions have been converted to C# methods.
    DataWindow is included in the main page as a control. DataWindow has been migrated to GridView with columns to represent names and age, and PBSELECT has been converted to a standard SELECT of Microsoft SQL Server. 
    We can run this application and look how it works now in a .NET environment. 
    The view is the same as in PB - it has a menu with 2 items. We can click «About» and we see that the «About» page with the description of our application opens.
    Let’s check how the filter works. For example, we want to see names with the age equal to 25. Let’s click “Show” and we can see the sorted data. 
    The functionality of this application is the same as in PB.
    As you can see, Ispirer MnMTK 2015 can automatically convert your application from PB to a web .NET environment. If you are interested in our toolkit or services, please contact us. Thank you for your attention.

产品

支持

顾客

关于Ispirer