From COBOL to DataSnap XE2

Many years ago I had built an automation server for my accounting platform using Delphi 6. It was based on TRemoteDatamodule and the Midas components TDatasetProvider & TClientDataset. It was a discovery for me especially speaking for TClientDataset and its unlimited features not only as a Midas client but as a standalone dataset fulfilled with capabilities that a blog post would not be enough to describe.

A couple of weeks ago, after I finished installing and familiarizing my self with the brand new Delphi XE2, I started studying its DataSnap technology. I have to say that I was somehow impressed by the bunch of features I had seen in demos, videos and webinars. Off course Midas components are still at the first line of building database client/server apps with DataSnap, but also a lot of other technologies have been added or heavily enhanced.

Some of them that I noticed are:

• Datasnap server with TCP/IP and HTTP(S) protocols
• Server classes with exposed methods to remote clients
• JSON object marshalling & un-marshalling
• Enhanced DBExpress framework (though I have never used it),
• DataSnap Connectors for Mobile Devices !
• DataSnap Callbacks
• Authorization & Authentication
• And many others that complete a long list to mention.

I was so confused with all these that I decided to give it a real world try by converting a old (from 1989) COBOL application to DataSnap. 
Did I said “Convert” ? Fully rebuild is the right choice of words. 

As database layer I was planning to stick with my well known SQLServer and ADODB in order to focus on Datasnap only. After database schema decided and built into SQL Server, I started the DataSnap server wizard of Delphi XE2. Choose “VCL Forms Application”, enabled all features except HTTPS and selected TDSServerModule as server methods class. 

• VCL Form selected in order to have a live server interface to do things like message logging, start/stop server, monitor its activity etc.
• All features selected in order to be able to test most DataSnap capabilities and be ready for mobile clients.
• TDSServerModule as server methods class provides a TDatamodule surface for VCL non-visual components and IAppServer interface which is essential for Dataset providers and clientdatasets communication (Midas).

The project the wizard  created was a lot different from what I was used using Automation with TypeLib and TRemoteDatamodule, but a few hours later I (think) had a clear understanding of the framework. The major aspects I acknowledge in simple terms are:

• VCLForm: the main form for monitoring server activity
• Container: a TDatamodule that is the main server module containing among other components a TDSServer, the class that manages transports from and to remote clients and server classes, a TDSServerClass which in turn used to specify a server-side class.
• ServerMethods: a TDSServerModule supporting IAppServer interface and contains the published methods that can be called from a remote client using dynamic method invocation.

How these works is pretty simple at its basics. 

Requests are served through the Container’s TDSServer component which coordinates traffic with the help of the other container components. 

As for the TDSServerClass it is the component responsible for creating its associated ServerMethods class. 

ServerMethods class exposes to remote clients its public methods and for the TDSServerModule especially the IAppServer interface for provider/clientdataset communication (Midas).

You can create as many classes as you want, either TComponent, TDataModule, TDSDataModule and expose their published methods, and IAppServer Interface in case of TDSDataModule, by just adding a TDSServerClass component in your server Container and respond to its “OnGetClass” event like this:

procedure TMyServerContainer.DSMyServerMethodsGetClass(DSServerClass
  : TDSServerClass; var PersistentClass: TPersistentClass);
begin
  PersistentClass := TMyClass; //Class of your TComponent, TDatamodule, TDSDataModule
end;

At client side now I had to create a VCL forms application and connect to the server to retrieve and present data for editing to the user. Three components do the base job:

• TSQLConnection: is the connection component that encapsulates a dbExpress connection to a database server. It can connect to various database server but in the case mentioned it connects to my DataSnap server using tcp/ip protocol.
• TDSProviderConnection: a component that provides connectivity to a DataSnap server methods class, the above mentioned ServerMethods (TDSServerModule), using dbExpress.
• TClientDataset: connected to the TDSProviderConnection via RemoteServer property and to the actual provider of the data in ServerMethods via ProviderName property.
  

I won’t describe further the details of setting the properties of those components as there are a lot of video presentations and articles at the official Embarcadero site & blogs. Also having a close look at the DataSnapXE projects in your XE2 samples folder is a must and I found them to be very much helpful.

Back to now, the business logic of my project is already implemented at the server and test clients have succeeded testing and coordinating them.


TClientDataset works as expected and a few extra communication needed between client and server implemented based on streaming TParams (TParamsStorage) via OwnerData. I use a lot this technique to pass info from one module to another and especially for passing user input from UI forms to datamodule methods that need to build runtime queries and return result sets for browsing, reporting etc. See my article series “A Journey to TParams” for more info.


Client Reporting requests are served from the server as entities of ClientDataset XmlPackets and processed at the client and the only things left are UI enhancements. Hope it soon will be completed so i can dig in more interesting aspects like Mobile connectors.

Datasnap & Transparent client lookup fields

Back in year 2000 I faced a problem trying to build my accounting platform to work in 3 tier client/server mode. In classic desktop applications I had separated database access logic and business rules from the user interface forms by using Delphi’s TDatamodule. A small but essential piece of this separation was lookup fields that once defined in the datamodule’s datasets should work transparently on UI forms with no further configuration.

But in the 3-tier model this could not be done, because TClientDataset in the client application receives the datapacket with lookup fields as data (fkData) and readonly. That seems logical as lookupfield info (LookupDataset property mainly) is unknown to the client. So the solution was to add clientdatasets for each server lookupdataset at the client and construct new lookup fields in the dataset that needed such referencies.
Problem! The level of abstraction of data I wanted for UI forms was broken, and even putting them in a client TDatamodule would be a break to the abstraction of data for the framework.

Did I mention “…could not be done”?

Shame of me, I am a Delphi developer.

All I needed was to scratch my head a bit more, and … Eureka! 

I spend some time reading the sources to figure out exactly what TDatasetProvider is doing behind the scenes and concluded that it would be possible to overcome the default behavior. The idea was to gather info about lookup fields, send them to the client where they can be processed and simulate lookup functionality. The process should be transparent to the client so I decided to embed it in a derived TClientDataset. On server side a procedure called from provider’s OnGetDatasetProperties should do the job of collecting and packaging needed info.

The result was “LookCDS”, a small library set of functions, classes and components for Delphi that enables and utilizes at client side the lookup fields defined in a Datasnap remote module. TlkClientDataset, a TClientDataset descendant, contained in LookCDS lib is the main component that supports transparent utilization of server side lookup fields. The library consists of two source files.

• DB_LooksClient.pas: It mainly contains TlkClientDataset, a derived TClientDataset to use at client side.
• UtilLookCDS.pas: Functions and definitions used by DB_LooksClient at client side and by TDatasetProvider at server side.

LookCDS enables transparent support for lookup fields defined in Datasnap server module to the client. It can be used this way:

On server side

• Define lookup fields as usual and just set their provider flags pfInUpdate & pfInWhere to false.
• Add TDatasetProvider component for any lookup dataset your fields refer to and you want to be enabled in the client.
• At the provider of the main dataset (that with lookupfields) add a call to “ProvideDatasetProperties” (in UtilLookCDS.pas) utility procedure.

On client side

• Use TlkClientDataset instead of the usual TClientDataset

That's all.

You can download the “LookCDS” files and a simple Datasnap XE2 demo here:  http://users.hol.gr/~georgev/delphi.htm

and at sourceforge project: http://sourceforge.net/projects/lookcds/

February 14, 2012 - Celebrate Delphi’s 17th birthday

I have been using Delphi since about 1997 (i do not remember exactly ;) ) , that is a couple years after it was launched and now i see this birthday celebration that i cannot loose.

Delphi Birthday Celebration
Celebrating 17 years of Continuous Innovation with Embarcadero Delphi

Delphi version 1.0 was launched at the Software Development Conference on February 14, 1995. The several thousand developers gave the team a standing ovation during the launch. This year we are celebrating 17 years of continuous innovation for the Delphi language, run-time library, Visual Component Library (VCL), database connectivity, application architectures, IDE, tool chain, and the new FireMonkey next generation business application platform. On our world tour stops for Delphi XE2 last fall, we again received standing ovations and big applause.

Join host David I and his special guests who will showcase many of the leading edge Delphi technologies, talk about customer success stories and provide tips for developers who want to move their applications into the future. This is one party you won’t want to miss!

Celebrating 17 years of continuous innovation with Embarcadero Delphi

In this two-hour online special event, you will learn how to:
Take advantage of Rapid Application Development across Windows, Mac, Mobile and Web
Leverage Delphi’s technology innovations for your application development success
Use the many Tips and Tricks that will speed up your development
Migrate your legacy Delphi application to the new FireMonkey business application platform
Build FireMonkey 3D applications for scientific, engineering, mathematics and automation industries

Date: Feb 14, 2012

A journey to Delphi TParams - Persistence

In the first article I demonstrated some features of TParams we can use at every day development to hold, process and move data structures around. But what if we want to persist such data and come back to them later?

As you will see, persisting is very easy and is based on Delphi’s component streaming mechanism. It is the same core mechanism used by IDE to save and load a form’s design in .dfm files. TStream class introduces methods that work in conjunction with components and filers for loading and saving components in simple and inherited forms. The two TStream methods needed are ReadComponent & WriteComponent and their definitions are:

function ReadComponent(Instance: TComponent): TComponent;
procedure WriteComponent(Instance: TComponent);

Delphi help also introduces two example functions to show how to use the built-in component streaming support to convert any component into a string and convert that string back into a component. These functions are a long time ago in my utilities library!

function ComponentToString(Component: TComponent): string;
var
  BinStream:TMemoryStream;
  StrStream: TStringStream;
  s: string;
begin
  BinStream := TMemoryStream.Create;
  try
    StrStream := TStringStream.Create(s);
    try
      BinStream.WriteComponent(Component);
      BinStream.Seek(0, soFromBeginning);
      ObjectBinaryToText(BinStream, StrStream);
      StrStream.Seek(0, soFromBeginning);
      Result:= StrStream.DataString;
    finally
      StrStream.Free;
    end;
  finally
    BinStream.Free
  end;
end;

function StringToComponent(Value: string): TComponent;
var
  StrStream:TStringStream;
  BinStream: TMemoryStream;
begin
  StrStream := TStringStream.Create(Value);
  try
    BinStream := TMemoryStream.Create;
    try
      ObjectTextToBinary(StrStream, BinStream);
      BinStream.Seek(0, soFromBeginning);
      Result := BinStream.ReadComponent(nil);
    finally
      BinStream.Free;
    end;
  finally
    StrStream.Free;
  end;
end;

Now that we have all the streaming functionality in our hands we can stream in & out a TParams collection, or we cannot?

No, we cannot. Component streaming works with TComponent & descendants and TParams is not one of these, it actually derives from TPersistent->TCollection.

But this is something easily fixed just by declaring a TComponent with a published TParams property. The streaming mechanism can then deal with this component and “magically” save and load the TParams collection.

Here is such a declaration, very simple and clean:

TParamsStorage = class(TComponent)
protected
 FParams: TParams;
published
 property Params: TParams read FParams write FParams;
end;

Now that we have the ability to write and read a TParams collection to and from a string, we can persist it anywhere we want, a local variable, a file, a stream, a database field etc. I personally have a function and procedure to automate the process of converting TParams to string and vice versa. Here they are:

function ParamsToString(Params: TParams): string;
var ps: TParamsStorage;
begin
  ps := TParamsStorage.Create(nil);
  try ps.Params := Params;
   Result := ComponentToString(ps);
  finally ps.Free;
  end;
end;
procedure StringToParams(Value: string; Params: TParams);
var ps: TParamsStorage;
begin
  ps := TParamsStorage.Create(nil);
  try ps.Params := Params;
   ps.Params.Clear;
   StringToComponent(Value,ps);
  finally ps.Free;
  end;
end;

Another interesting effect of having a TParams collection in a string is that we can store this string in a single TParam object, effectively creating a tree structure of TParam collections!You can investigate the whole idea in the code behind the recursive function I use to create/update such structures:

TParamProps = record
  Name: string;
  DataType: TFieldType;
  Value: variant;
end;
function CreateTParams(const aParams: array of TParamProps): TParams;
var i: integer;
begin
  Result := TParams.Create;
  for i:=0 to High(aParams) do
   Result.CreateParam(aParams[i].DataType,aParams[i].Name,ptUnknown).Value := aParams[i].Value;
end;

function UpdateParam(
Params: TParams; const //The root TParams collection
Path: array of string; //TParam names hierarchy path
             FldType: TFieldType; //DataType of TParam to create
Value: Variant //Value of TParam to create/update
): Boolean; //True always 
var WP: TParams;
    P: TParam;
    A: array of string;
    i: integer;
begin
  if Length(Path) = 1 then
     begin
     P := Params.FindParam(Path[0]);
     if not Assigned(P) then
        P := Params.CreateParam(FldType,Path[0],ptUnKnown);
     P.Value := Value;
     Result := True;
     end
  else
     begin
     P := Params.FindParam(Path[0]);
     if not Assigned(P) then
        P := Params.CreateParam(ftString,Path[0],ptUnKnown);
     WP := TParams.Create;
     try if P.AsString <> '' then
           StringToParams(P.AsString, WP);
      SetLength(A,Length(Path)-1);
      for i:=0 to Length(A)-1 do A[i] := Path[i+1];
      Result := UpdateParam(WP,A,FldType,Value);
      P.AsString := UtilDB.ParamsToString(WP);
      finally WP.Free;
      end;
     end;
end;

Have fun developing, because development is fun!
Feel free to modify the above code as per your needs and if you make any enhancements please contact me.

