Navigate data with the Mapper framework

Build your own data mapping system with an interlingual approach

By Snehal Patel, JavaWorld.com, 04/26/02

Most developers, at some point, have written software to move (and/or manipulate) data from two different data sources. Usually, the software that tackles this job is custom code specific to the data entities involved and the data itself. Fueling the fire, good data mapping software is typically very expensive for organizations with tight IT budgets, especially in today's market. The Mapper framework offers a simple and inexpensive (free) way for you to read from one data entity and write to another with minimal coding and maintenance.

In this article, I first explain the system's overall design and then demonstrate how the framework operates by mapping between a file and a database table. Using this example as a template, you'll be able to add other entities as your own specific requirements dictate and map data between them as easily as editing a few XML lines.

The framework

In Chapter 8.2 of the online book Survey of the State of the Art in Human Language Technology, Martin Kay explains that one algorithm for Machine Translation (MT), which translates text from one natural language (like English) to another, works by parsing the source text into a standard semantic form using the source language's grammar rules. It then applies the target language's grammar rules to the standard form to yield the desired translation. Of course, this is an oversimplification of how MT actually works, but this straightforward process, called the interlingual approach in MT, is the basis for the Mapper framework.

In contrast to the interlingual approach, another algorithm called the transfer approach attempts to translate texts by having a separate translation module from the source language to the target language. Given n languages in a system, n(n-1) translation mechanisms must translate each language to every other language. However, a solution similar to the interlingual approach significantly reduces the complexity of translating the languages, requiring only 2n translation mechanisms. The Mapper framework applies the interlingual approach to mapping data entities in a system, thereby making the system maintainable and easily extendable. The following figure illustrates this approach.

The framework's semantic representation of data, for simplicity's sake, is a HashMap called MapperRecord (of course, you can use XML as an alternative representation). In addition, the Entity interface represents each data entity:

public class MapperRecord extends java.util.HashMap {
}
public interface Entity {
   public static int READ = 0;
   public static int WRITE = 1;
   public void open() throws MapperException; //Open the entity for reading or writing
   public void close() throws MapperException; //Close all reading and writing
resources
   public MapperRecord readRecord() throws MapperException; //Read/translate
record from 
     //Data entity into a MapperRecord
   public void writeRecord(MapperRecord record) throws MapperException; //Write
MapperRecord to the data entity
}

You should apply the following rules to smoothly map between arbitrary data entities: