Object Translator

The Object translator is a bridge for reading java objects from external sources (i.e., Infinispan Cache or Map cache) and delivering them to the engine for processing.  And to assist in providing that bridge, the OBJECTTABLE function can be used to transform complex java objects into rows and columns.   

The following are the translator types and their respective supported data source:

• infinispan-cache - supports Infinispan cache and using either Key searching (for non-annotated objects) or Hibernate/Lucene searching
• map-cache - supports a local cache that is of type Map and using Key searching

Execution Properties - infinispan-cache

Supported Capabilities

The following are the connector capabilities when Key Searching is used:

• SELECT command
• CompareCriteria - only EQ
• InCriteria

The following are the connector capabilities when Hibernate/Lucene Searching is enabled:

• SELECT command
• CompareCriteria - EQ, NE, LT, GT, etc.
• And/Or Criteria
• In Criteria
• Like Criterai
• Or Criteria
• INSERT, UPDATE, DELETE

Usage

• Retrieve objects from a cache and transform into rows and columns.
• Perform writes to the cache

Metadata

Definition Requirements

• The table for the root class, must have a primary key defined, which must map to an attribute in the class.
• The table "name in source" (NIS) will be the name of the cache this table/class is stored
• The primary object that represents the cached object should have a name in source of 'this'.  All other columns will have their name in source (which defaults to the column name) interpreted as the path to the column value from the primary object.
• All columns that are not the primary key nor covered by a lucene index should be marked as SEARCHABLE 'Unsearchable'.
• Attributes defined as repeatable (i.e., collections, arrays, etc.) or a container class, will be supported as 1-to-* relationships, and will have corresponding registered class (if they are to be searched).
• A 1-to-* relationship class must have a foreign key to map to the root class/table, where the name in source for the foreign key is the name of the root class method to access those child objects. Note, this is the class method, not a reference in the google protobuf definition.
• Dynamic VDBs using metadata import will automatically determine a phsyical table for each root object and will have each top level member represented as a column.

Options for Defining

The following is an example of a key search and a view that associated player names with their team. It uses a dynamic vdb to define the physical source and views using DDL.   It uses a TeamObject class, shown below, with a teamName field that is used as its cache key and a String list of players. 

public class TeamObject {

   private String teamName;
   private List<String> players = new ArrayList<String>();

   public String getTeamName() {
      return teamName;
   }

   public void setTeamName(String teamName) {
	   this.teamName = teamName;
   }

   public List<String> getPlayers() {
	   return players;
   }

}

Note that by just using a dynamic vdb native import logic will provide you with a TeamObject physical table that can be queried. An equivalent Team table is shown here for demonstration purposes.

<vdb name="team" version="1">
    <model name="Team" visible="false">
        <source name="objsource" translator-name="infinispan1" connection-jndi-name="java:infinispan-jndi"/>
        <metadata type="DDL"><![CDATA[

            CREATE FOREIGN TABLE Team (
                TeamObject Object OPTIONS (NAMEINSOURCE 'this', SEARCHABLE 'Unsearchable'),
                teamName varchar(255) PRIMARY KEY)
              OPTIONS (NAMEINSOURCE 'teams');

         ]]> </metadata>
    </model>
    <model name="TeamView" type="VIRTUAL">
         <metadata type="DDL"><![CDATA[
             CREATE VIEW Players (
                  TeamName varchar(255) PRIMARY KEY,
                  PlayerName varchar(255)
             )
             AS
             SELECT t.TeamName, y.Name FROM Team as T,
                   OBJECTTABLE('m.players' PASSING T.TeamObject as m COLUMNS Name string 'teiid_row') as y;

        ]]> </metadata>
    </model>

    <translator name="infinispan1" type="infinispan-cache">
        <property name="SupportsLuceneSearching" value="true"/>
    </translator>
</vdb>

Notice the use of the OBJECTABLE function to parse the object from Team and transform into rows and column. This is only for demonstration purposes, and is not required in order to parse the object into rows and columns. This metadata could also be defined by using the Teiid Designer Teiid Connection Importer or can defined using CREATE FOREIGN TABLE and the Definition Requirements above. 

JCA Resource Adapter

See the Infinispan resource adapter for this translator.   It can be configured to lookup the cache container via JNDI or created (i.e., ConfigurationFileName or RemoteServerList).