Webinar: Software Development Trends 2012 with David I and more

I have just found this announcement and applied to attend. Thanks boys.
------
Registration is now open for our first free webinar of the year - Software Development Trends 2012 featuring David I in an interactive discussion with Michael Swindell, Senior Vice President of Marketing and Products and John Thomas, Director of Product Management discussing software development trends that are important to Delphi, C++Builder, RAD Studio and other software developers in the new year.

Software Development Trends 2012

Monday, January 23, 2012

6:00am PST / 9:00am EST / 3:00pm CET

11:00am PST / 2:00pm EST

5:00pm PST / January 24 12:00pm Australian EDT

Register Now

Topics and trends that will be covered include:

• What developers need to know to be successful in 2012
• Productive Windows and Mac application development in your workplace
• Adding mobile applications to your business infrastructure
• Cloud applications and storage and their impact on software developers
• Multi-client, multi-platform, multi-database, multi-tier – how to leverage it all in 2012

You will get insight into technologies that are making a difference for ISVs and enterprises and how you can use Embarcadero tools to create great software that puts you ahead of the competition. You’ll also get a chance to ask questions during a live Q&A session at the end.


Join us for this valuable session with information that every developer using RAD Studio, Delphi, C++Builder, Embarcadero Prism and RadPHP needs to know!

Data Centric Application Framework

An application framework consists of software used by developers to implement the standard structure and base functionality of an application for a specific development environment and/or application needs. Developers usually use object-oriented programming techniques to implement frameworks such that the unique parts of an application can simply inherit from pre-existing classes in the framework.

Through my experience on facing requirements while building data centric applications for clients, i found out that there are common used constructs and need for utilities. So started gathering the tools and libraries i had built around, created new modules, classes and components and modified them so they could work together. Finally something came out of this; a development framework that could support almost all the base functionality i needed and the consistency i wanted my products to have.

My framework is a software development framework, fully object oriented and data centric, for the Delphi development environment that targets the Win32/64 platform and SQL RDBMS. It is designed for rapid application development and focuses on efficiency, usability and consistent functionality of the final product.

User experience, with intensive all day work on data entry and query forms, is among the targets of this development framework, which provides a well balanced UI that helps user productivity. The framework provides forms and data modules with common functionality for almost every kind of data, utility dialogs for every day user work and common behavior of UI and controls.

Combines together many tools, functions, components and user enhancements in an environment that most of its functionality is almost out-of-the-box, helping the developer to rapidly create the base of consistent data centric applications and then focus to the specific requirements of the user i.e. business rules and further UI enhancements.

The main technical features consist of an MDI project template, base form/report classes and data module classes, all with integrated functionality that can be customized via inheritance, component events, virtual methods and class functions. It also contains application and user configuration modules and a lot of tools, dialogs & components that act at runtime in conjunction with all main classes of the framework.

I spent many hours (days, months…) working on this in parallel with other projects and I still make enhancement and adding new features, but finally seems like it worth the investment!

Know i am in the process of upgrading & enhancing it for the new Embarcadero Delphi XE2 and hope i will come back soon with a full technical description.

So stay tuned and have very good year 2012 full of happiness and joy.


Following is a small non-exhaustive descriptive list of the framework’s main features:

User Authentication

User authentication can be set by groups of users and authorities can be granted or denied for form or application defined procedure level.

  

Data features

Supports ADO enabled databases and especially SQL Server. Can install and update database via external scripts. Handles internally connection string and other connection parameters. Automatically marks with create/change user & timestamp info the database records that support this feature. Supports transactions, automatic or manual, on record or batch basis. Provides logical data schemas to forms and reports and handles communication of data between different active forms.

Application Desktop - MDI Environment

The application desktop is an MDI controller form class with user customizable main menu and sidebar.
Each user form works inside and controlled by the main application form. User can activate, deactivate, hide, minimize, arrange and switch between client forms inside the application desktop.

  

Common User Access

The framework adopts this IBM’s standard (CUA) which was a detailed specification and set strict rules about how applications should look and function. A major set of rules refers to the standardization of keyboard shortcuts (F keys and combinations) that user can use to access common features. Each keyboard shortcut has an application wide meaning so users are never confused when working with the different application forms. Such common keystrokes are F1 for help, F2 for field editing, F3 for search, F4 for lookup, F5 for refresh and so on. The CUA standard was also the basis for the Windows Consistent User Interface standard (CUI), as well as that for OS/2 applications. Most of the standard keystrokes and basic GUI widgets specified by the CUA remain a feature of Windows, but few users are aware of them.

Lookup & Select

Wherever a reference to a field is required user can activate a helper window that let him search and select a value for this field, i.e. when a customer must be selected for a purchase order the user is presented with a list of available customers in a fully customized data grid. Features of filtering grid data and quick locate column value are available also here as almost in all other data grids.

  

Data Grids

Data grids are extensively used in many places of the application framework. Data entry forms, query results, lookup&select are some of them. Data grids can be customized in many ways such as visibility of columns, column grouping and summaries. They support common actions like filtering, locate column value, print as is and can be exported to html, csv, xml or text.

Data Filtering

Filtering is a must have for every serious data centric application. When dealing with large amounts data filtering is an essential way to isolate and easily locate those of interest. The framework has extensive support for filtering with multiple different filters per dataset which can be application and/or user defined.

  

Dynamic data panels

Dynamic data panels can present data from a dataset record via dynamically created and/or runtime designed controls. Design specifications of the data panels can be saved for runtime reusability. As long as data logic is separated from the data presentation, a single form class which features dynamic control creation is enough and gives consistent UI experience.

  

Context Sensitive Popup Menu

Popup menu is a feature widely used in Windows and the framework utilizes this feature with context sensitive popup menu on its forms and user dialogs. It helps user to select from available actions on a form by just right clicking on it.

Form Menu

Each form has its own menu with all the available functions that are defined by the application. The menu supports floating and dockable bars and is fully customizable.

Edit record template

Base form class that supports editing of a single database record in a data panel which can be dynamic. Can also be used as generic record editing form.

Browse/Edit file template

Browse base form class that supports browsing database tables, queries and dataset results in a data grid. Features filtering and all data grid functionality except editing. Can also be used as generic dataset browsing form.
Edit base form class much like Browse file template that supports editing multiple database records in a data grid. Features data filtering, and all data grid standard functionality. Can also be used as generic dataset editing form.

  

Reporting template

Base report class that support consistent reporting features and functions along the application. User can preview reports, export report to various formats, change printer settings and define font sets for specific reports.

Query executor

Utility to build and execute queries against the data base. Results are presented in a data grid with capabilities like browse file and also can be used by Report Generator. Query definitions can be saved for later use and can also be parameterized.

  

Report manager

Reporting utility that features runtime report designer, save and load reports, custom layouts and reports based on user defined queries or datasets derived by the application like the ones manipulated by a Browse/Edit file templates or produced by Query executor.

  

Chart generator

A chart generating form class that can get input from any application dataset and produce on the fly charts (pies, bars, lines etc) on screen and printer.

  
 

  

1st Impressions on Embarcadero Delphi XE2 - Part 2

Though tomorrow is Christmas Day, i could not hold back and just turned on my workstation to play with my gift. 

Running again Delphi XE2, a notification showed up that Update 3 is available for download. It took a while to complete but i have to notice that all installation steps so far completed very smooth, despite the big amount of programs and features that installed. That is very nice and gives me confidence for the future.

Ok, Delphi XE2 pinned to start menu, let’s start discovering the new development environment.

Checking Installed packages and what is available for download. QuickReports & FastCube are available for download. For the first I will need it in order to convert my previous apps due to the extensive usage I had done, and I even derived some of these to suit my needs.

ADO DB is installed so normally I will not any problem. As for other components I will check on the go.

Looking at Help, “What's New in the Help, and Where is Everything” it says I must take a “Tour of the IDE”. It is comprehensive presentation of the IDE features and finally I found out what the “Structure View” window is (see my 1^st post), it is the Object Treeview from past versions of Delphi. Also “History Manager” and the Subversion integration is a very usefull new feature that “lets you see and compare versions of a file, including multiple backup versions, saved local changes, and the buffer of unsaved changes for the active file. If the current file is under version control, all types of revisions are available in the History Manager”.

Next stop is at a feature of modern application development tools, that old guys like me can truly appreciate, “Refactoring”. When you have written thousands lines of code in COBOL using just a plain text editor, or even used the first versions of IDE based tools like Delphi at late 90's, you can tell the difference about massive code modifications at the years before Refactoring. As help says “Refactoring is a technique you can use to restructure and modify your existing code in such a way that the intended behavior of your code stays the same. Refactoring allows you to streamline, simplify, and improve both performance and readability of your application code”. I will not get you any deeper to this but defenitely is something that every developer who builds applications with multiple units/forms should take into great consideration.

I will spend the rest of the night looking to demos, reading articles and watching videos at Embarcadero’s Developer Network. My purpose is to feel as much confortable with my new toy so I can start migrating old code libraries and my Data CentricApplication Framework* before I start migrating applications.

*I am preparing some articles for the “Data Centric Application Framework” and hope to publish them soon.