Abstract:
An object-oriented system and method is provided that is suitable for creating, reading, updating, and deleting data located across multiple different data stores. Unlike conventional systems, the present invention provides a unified method for access in the form of an UML mapping that ties together multiple databases, rather than using messaging middleware to achieve the same functionality. A virtual object layer provides safe updating, which can easily and automatically handle changes to the Object layer and to the underlying data store layers without the need to recompile or regenerate code.

Description:
BACKGROUND OF THE INVENTION  
         [0001]    1. Field of the Invention  
           [0002]    The present invention relates generally to data reading and writing across data stores. More specifically, the present invention provides an object-oriented system and method for creating, reading, updating, and deleting data located across multiple different data stores  
           [0003]    2. Description of the Related Art  
           [0004]    The rapid onset of the information age has meant that the growth of many enterprises, at least from the computer system architecture perspective, has been piecemeal. A company may have started, for example, with a sales division. Later, a customer service division was added. Later still came technical support. With the addition of each division came a new computer system with a different underlying architecture and inherent incompatibilities. Consider other enterprises, in which expansion was the result of mergers and acquisitions. A first Company (A) had a first system architecture, and a second Company (B) had an entirely different architecture. When Company A acquired Company B, it was easier to make do with two incompatible systems than to spend the resources and absorb the risk of merging data from the systems together. Of course, the longer each of the individual systems was relied upon, the more difficult it became to give either of them up.  
           [0005]    As a result, many enterprises continue today to operate with multiple system architectures that do not communicate with each other. Referring now to FIG. 1 there is shown an example of a conventional enterprise computer system architecture. FIG. 1 includes a customer server  108  for processing customer data, a sales server  110  for processing orders, and a technical support server  112 , for providing technical support services. Each of these servers in turn has an internal data store. As illustrated, customer server  108  includes an Oracle Database  102  for maintaining customer information; sales server  110  includes an SQL Server Database  104  for maintaining order information; and technical support server  112  includes a flat file database  106  for maintaining trouble tickets. Thus, for a sales representative  116  logged in to sales server  110 , it is not possible to see both the order information from the Oracle Database  102  and the customer information from the SQL Server Database  104  and customer information in a unified manner.  
           [0006]    This communication hurdle is a problem, because in the real world, sales, customer service, technical support and other divisions within an enterprise want (and need) to access data from systems outside of their own divisions. For example, a customer service representative should be able to access sales data for a particular customer, instead of relying on the customer to provide the make and model of their equipment. Similarly, when high value customers call for technical support, some enterprises would like to place those callers at the front of the call queue to minimize their hold time. However if the technical support telephone server cannot access the sales or customer service records, this business goal cannot be implemented. This is a problem well known to those of skill in the art. Indeed, the problem of unified access to disparate data is found in various enterprise environments—sales is but one example.  
           [0007]    Communication with databases is typically through the Structured Query Language (SQL). SQL, as is well known in the art, is a database query language adopted as an industry standard in 1986. A major revision to the standard, completed in 1992, is SQL-92 (also known as SQL2). Largely for competitive reasons, vendors have created differing database engines, despite their professed efforts to conform to the SQL-92 standard. Accordingly, SQL database clients cannot use pure SQL statements to access data from multiple vendors&#39; database servers. Instead, system integrators write custom code to point at different sources and present data to a user.  
           [0008]    Business applications are typically designed using a layered architecture. Referring now to FIG. 2, an Application Logic layer  202  implements the functionality of the application in terms of operations on an underlying Object layer  204 . The Object layer in turn implements the application&#39;s objects in terms of code that operates on persistent data that is stored in the Data store layer  206 . Each layer of the application implements an interface or language that is used by the layer above it, and that hides irrelevant detail about how the layer is constructed. This use of abstraction or information hiding in software design is analogous to how chemists can think about molecules and their interaction without having to think about how molecules are themselves comprised of atoms held together by electrostatic forces.  
           [0009]    A standard solution for allowing multiple business applications to share data is to use Enterprise Application Integration (EAI) technology, in which applications keep redundant copies of the data they need from other applications, and where an EAI module allows messages to be passed between applications when the data changes. In FIG. 3, the logic  306  in Application  1  updates an object  308  which in turn updates the data store  310  that contains data  302  from Application  1 , and a copy of data  304  from Application  2 . Application  1  sends a message to the EAI module  312  which updates the copy of the data B  314  in Application  2 . Some of the main drawbacks of the EAI approach are that it requires both applications to keep redundant copies of the data and that the copies are out of sync for long periods of time while the update messages are in flight. In addition, the applications must be manually adapted to use the EAI technology, and manually modified anytime an application&#39;s object layer or data store layer changes-an expensive, labor intensive-process. EAI technology is marketed by a number of vendors, including Tibco, Vitria, SeeBeyond, IBM, BEA, and Microsoft.  
           [0010]    Attunity Connect, by Attunity, Inc. of Wakefield, Mass. provides a virtual database layer between the original data store layer and the object layer. As shown in FIG. 4, a virtual data store layer  410  allows the object layer to access and update data  402 ,  404  in multiple application data stores. When the logic layer in Application  1   406  updates an application object  408 , the virtual object layer updates the virtual data store which in turn updates the underlying application data stores  402 ,  404 . The Attunity product allows applications to safely update data in other data stores and automatically handles changes to the underlying data store layer. However, applications must still be manually adapted to use the Attunity product and must be manually modified when an application&#39;s object layer changes.  
           [0011]    BEA Systems markets a product called Liquid Data that provides a virtual object layer in place of the original object layers in each application. As shown in FIG. 5, when Application  1  accesses an application object  508 , the virtual object layer  510  translates the access into accesses on the underlying data stores  502 ,  504 . A key drawback of the Liquid Data technology is that it does not handle updates to the application object; the object may only be read from, not written to, which severely limits the usefulness of this technology.  
           [0012]    Firestar Software of Acton, Mass. markets a product called ObjectSpark that provides a virtual object layer that allows the object layer to access and update multiple data stores. Referring now to FIG. 6, when the Application layer  606  updates an object in the Object layer  608 , the Object layer  608  updates a local copy of the data  602 ,  604 , and then updates the underlying application data stores  610 ,  612 . The use of redundant copies of data in the Object layer is a key drawback—the redundant copies can easily get out of sync; for example when Application  2  updates its data store  612  without informing Application  1  so that Application  1  can update its copy  604 . In addition, ObjectSpark does not handle changes to the Object layer very easily; ObjectSpark requires its virtual objects to be regenerated and recompiled when the Object layer changes.  
           [0013]    In view of the foregoing, a need therefore exists for a system and method for providing a virtual object layer with safe updating, which can easily and automatically handle changes to the Object layer and to the underlying data store layers.  
         SUMMARY OF THE INVENTION  
         [0014]    The present invention provides a solution to the need to aggregate data from multiple sources. Unlike conventional systems, the present invention provides a unified method for access in the form of a UML mapping that ties together multiple databases and an XML API to access the data directly, rather than using messaging middleware to achieve the same functionality.  
           [0015]    An Auto Discovery Engine allows a designer to discover tables located on various disparate data stores, and turns table data such as column name, type and size into metadata. From the metadata, the Auto Discovery Engine generates an XML schema, which is saved to an Internal Design Repository.  
           [0016]    To access data stored in data objects, a client creates queries that use property sets, filters and views. Database-specific SQL statements are generated by a Database Abstraction Layer. The XML for a query includes in a preferred embodiment a “propertyset” and a “filter.” The propertyset identifies the properties that should be returned as the results of the query and the filter specifies the constraints to place on the results.  
           [0017]    In addition, the present invention allows the schema to be updated and automatically reacts to schema changes in underlying data stores. When the schema definition in the Internal Design Repository is changed, the invention automatically modifies the data structures in the underlying data stores to reflect the new definition. When the data structures in the underlying data stores are changed, a Synchronizer module synchronizes the Internal Design Repository with changes in the schemas of the underlying data stores to ensure that data across the multiple data stores is always accessible using an up-to-date schema. 
       
    
    
     BRIEF DESCRIPTION OF THE DRAWINGS  
       [0018]    [0018]FIG. 1 is an example of a conventional enterprise computer system architecture.  
         [0019]    [0019]FIG. 2 illustrates the conventional architecture of a typical application.  
         [0020]    [0020]FIG. 3 illustrates a conventional Enterprise Application Integration solution.  
         [0021]    [0021]FIG. 4 illustrates the conventional use of a virtual data store layer.  
         [0022]    [0022]FIG. 5 illustrates the conventional use of a virtual object layer.  
         [0023]    [0023]FIG. 6 illustrates another conventional use of a virtual object layer.  
         [0024]    [0024]FIG. 7 is a block diagram of a system in accordance with an embodiment of the present invention.  
         [0025]    [0025]FIG. 8 is a flow chart illustrating a process for automatically generating XML schemas defining relationships between objects from different data stores in accordance with an embodiment of the present invention.  
         [0026]    [0026]FIG. 9 illustrates a UML (Unified Modeling Language) object model used in accordance with an embodiment of the present invention.  
         [0027]    [0027]FIG. 10 illustrates how the UML object model maps to a data model in accordance with an embodiment of the present invention.  
         [0028]    [0028]FIG. 11 illustrates an example of an aggregation that shows a foreign key in accordance with an embodiment of the present invention.  
         [0029]    [0029]FIG. 12 illustrates a method for creating instances of an object in accordance with an embodiment of the present invention. 
     
    
       [0030]    The figures depict preferred embodiments of the present invention for purposes of illustration only. One skilled in the art will readily recognize from the following discussion that alternative embodiments of the structures and methods illustrated herein may be employed without departing from the principles of the invention described herein.  
       DETAILED DESCRIPTION OF THE PREFERRED EMBODIMENTS  
       [0031]    System Architecture  
         [0032]    Referring now to FIG. 7, there is shown a diagram of a system  700  in accordance with an embodiment of the present invention. System  700  includes an Auto Discovery Engine  704 , which is used to generate appropriate XML Schema based on defined relationships between elements of the various data stores. The Internal Design Repository  710  is where the XML Schema representations are stored. This can be viewed simply as a repository that contains the actual XML Schema, although in practice it may be more efficient to store this information in database tables. The translation from the XML to database tables is a simple task for those of skill in the art, and therefore for the sake of clarity of description, the Schema XML is referred to in this document. Database Abstraction  712  allows access to multiple disparate data sources without writing, compiling and deploying SQL specific code by loading syntactical differences and generating compliant SQL specific code without the use of an if/then/else logical structure. The operation of Database Abstraction  712  is further described below. Transaction Processing Monitor (TP Monitor) is responsible for managing distributed transactions; in particular it coordinates the commitment and rollback of transactions in which the various data stores participate, as will be appreciated by those of skill in the art. System  700  also includes Synchronizer Module  716 , which synchronizes the Internal Design Repository  710  with any changes in the schemas of the underlying data stores  708 . Data stores  708   a ,  708   b  and  708   c  contain data to be accessed and manipulated by system  700 . Note that while three data stores are illustrated in FIG. 7, this is for purposes of illustration and not limitation—fewer or more data stores could be present. Data stores  708  can be relational databases, or non-relational databases with SQL-92 interfaces. If the data store supports distributed transactions then system  700  is able to manipulate the data from that data store in a distributed transaction, however distributed transaction support is not a required attribute of a data store. FIG. 7 also includes a workstation  706 , which can be used to create the object requests sent to system  700 .  
         [0033]    Entities  
         [0034]    An “Entity” according to the present invention is the design level description of an Object, similar to a “class” in Java or C++. At design time, the designer works with entity definitions. At run time, the user works with entity instances. Entity definition schema and entity instance data are stored in the Internal Design Repository  710  of system  700 . An entity definition schema is preferably an XML representation of the definition&#39;s properties and relationships. The XML is used to represent a Unified Modeling Language (UML)-type view of the object model. Those of skill in the art are familiar with the UML specification, which is publicly available from the Object Management Group.  
         [0035]    In one embodiment, entity definitions include two types of elements:  
         [0036]    Properties—Define the characteristics of the entity definition.  
         [0037]    Relationships—Provide a reference to another entity definition.  
         [0038]    In other embodiments, entity definitions also include:  
         [0039]    Primary Key  
         [0040]    a Indexes  
         [0041]    Data store ID  
         [0042]    Aggregation Information  
         [0043]    Association Entity Information  
         [0044]    Inheritance  
         [0045]    One example of syntax that could be used to define an entity is as follows:  
                                                                                                                                                                                                                                                                                                 &lt;SilkDataObjects_EntityDirectory_CreateDefinition&gt;                &lt;schema name=“entity-name”&gt;                &lt;!-- elementType block declaring parent --&gt;           &lt;!-- required for derived entity definitions --&gt;           &lt;elementType id=“parent-entity” is=“entity”/&gt;           &lt;!-- relationship block --&gt;           &lt;!-- required for aggregate entity definitions --&gt;           &lt;elementType id=“parent-entity” type=“aggregation”            is=“relationship”&gt;                &lt;element id=“aggregate-from-parent-role”                type=“aggregate-entity”           occurs=“aggregate-from-parent-multiplicity”/&gt;                &lt;/elementType&gt;           &lt;!-- property block -- 1 per property --&gt;           &lt;elementType id=“property-name” is=“property”&gt;                &lt;description&gt;field-name&lt;/description&gt;           &lt;lexicon/&gt;           &lt;string/&gt;           &lt;dataType dt=“string” maxlength=“integer-value”/&gt;           &lt;!-- additional blocks, depending on property type --&gt;                &lt;/elementType&gt;                .           .           .                &lt;!-- layout block -- 1 required --&gt;           &lt;elementType id=“entity-name” is=“entity” virtual=“1|0”&gt;                &lt;description&gt;descriptive text&lt;/description&gt;           &lt;element type=“property-name” occurs=“multiplicity”/&gt;                . . . &lt;!-- additional element blocks --&gt;                &lt;datasource password=“realm1” username=“realm1”&gt;                datasource            identifier&lt;/datasource&gt;                &lt;dbschema&gt;schema name&lt;/dbschema&gt;                &lt;key id=“key-name” type=“key-type”&gt;                &lt;keyPart href=“property-name”/&gt;                . . . &lt;!-- additional keyPart blocks --&gt;                &lt;/key&gt;                . . . &lt;!-- additional key blocks --&gt;                &lt;/elementType&gt;                &lt;/schema&gt;                &lt;alter_database&gt;[0|1]&lt;/alter_database&gt;            &lt;/SilkDataObjects_EntityDirectory_CreateDefinition&gt;                  
 
         [0046]    Relationships between entity definitions are described in a preferred embodiment using relationship names, role names, and cardinalities. For example, a Customer entity definition may have properties for AccountID, LastName, and FirstName, and have a relationship to a CustOrder entity definition.  
         [0047]    Properties have a name and a data type. In one embodiment, the data types include fixed-length and unbounded strings, integers, real numbers, Boolean values, dates, enumerations, and unique identifiers (UUIDs). Properties may be specified as required or optional.  
         [0048]    Any properties that are primary keys are required properties. Primary keys may be composed of one or more properties. For example, a Customer entity definition may have a primary key composed of the LastName and FirstName properties. An entity definition specifies which of its properties make up the primary key for the definition and, optionally, other unique or nonunique keys, which are analogous to indexes in relational databases. The layout block of an entity definition specifies which properties make up the keys for the definition. The layout block can also be referred to as an entity block. The entity block references the properties and relationships that make up the entity and specifies whether the properties are required or optional and also the multiplicity of the relationships. The entity block also specifies the data store ID and the keys.  
         [0049]    Any entity definition may describe one or more relationships with other entity definitions. A designer can specify relationships that involve multiple instances of an entity definition. That is, system  700  supports one-to-one, zero-or-one, zero-or-more, and one-or-more occurrences of an entity instance. Some examples of this kind of multiplicity include the following:  
                                           Required   1 . . . 1   This signifies that an instance of the               entity must be related to one and only               one instance of the related entity, for               example it is required that Person has               a Head. This kind of multiplicity is               usually in an aggregation relationship.       Optional   0 . . . 1   This signifies that an instance of the               entity may or may not be related to one               instance of the associated entity, for               example a Person may have zero or one spouse.       Zero or more   0 . . . *   This signifies that an instance of the               entity may optionally be related to many               instances of the associated entity, for               example a student may be enrolled in zero               or more courses.       One or more   1 . . . *   This signifies that an instance of the               entity must be related to at least one               instance of the related entity, for example               a sentence must contain one or more words.                  
 
         [0050]    In a preferred embodiment, system  700  supports relationships between entity definitions using the following:  
                                       Inheritance   Inheritance allows creation of an entity           definition that is derived from another           entity definition.       Associations   An association links two independent entity           definitions. An association defines the           relationship between two definitions.           Associations do not have properties.       Association entity   An association entity definition is an       definitions   association relationship and an entity           definition that attaches properties to the           association relationship. The entity           defines properties that exist only in the           context of the association relationship.       Aggregation entity   An aggregation entity definition is a       definitions   definition and an aggregation (whole/part)           relationship with another entity definition.                  
 
         [0051]    Auto Discovery Engine  
         [0052]    Auto Discovery Engine  704  allows an application developer to automatically discover relevant data fields from among the various data stores at design time.  
         [0053]    As noted, entity properties and relationships are specified by the user at design time using discovery engine  704 . Referring now to FIG. 8, there is shown an example of a method for using Auto Discovery Engine  704  to create an XML Schema in accordance with an embodiment of the present invention. First, Auto Discovery Engine  704  presents  802  a list of available data stores, from which the user then selects  804  one. Where required by the data store, such as with SQL Server and Sybase data stores, the Auto Discovery Engine  704  lists  806  catalogues that are available. After the user selects  808  a catalogue, or after the user selects the data store, if a catalogue selection is not required, she is next presented  810  with a list of schemas, which again she selects  812  from. Next, Auto Discovery Engine  704  presents  814  the user with tables stored in the schema, and the user selects  816  the table of interest.  
         [0054]    Auto Discovery Engine  704  next obtains  818  column information from the selected table. In a preferred embodiment, column information includes the name, type and size of each column. Next, Auto Discovery Engine  704  turns  820  the table name, column name, type, and size into entity and property metadata. Finally, Auto Discovery Engine  704  generates  822  an XML schema with the table name, column name, type and size data. This XML schema is then saved to Internal Design Repository  710 .  
         [0055]    Consider the following example, based on a scenario in which a first data store is an IBM DB2 Database (DB2db01), and a second data store is an Oracle Database (Oracledb02). The DB2 Database contains a table with customer information and the Oracle Database contains a table with Order information.  
         [0056]    In this example, the customer information in the DB2db01 data store is in a table named “cust_table” with the following makeup:  
                                                                                 Column Name   Data Type   Column Size   Nullable                                        ID (pk)   VARCHAR   25   NO           FIRSTNAME   VARCHAR   700   NO           LASTNAME   VARCHAR   700   NO           AGE   NUMBER   22   YES                      
 
         [0057]    A user can then use the Auto Discovery Engine  704  to create a schema for an entity to represent this data. The user selects the appropriate data store and schema, and then indicates the “Customer” table. The Auto Discovery  704  engine interrogates the data store to get the column names, types, sizes, nullability, primary key, and indexes. The column names, types, and sizes are represented by “elementType” elements that have the value “property” for the “is” attribute. The primary key and indexes are represented by “key” elements that have the “type” attribute of “PRIMARY”, “UNIQUE”, or “NONUNIQUE” for primary key, unique indexes, and non-unique indexes respectively. The following is an example of a schema produced for the example “Customer” table:  
                                                                                                                                                                                               &lt;schema name=“Customer” persistentname=“cust_table”&gt;                &lt;elementType id=“id” is=“property” persistentname=“id”&gt;                &lt;dataType dt=“string” maxlength=“25”/&gt;           &lt;description&gt;The User ID&lt;/description&gt;           &lt;label locale=“ENUS”&gt;User ID&lt;/label&gt;                &lt;/elementType&gt;           &lt;elementType id=“firstName” is=“property” persistentname=“fir                stName”&gt;                &lt;dataType dt=“string” maxlength=“700”/&gt;           &lt;description&gt;First Name&lt;/description&gt;           &lt;label locale=“ENUS”&gt;First Name&lt;/label&gt;                &lt;/elementType&gt;           &lt;elementType id=“lastName” is=“property” persistentname=“last                Name”&gt;                &lt;dataType dt=“string” maxlength =“700”/&gt;           &lt;description&gt;Last Name&lt;/description&gt;           &lt;label locale=“ENUS”&gt;Last Name&lt;/label&gt;                &lt;/elementType&gt;           &lt;elementType id=“age” is=“property” persistentname=“age”&gt;                &lt;dataType dt=“int” maxlength=“”/&gt;           &lt;description&gt;Age in years&lt;/description&gt;           &lt;label locale=“ENUS”&gt;Age&lt;/label&gt;                &lt;/elementType&gt;           &lt;elementType is=“entity” virtual=“0” id=“Customer”&gt;                &lt;key type=“PRIMARY”&gt;                &lt;keyPart href=“id”/&gt;                &lt;/key&gt;           &lt;datasource&gt;jdbc/DB2db01&lt;/datasource&gt;           &lt;dbschema&gt;PrimarySchema&lt;/dbschema&gt;           &lt;label locale=“ENUS”&gt;Customer&lt;/label&gt;           &lt;description&gt;Customer&lt;/description&gt;           &lt;element type=“id” occurs=“REQUIRED”/&gt;           &lt;element type=“firstName” occurs=“REQUIRED”/&gt;           &lt;element type=“lastName” occurs=“REQUIRED”/&gt;           &lt;element type=“age” occurs=“OPTIONAL”/&gt;                &lt;/elementType&gt;            &lt;/schema&gt;                  
 
         [0058]    The Order information in the Oracledb02 data store is in a table named “order_table” with the following makeup:  
                                                                                 Column Name   Data Type   Column Size   Nullable                                        ORDERID (pk)   NUMBER   22   NO           ORDERDATE   DATE   7   NO           TOTAL   REAL   7   YES           COMMENTS   VARCHAR2   250   YES                      
 
         [0059]    The Auto Discovery Engine  704  can again be used to point at the OracleDB02 data store to produce the schema for an entity to represent this data. The entity can be given a name like “Order” and an example of the resulting schema is as follows:  
                                                                                                                                                                                                                   &lt;schema name=“Order” persistentname=“order_table”&gt;                &lt;elementType id=“orderID” is=“property” persistentname-“orde                rID”&gt;                &lt;dataType dt=“int” dc=“sequencenumber” maxlength=“”/&gt;           &lt;description&gt;Unique Order ID &lt;/description&gt;                &lt;label locale=“ENUS”&gt;Order ID&lt;/label&gt;                &lt;/elementType&gt;           &lt;elementType id=“orderDate” is=“property”           persistentname=“or                derDate”&gt;                &lt;dataType dt=“date” maxlength=“”/&gt;           &lt;description&gt;Date order placed&lt;/description&gt;           &lt;label locale=“ENUS”&gt;Order Date&lt;/label&gt;                &lt;/elementType&gt;           &lt;elementType id=“total” is=“property”           persistentname= “total”&gt;                &lt;dataType dt=“r8” maxlength=”/&gt;           &lt;description&gt;Total Cost&lt;/description&gt;           &lt;label locale=“ENUS”&gt;Total Cost&lt;/label&gt;                &lt;/elementType&gt;           &lt;elementType id=“comments” is=“property”           persistentname=“co                mments”&gt;                &lt;dataType dt=“string” maxlength=“250”/&gt;           &lt;description&gt;Misc Comments&lt;/description&gt;           &lt;label locale=“ENUS”&gt;Order Comment&lt;/label&gt;                &lt;/elementType&gt;           &lt;elementType is=“entity” virtual=“1”           abstract=“0” id=“Order”&gt;                &lt;key type=“PRIMARY”&gt;                &lt;keyPart href=“orderID”/&gt;                &lt;/key&gt;           &lt;datasource&gt;jdbc/Oracledb02&lt;/datasource&gt;           &lt;dbschema&gt;OrderSysSchema&lt;/dbschema&gt;           &lt;label locale=“ENUS”&gt;Order&lt;/label&gt;           &lt;description&gt;Order&lt;/description&gt;           &lt;element type=“orderID” occurs=“REQUIRED”/&gt;           &lt;element type=“orderDate” occurs=“REQUIRED”/&gt;           &lt;element type=“total” occurs=“OPTIONAL”/&gt;           &lt;element type=“comments” occurs=“OPTIONAL”/&gt;                &lt;/elementType&gt;            &lt;/schema&gt;                  
 
         [0060]    Once the two entities are defined, an association between the two entities can be created. An example of the request to create an association between the Customer entity and the Order entity is as follows:  
                                                                                                                                                                                                                                                     &lt;schema name=“Order.placedBy” persistentname=“OrderplacedBy$”&gt;                &lt;elementType id=“Customer.id” from=“Customer” is=“property”&gt;                &lt;description&gt;The User ID&lt;/description&gt;           &lt;dataType dt=“string” maxlength=“25” /&gt;                &lt;/elementType&gt;                &lt;elementType id=“Order.orderID” from=“Order” is=“property”&gt;                &lt;description&gt;Unique Order ID&lt;/description&gt;                &lt;dataType dt=“int” dc=“sequencenumber” /&gt;                &lt;/elementType&gt;                &lt;elementType id=“Order” type=“ass ciation” is=“relationship”&gt;                &lt;element id=“placedBy” type=“Order.placedBy”                occurs=“OPTIONAL” /&gt;                &lt;/elementType&gt;                &lt;elementType id=“Customer” type=“association” is=“relationship”&gt;                &lt;element id=“places” type=“Order.placedBy”                occurs=“ZEROORMORE” /&gt;                &lt;/elementType&gt;                &lt;elementType id=“Order.placedBy” virtual=“0” is=“association”&gt;                &lt;entity type=“Customer” /&gt;           &lt;entity type=“Order” /&gt;                &lt;datasource&gt;jdbc/DB2db01&lt;/datasource&gt;           &lt;dbschema&gt;PrimarySchema&lt;/dbschema&gt;                &lt;description/&gt;                &lt;/elementType&gt;           &lt;ancestors/&gt;           &lt;descendents/&gt;                &lt;/schema&gt;                      
 
         [0061]    This request will create a table in the DB2db01 data store to store that will contain foreign keys to both the Customer and Order entities in order to store the association instance data.  
         [0062]    The association table (or join table) “OrderplacedBy$” has the following makeup:  
                                               Data   Column   Null-       Column Name   Type   Size   able                   PLACESCUSTOMERID$ (pk)   VARCHAR2   25   NO       PLACEDBYORDERORDERID$ (pk)   NUMBER   22   NO                  
 
         [0063]    The “placesCustomerID$” column is a foreign key to the customer table and the “placedByOrderOrderID$” column is a foreign key to the Order table.  
         [0064]    Now there is a schema that represents the following logical UML object model, as illustrated in FIG. 9.  
         [0065]    The model shown in FIG. 10 illustrates how the logical model maps to the data model. Customer object  1002  maps to the cust_table table  1004  in the DB2db01 data store  1012 , and has its instances stored as rows there. Order object  1006  mapes to the order_table table  1008  in the Oracledb01 data store  1014 , and has its instance data stored as rows there. The association between the Customer  1002  and Order  1006  objects is represented by instances in the OrderPlacedBy$ table  1010  in the DB2db01 data store  1012 .  
         [0066]    [0066]FIG. 11 presents an example of an aggregation that shows a foreign key. The OrderItem object  1102  is aggregated by the Order object  1104 . As in UML terminology, this means that instances of OrderItems are contained by Orders, or an Order is made up of OrderItems. This requires some way to map OrderItems to Orders, and in this case it is achieved through using a foreign key to Orders in the table representing OrderItems instances. This can be seen as a “foreignKey” element within the “elementType” element with an ID of “partOf” that represents the “partOf” association.  
                                                                                                                                                                                                                                                                                                   &lt;CreateDefinition&gt;                &lt;schema name=“OrderItem”&gt;                &lt;elementType from=“Order” id=“Order.orderID”           is=“property”&gt;                &lt;description&gt;Unique Order ID           &lt;/description&gt;           &lt;dataType dc=“sequencenumber” dt=“int”/&gt;                &lt;/elementType&gt;           &lt;elementType id=“ItemID” is=“property”           persistentname=“Item                ID”&gt;           &lt;description&gt;Unique Item ID&lt;/description&gt;           &lt;dataType dt=“int”/&gt;           &lt;label locale=“ENUS”&gt;Item ID&lt;/label&gt;                &lt;/elementType&gt;           &lt;elementType id=“Name” is=“property”           persistentname=“Name”                &gt;                &lt;description&gt;Name&lt;/description&gt;           &lt;dataType dt=“string” maxlength=“50”/&gt;           &lt;label locale=“ENUS”&gt;Name&lt;/label&gt;                &lt;/elementType&gt;           &lt;elementType id = “UnitPrice” is=“pr perty”           persistentname=“Uni                tPrice”&gt;           &lt;description&gt;Price per Unit&lt;/description&gt;                &lt;dataType dt=“r8”/&gt;           &lt;label locale=“ENUS”&gt;Unit Price&lt;/label&gt;                &lt;/elementType&gt;           &lt;elementType id=“numItems” is=“property”           persistentname=“nu                mItems”&gt;           &lt;description&gt;Number of Items Ordered&lt;/description&gt;           &lt;dataType dt=“int”/&gt;           &lt;label locale=“ENUS”&gt;Number Ordered&lt;/label&gt;                &lt;/elementType&gt;           &lt;elementType id=“partOf” is=“relationship” type=“parent”&gt;                &lt;foreignKey range=“Order”&gt;                &lt;Key original=“id”           persitentname=“OrderorderID$”/&gt;                &lt;/foreignKey&gt;                &lt;/elementType&gt;           &lt;elementType id=“Order” is=“relationship” type= “aggregation”                &gt;           &lt;element id=“has” occurs=“ZEROORMORE”           type=“OrderIte           m”/&gt;                &lt;/elementType&gt;           &lt;elementType id=“OrderItem” is=“entity”           type=“aggregation” vi                rtual=“1”&gt;           &lt;entity type=“Order”/&gt;           &lt;description&gt;OrderItem&lt;/description&gt;           &lt;element occurs=“REQUIRED” type=“ItemID”/&gt;           &lt;element occurs=“REQUIRED” type=“Name”/&gt;           &lt;element occurs=“REQUIRED” type=“UnitPrice”/&gt;           &lt;element occurs=“REQUIRED” type=“numItems”/&gt;           &lt;element occurs=“OPTIONAL” type=“partOf”/&gt;           &lt;key id=“OrderItem” type=“PRIMARY”&gt;                &lt;keyPart href=“Order.orderID”/&gt;           &lt;keyPart href=“ItemID”/&gt;                &lt;/key&gt;           &lt;label locale=“ENUS”&gt;OrderItem&lt;/label&gt;           &lt;datasource&gt;jdbc/Oracledb02&lt;/datasource&gt;           &lt;dbschema&gt;OrderSysSchema&lt;/dbschema&gt;                &lt;/elementType&gt;           &lt;ancestors/&gt;           &lt;descendents/&gt;                &lt;/schema&gt;            &lt;/CreateDefinition&gt;                  
 
         [0067]    Internal Design Repository  
         [0068]    Once the schema is submitted for an entity or association either manually or through Auto Discovery Engine  704 , it is then stored in the Internal Design Repository  710  for use when constructing create, read, update and delete statements. In one embodiment, this data store can simply be XML representations such as those described above. In alternative embodiments, it is possible to store this information in database tables and cache some of it at run time. Those of skill in the art will appreciate that this XML schema is translatable to information in database tables for faster access.  
         [0069]    Schema Modification Examples  
         [0070]    The following are some examples of schema modification operations. The deletion of a schema removes that schema form the Internal Design Repository  710 . Manual schema update operations result in the modification of the schema in the Internal Design Repository  710  as well as the execution of the appropriate Data Definition Language (DDL) calls on the data store  708  where the entity instance data is stored. These DDL calls are generally SQL “ALTER TABLE” statements. One embodiment of the invention does not drop the physical tables in a data store when an entity definition is deleted. This is to prevent critical data from being lost by accident; deleting the schema definition from the repository essentially makes the system “forget” about the data. If desired, the physical tables can subsequently be removed manually.  
         [0071]    In one embodiment, the general syntax to delete an entity definition schema is as follows:  
                                                                                           &lt;DeleteEntityDefinition&gt;                &lt;entity&gt;                entity-name                &lt;/entity&gt;                &lt;/DeleteEntityDefinition&gt;                      
 
         [0072]    This results in the Schema XML representing the entity “entity-name” being removed from the Internal Design Repository  710  along with any association Schema representing associations to or from that entity. The general syntax to modify an entity definition schema is:  
                                                                                                                                                                                                                                   &lt;UpdateEntityDefinition&gt;                &lt;schema name=“entity-name”&gt;                &lt;!-- elementType block declaring parent --&gt;           &lt;!-- required for derived entity definitions --&gt;           &lt;elementType id=“parent-entity” is=“entity”/&gt;           &lt;!-- relationship block --&gt;           &lt;!-- required for aggregate entity definitions --&gt;           &lt;elementType id=“parent-entity” type=“aggregation”           is=“relationship”&gt;                &lt;element id=“aggregate-from-parent-role”                type=“aggregate-entity”           occurs=“aggregate-from-parent-cardinality”/&gt;                &lt;/elementType&gt;           &lt;!-- property block -- 1 per property --&gt;           &lt;elementType id=“property-name” is=“property”&gt;                &lt;description&gt;field-name&lt;/description&gt;           &lt;lexicon/&gt;           &lt;string/&gt;           &lt;dataType dt=“string”           maxlength=“integer-value”/&gt;           &lt;!-- additional blocks, depending on           property type --&gt;                &lt;/elementType&gt;                .           .           .                &lt;!-- entity block -- 1 required --&gt;           &lt;elementType id=“entity-name” is=“entity”           action=“MODIFY”&gt;                &lt;description&gt;descriptive text&lt;/description&gt;           &lt;element type=“property-name”           occurs=“cardinality”            action=[add|modify|remove]/&gt;                . . . &lt;!-- additional element blocks --&gt;                &lt;key id=“key-name” type=“key-type”&gt;                &lt;keyPart href=“property-name”/&gt;                . . . &lt;!-- additional keyPart           blocks --&gt;                &lt;/key&gt;                . . . &lt;!-- additional key blocks --&gt;                &lt;/elementType&gt;                &lt;/schema&gt;            &lt;/UpdateEntityDefinition&gt;                  
 
         [0073]    Examples of modifications to the Entity schema definitions are detailed below.  
         [0074]    The following is an example of how to add a “title” property to a “Customer” entity in accordance with one embodiment of the present invention:  
                                                                                                               &lt;UpdateEntityDefinition&gt;                &lt;schema name=“Customer” timecached=“”&gt;                &lt;elementType id=“title” is=“property” persistentname=“title”&gt;                &lt;dataType dt=“string” maxlength=“10”/&gt;           &lt;description&gt;title&lt;/description&gt;           &lt;label locale=“ENUS”&gt;title&lt;/label&gt;                &lt;/elementType&gt;           &lt;elementType id=“Customer” is=“entity”           virtual=“1” action=“MO                DIFY”&gt;           &lt;element type=“title” occurs=“OPTIONAL”           action=“ADD”/&gt;                &lt;/elementType&gt;                &lt;/schema&gt;            &lt;/UpdateEntityDefinition&gt;                  
 
         [0075]    The main “entity” element that is the “elementType” block that has the same ID as the entity, (Customer in this case), is the place where modifications will be indicated. In this example, there is an “element” with the “type” of title that has an action “ADD”. This refers to the elementType that describes the title property and indicates that it should be added to the Schema XML in the Internal Design Repository  710 . Once the system updates the internal design repository, it emits a SQL “ALTER TABLE ADD COLUMN” command to the data stores that contains the physical table for the entity.  
         [0076]    The following is an example of how to add increase the maximum length of the “title” property in accordance with one embodiment of the present invention:  
                                                                                                                                       &lt;SilkDataObjects_EntityDefinition_Set&gt;                &lt;schema name=“Customer” timecached=“”&gt;                &lt;elementType id=“title” is=“property”           persistentname=“title”&gt;                &lt;description&gt;title&lt;/description&gt;           &lt;dataType dt=“string” maxlength=“25” /&gt;           &lt;label locale=“ENUS”&gt;title&lt;/label&gt;                &lt;/elementType&gt;           &lt;elementType id =“Customer” is=“entity” virtual=“1”           action=“MO                DIFY”&gt;                &lt;element occurs=“OPTIONAL” type=“title”           action =“MODIFY”                /&gt;                &lt;/elementType&gt;                &lt;/schema&gt;                &lt;/SilkDataObjects_EntityDefinition_Set&gt;                      
 
         [0077]    The main entity block in this example has an “element” with the “type” of title that has the action “MODIFY”. This refers to the elementType that describes the title property and indicates that it should be modified in the Schema XML in the Internal Design Repository  710 . The Schema will be updated with this definition of the title property. Once the design repository has been updated, the system will emit a SQL “ALTER TABLE” statement to change the length of the table column that represents the property.  
         [0078]    The following is an example of how to remove the “title” property from the “Customer” entity in accordance with one embodiment of the present invention:  
                                                                                                                                       &lt;SilkDataObjects_EntityDefinition_Set&gt;                &lt;schema name=“Customer” action=“REBUILD”&gt;                &lt;elementType id=“title” is=“property”           persistentname=“title”&gt;                &lt;description&gt;title&lt;/description&gt;           &lt;lexicon/&gt;           &lt;string/&gt;           &lt;dataType dt=“string” maxlength=“25”/&gt;           &lt;label locale=“ENUS”&gt;title&lt;/label&gt;                &lt;/elementType&gt;           &lt;elementType id=“Customer” is=“entity” virtual=“1”           action=“MO                DIFY”&gt;                &lt;element occurs=“OPTIONAL” type=“title”           action=“REMOVE                ”/&gt;                &lt;/elementType&gt;                &lt;/schema&gt;           &lt;alter_database&gt;1&lt;/alter_database&gt;                &lt;/SilkDataObjects_EntityDefinition_Set&gt;                      
 
         [0079]    The main entity block in this example has an “element” with the “type” of title that has the action “REMOVE”. This refers to the elementType that describes the title property and indicates that it should be removed from the Schema XML in the Internal Design Repository  710 . The Schema will be updated with the title property removed.  
         [0080]    In the above example, the REBUILD action is optionally used to indicate whether to affect the table or just the schema. Without the REBUILD action the Schema in the Internal Design Repository  710  will be updated but nothing will be done to the underlying table representing the Customer entity in the DB2db01 data store. Thus the data in the table will be unaffected and the deleted column will remain in the data store but the system will ignore the existence of the column. If the REBUILD action is set then system  700  will emit a SQL “ALTER TABLE” statement that will remove the column from the table representing the Customer entity so that the data store matches the Internal Design Repository  710 .  
         [0081]    Database Abstraction  
         [0082]    To access data stored in data objects, a client  706  creates queries that use property sets, filters, and views. The client  706  can specify these query components dynamically or create stored definitions to preserve particular queries.  
         [0083]    To generate database specific SQL statements, system  700  uses Database Abstraction layer (the DBAbstraction)  712 . To use the DBAbstraction  712  to generate an SQL INSERT statement, a combination of a SQLInsert and zero or more SQLColumn objects is used to construct the object representation of the INSERT statement. The SQLInsert is then passed into the SQLBridge object created with the database connection acquired from the database associated with the specified entity. The SQLBridge then generates the syntactically correct INSERT statement for that database.  
         [0084]    To generate a SQL UPDATE or a SQL DELETE statement, the DBAbstraction is used in an analogous manner. Instead of constructing a SQLInsert, a SQLUpdate or a SQLDelete is constructed instead. In addition, a SQLWhere can be used to add a WHERE clause to the SQL.  
         [0085]    Once the model is created, the entities can be used. As an example, an instance of a Customer entity can be created in a preferred embodiment with the following request:  
                                                                                           &lt;CreateInstance&gt;                &lt;Customer&gt;                &lt;id&gt;dmatrix&lt;/id&gt;           &lt;firstName&gt;Dot&lt;/firstName&gt;           &lt;lastName&gt;Matrix&lt;/lastName&gt;           &lt;age&gt;45&lt;/age&gt;                &lt;/Customer&gt;                &lt;/CreateInstance&gt;                      
 
         [0086]    From this request, system  700  can determine that the request is to create an instance of the Customer entity. By traversing the request XML, system  700  can see that the request is to create an instance of the Customer entity and values are supplied for the id, firstName, lastName, and age properties. From the Internal Design Repository  710  (see the schema XML for Customer, above), it can be determined that the types for the ID, firstName, lastName, and age properties are string, string, string, and int, respectively. These data types and values can be used to create SQLColumn objects that will be added to a SQLInsert Object. The SQLBridge portion of the DBAbstraction  712  will then translate the SQLInsert object to the appropriate SQL statement for the DB2db01 data store that is indicated in the Customer schema. For the described embodiment, an example of the SQL is:  
         [0087]    INSERT INTO cust_table(id, firstName, lastName, age)  
         [0088]    VALUES(‘dmatrix’,‘Dot’,‘Matrix’, 45)  
         [0089]    The general format for a “CreateInstance” call in a preferred embodiment is:  
                                                                                                                                                 &lt;CreateInstance&gt;                &lt;entity-name&gt;                &lt;element-name&gt;element-value&lt;/element-name&gt;                .           .           .                &lt;relationship-name&gt;                &lt;entity-name&gt;                &lt;element-name&gt;element-value&lt;/element-name&gt;                .           .           .                &lt;/entity-name&gt;                &lt;/relationship-name&gt;                &lt;/entity-name&gt;           &lt;relatedKeys&gt;0|1&lt;/relatedKeys&gt;                &lt;/CreateInstance&gt;                      
 
         [0090]    Since there is an instance of a Customer, it is possible to create an Order that was placed by that Customer, and the request will look like:  
                                                                                                                                   &lt;CreateInstance&gt;                &lt;Order&gt;                &lt;orderDate&gt;2003-6-17TO:0:0&lt;/orderDate&gt;           &lt;total&gt;3.1415&lt;/total&gt;           &lt;comments&gt;An Order of Pi&lt;/comments&gt;           &lt;placedBy&gt;                &lt;Customer.Key&gt;                &lt;id&gt;dmatrix&lt;/id&gt;                &lt;/Customer.Key&gt;                &lt;/placedBy&gt;                &lt;/Order&gt;                &lt;/CreateInstance&gt;                      
 
         [0091]    The system can see that this is a request to create an instance of an Order, and from the associated schema can also ascertain that this is creating an instance of the “placedBy” association which is from Order to Customer. The schema indicates that the Order data is stored in the OracleDB02 data store and the association data is stored in the DB2db01 data store. Using the schema and with the aid of the DBAbstraction  712 , two SQL statements are constructed and executed against the two data stores. In a preferred embodiment, they are:  
         [0092]    The Order in data store Oracledb02:  
         [0093]    INSERT INTO order_table(orderID, orderDate, total)  
         [0094]    VALUES(1, 2003-6-17, 3.1415)  
         [0095]    The association in data store DB2db01:  
         [0096]    INSERT INTO orderplacedBy$(placedByorderorderID$, placesCustomerid$) VALUES(1, dmatrix)  
         [0097]    An example of the recursive nature of the algorithm is:  
                                                                                                                                             &lt;CreateInstance&gt;                &lt;Customer&gt;                &lt;id&gt;jdoe&lt;/id&gt;           &lt;firstName&gt;John&lt;/firstName&gt;           &lt;lastName&gt;Doe&lt;/lastName&gt;           &lt;age&gt;35&lt;/age&gt;                &lt;places entity=“Order” action=“add”&gt;                &lt;Order&gt;                &lt;orderDate&gt;2003-6-18TO:0:0&lt;/orderDate&gt;           &lt;total&gt;55.60&lt;/total&gt;           &lt;comments&gt;Some Stuff&lt;/comments&gt;                &lt;/Order&gt;                &lt;/places&gt;                &lt;/Customer&gt;                &lt;/CreateInstance&gt;                      
 
         [0098]    In general, and referring now to FIG. 12, an algorithm for creating instances is as follows—specifics for the example above appear in parentheses:  
         [0099]    1. Identify  1202  the outer most entity using the outer tag name. (Customer).  
         [0100]    2. Identify  1204  the properties and their values by iterating through the child XML elements (id=j doe, firs tName=john, lastName=Doe, age=35)  
         [0101]    3. Retrieve  1206  the datatypes and column names for the properties from the Internal DataStore. (id=string:id firstName=string:firstname, lastName=strig:lastName, age=int:age)  
         [0102]    4. Create  1208  a SQLInsert object.  
         [0103]    5. Create  1210  a SQLColumn object for each property, supplying the column name, data type, and value for each (shown in #2 and #3) and add them to the SQLInsert object.  
         [0104]    6. Get  1212  the data store information from the schema (DB2db01 for Customer) and obtain a connection to the data store.  
         [0105]    7. Construct  1214  a SQLBridge object using the data store  
         [0106]    8. Pass  1216  the SQLInsert to the SQLBridge to generate the appropriate SQL statement for the data store.  
         [0107]    9. Execute  1218  the SQL statement and store the primary key for the new instance created, retrieving any auto generated values.  
         [0108]    10. For each child XML element that is an association rather than a property  1220  (the places element)  
         [0109]    a. Identify the entity that an instance will be created for (Order)  
         [0110]    b. Repeat steps 2-9. (Insert an Order)  
         [0111]    c. Use the keys from the outer insert and this inner insert to correctly insert the association using the association table or appropriate foreign key column indicated by the schema for the association.  
         [0112]    d. Repeat step 10  
         [0113]    The SQL statements generated for this example would be:  
         [0114]    The Order in Oracledb02:  
         [0115]    INSERT INTO cust_table(id, firstName, lastName, age)  
         [0116]    VALUES(‘jdoe’,‘John’,‘Doe’, 35)  
         [0117]    The Order in Oracledb02:  
         [0118]    INSERT INTO order_table(orderID, orderDate, total)  
         [0119]    VALUES(4, 2003-6-18, 55.60)  
         [0120]    The association in DB2db01:  
         [0121]    INSERT INTO OrderplacedBy$(placedByorderorderID$, placescustomerid$) VALUES(4, jdoe)  
         [0122]    The same basic algorithm applies for update and delete commands, only SQLUpdate and SQLdelete objects are used instead of SQLInsert.  
         [0123]    The syntax for the update and delete commands for instances may be, for example:  
                                                                                                                                                                                                           &lt;UpdateInstance&gt;                &lt;entity-name&gt;                &lt;property-name action=[ADD|REPLACE|REMOVE]&gt;           element-value&lt;/property-            name&gt;                .           .           .                &lt;relationship-name action= [ADD|REMOVE] &gt;                &lt;entity-name.Key&gt;                &lt;property-name&gt;element-value&lt;/property-name&gt;                &lt;/entity-name.Key&gt;                &lt;/relationship-name&gt;                &lt;/entity-name&gt;           &lt;entity-name.Key&gt;                &lt;property-name&gt;key-value&lt;/property-name&gt;                .           .           .                &lt;/entity-name.Key&gt;           &lt;relatedKeys&gt;0|1&lt;relatedKeys&gt;            &lt;/UpdateInstance&gt;       &lt;DeleteInstance&gt;                &lt;entity&gt;entity-name&lt;/entity&gt;           &lt;entity-name.Key&gt;                &lt;instance-name&gt;instance-value&lt;/instance-name&gt;                &lt;/entity-name.Key&gt;            &lt;/DeleteInstance&gt;                  
 
         [0124]    Query Example:  
         [0125]    At run time, a user of client workstation  706  wishes to access objects stored in multiple data stores  708 . The Database Abstraction  712  generates properly formed SQL using the following steps according to one embodiment. First, a connection to the datasource is acquired, and this connection is passed on to the abstraction object SQLBridge. The abstraction queries the connection to determine the database vendor and version. The abstraction then uses this information to load into the SQLBridge object database/version specific XML containing the syntactical differences of that database that differ from the SQL92 standard. The application will use the abstraction to create objects specific to the operation desired. For example, if a SELECT operation is required, an SQLCommand object is created. This object is then composed of an SQLSelect object, an SQLFrom object an optional SQLWhere object, an optional SQLOrderBy object and an optional SQLGroupBy object. The combination of these objects defines the generic behavior expected by the application for a Select operation. The application then requests a syntactically correct SQL command from the SQLBridge object by passing the SQLCommand object into the SQLBridge object. The SQLBridge object will then be able to apply the database specific differences to the SQL command as it generates the correct SQL based on the expected behavior defined in the SQLCommand object. Once the SQLBridge has generated the syntactically correct SQL command it will then be executed on the connection associated with that database/datasource. Any new databases can have their syntactical differences defined in the database abstraction XML. That XML will be loaded the first time the application passes a connection from that datasource to the SQLBridge object. This greatly simplifies the normally code intensive task of maintaining compliance with multiple different databases in the same code base.  
         [0126]    To access data stored in data objects, a client  706  creates queries that use property sets, filters, and views. The client  706  can specify these query components dynamically or create stored definitions to preserve particular queries.  
         [0127]    The XML for a query includes in a preferred embodiment a “propertyset” and a filter. The propertyset identifies the properties that should be returned as the results of the query and the filter specifies the constraints to place on the results as in a SQL WHERE clause.  
         [0128]    For example, the following query retrieves the first name and last name of the customer in a preferred embodiment, as well as the order information for that customer if the customer&#39;s ID is “dmatrix”, and if there are any orders with a total greater than “$5.00” or an order date greater than or equal to “2003-6-17T0:0:0”.  
         [0129]    Since the entities are in two different data stores, multiple SQL statements will be executed to get the appropriate data, then the data will be combined and returned.  
                                                                                                                                                                                                                                                     &lt;QueryInstances&gt;                &lt;query entity=“Customer” id=“AdHocView”&gt;                &lt;propertyset entity=“Customer” id=“adHoc”&gt;                &lt;property id=“firstName” /&gt;                &lt;property id=“lastName” /&gt;           &lt;property entity =“Order” id=“places”&gt;                &lt;property id=“orderDate” /&gt;           &lt;property id=“total” /&gt;                &lt;/property&gt;                &lt;/propertyset&gt;           &lt;filter entity=“Customer” id=“AdhocFilter”&gt;                &lt;conditions required=“ALL”&gt;                &lt;property id=“id” operator=“EQ”           value=“dmatrix”                /&gt;                &lt;/conditions&gt;           &lt;property entity=“Order” id=“places”                joinType=“INNER”&gt;           &lt;conditions required=“1 OR 2”&gt;                &lt;property id=“total” operator=“GT”                value=“5.00” /&gt;                &lt;property id=“orderDate”           operator=“GE”                value=“2003-6-17” /&gt;                &lt;/conditions&gt;                &lt;/property&gt;                &lt;/filter&gt;                &lt;/query&gt;                &lt;/QueryInstances&gt;                      
 
         [0130]    As with the insert algorithm described above, the algorithm for processing the query XML is also recursive. The above query will be used to illustrate the algorithm.  
         [0131]    1. Merge the properties from the filter into the propertyset to create a single propertyset. Any associations traversed in the propertyset will default to LEFT OUTER joins unless overridden in the propertyset or the filter. Associations traversed in the filter will default to INNER joins.  
                                                                                                               &lt;propertyset entity=“Customer” id=“adHoc” required=“ALL”&gt;                &lt;property id=“firstName” /&gt;           &lt;property id=“lastName” /&gt;           &lt;property id=“id” operator=“EQ” value=“dmatrix”/&gt;           &lt;property entity=“Order” id=“places” joinType=“INNER”                required=“1 OR 2”&gt;                &lt;property id=“orderDate” /&gt;           &lt;property id=“total” /&gt;           &lt;property id=“total” operator=“GT” value=“5.00” /&gt;           &lt;property id=“orderDate” operator=“GE”                value=“2003-6-17” /&gt;                &lt;/property&gt;                &lt;/propertyset&gt;                      
 
         [0132]    2. Begin by setting the “current XML position” indicator to the outer propertyset element.  
         [0133]    3. Begin maintaining an array of SQL statements, which include SELECT, FROM, and WHERE portions and create the first empty SQL statement in position 0.  
         [0134]    4. Initialize a variable to 0 that indicates the “working SQL statement”.  
         [0135]    5. Get the name of the starting entity from the current XML position (Customer) and get the data store (DB2db01) and table name (cust_table) from the schema in the Internal Design Repository  710 . Make note of the data store and add the table name to the FROM portion of the working SQL statement.  
         [0136]    (FROM cust_table)  
         [0137]    6. Get the primary key columns for the entity form the schema and add them to the SELECT portion of the SQL statement for use when merging SQL statements.  
         [0138]    (SELECT Customer$1.id)  
         [0139]    7. Add a unique alias to the table name using the entity name:  
         [0140]    (FROM cust_table Customer$1)  
         [0141]    8. Iterate through all of the property elements that do not represent associations and are not part of the filter (indicated by an “operator” attribute) and for each:  
         [0142]    a. Use the property name to lookup the column name from the schema for the entity.  
         [0143]    b. Add the column to the SELECT portion of the working SQL statement.  
         [0144]    (SELECT Customer$1.id ,Customer$1.firstName, Customer$1.lastName  
         [0145]    FROM cust_table Customer$1)  
         [0146]    9. Get the value of the “required” attribute from the current XML position (set in #2)—this will indicate how to combine the conditions in the WHERE clause:  
         [0147]    ALL: indicates use “AND” between all conditions.  
         [0148]    ANY: indicates use “OR” between all conditions.  
         [0149]    The other option is a complex condition that refers to the property conditions by number like “(1 OR 2) AND (3 OR 4)” 
         [0150]    10. Begin maintaining a WHERE clause array.  
         [0151]    11. Iterate through all of the property elements from the filter (indicated by an “operator” attribute) and for each  
         [0152]    a. Use the property name to lookup the data type and column name from the schema.  
         [0153]    b. Get the operator and value attributes and combine them with the column name to construct a condition for the WHERE clause. Add this to the WHERE clause array. The array in this case will be:  
         [0154]    0: Customer$1.id=‘dmatrix&#39; 
         [0155]    12. Using the value of the required attribute and the conditions in the WHERE clause array, add the conditions to the WHERE clause of the working SQL statement:  
                                                                       (SELECT Customer$1.id,Customer$1.firstName,                Customer$1.lastName                FROM cust_table Customer$1           WHERE Customer$1.id=‘dmatrix’)                      
 
         [0156]    13. Iterate through all of the property elements that represent associations and for each:  
         [0157]    a. Get the association schema from the Internal Design Repository.  
         [0158]    b. Get the “joinType” attribute value from the element and add the join to the FROM portion of the working SQL statement  
                                                                                                               (SELECT Customer$1.id,Customer$1.firstName,                Customer$1.lastName                FROM cust_table Customer$1                INNER JOIN OrderplacedBy$ Order$placedBy$1 ON                (Customer$1.id =                Order$placedBy$1.placesCustomerid$)                WHERE Customer$1.id =‘dmatrix’)                      
 
         [0159]    c. Get the name of the entity on the other side of the association using the “entity” attribute of the property element or from the association schema. (Order)  
         [0160]    d. Set the “current XML position” to this association property element  
         [0161]    e. Get the name of the data store from the schema for the associated entity. (OracleDB02)  
         [0162]    f. If the data store is the same as the previous entities data store then and proceed from step #5 above. (not the case in this example)  
         [0163]    g. Else if the data store is different than the previous entity then add a new SQL statement to the array of SQL statements, store the fact that this SQL statement is a sub-query to the current “working SQL statement” (0 in this case), then increment the variable that indicates the “working SQL statement”, and now proceed from step #5 above.  
         [0164]    14. One completed, there will be an array of SQL statements with some of the statements being sub-queries to previous statements. The statements are preferably executed in order, and when data store boundaries are traversed the parent statement should select the foreign keys from the association table and then merge them into the WHERE clause for the sub-statements. Then the sub-statement results can be merged with the parent statement results using the primary key values from the instances and the association instances.  
         [0165]    The array for this example looks as follows in a preferred embodiment:  
                                                                                                                                               0:                SELECT            Customer$1.id,Customer$1.firstName,Customer$1.lastName,                Order$placedBy$1.placedByOrderorderID$                FROM cust_table Customer$1                INNER JOIN OrderplacedBy$ Order$placedBy$1 ON            (Customer$1.id =                Order$placedBy$1.placesCustomerid$)                WHERE (Customer$1.id = ‘dmatrix’)            1: &lt;sub-query to 0&gt;                SELECT Order$1.orderID,Order$1.orderDate,Order$1.total           FROM order_table Order$1           WHERE Order$1.total &gt; 5.00                OR Order$1.orderDate &gt;= 2003-06-17                ORDER BY Order$1.id                      
 
         [0166]    The results of the first query will be:  
                                                               dmatrix   Dot   Matrix   1           dmatrix   Dot   Matrix   2           dmatrix   Dot   Matrix   3                      
 
         [0167]    The foreign keys to Order Will then be added to the sub-SQL statement for Orders as follows:  
                                                                                           SELECT Order$1.orderID,Order$1.orderDate,Order$1.total           FROM order_table Order$1           WHERE ( Order$1.total &gt; 5.00                OR Order$1.orderDate &gt;= 2003-06-17)                AND ( Order$1.ordered = 1 OR Order$1.ordered = 2 OR                Order$1.ordered = 3)                ORDER BY Order$1.id                      
 
         [0168]    The results will be:  
                                                           2   2003-06-20   75.25           3   2003-06-18   3.1415                      
 
         [0169]    These results will be merged with the previous results using an “INNER JOIN” type mechanism as indicated in the query, therefore since Order #1 did not meet the Order criteria the Customer row containing that order will be removed. The combined results will be:  
                                                                       dmatrix   Dot   Matrix   2   2003-06-20   75.25           dmatrix   Dot   Matrix   3   2003-06-18   3.1415                      
 
         [0170]    The result will then be converted to XMl and returned as follows:  
                                                                                                                                                                                                                                 &lt;view id=“AdHocView” entity=“Customer”&gt;                &lt;viewitem&gt;                &lt;Customer.Key&gt;                &lt;id&gt;dmatrix&lt;/id&gt;                &lt;/Customer.Key&gt;           &lt;Customer&gt;                &lt;firstName&gt;Dot&lt;/firstName&gt;           &lt;lastName&gt;Matrix&lt;/lastName&gt;           &lt;places&gt;           &lt;Order.Key&gt;                &lt;orderID&gt;2&lt;/orderID&gt;                &lt;/Order.Key&gt;           &lt;Order&gt;                &lt;orderDate&gt;2003-06-20&lt;/orderDate&gt;           &lt;total&gt;75.25&lt;/total&gt;                &lt;/Order&gt;                &lt;/places&gt;           &lt;places&gt;                &lt;Order.Key&gt;                &lt;orderID&gt;3&lt;/orderID&gt;                &lt;/Order.Key&gt;           &lt;Order&gt;                &lt;orderDate&gt;2003-06-18&lt;/orderDate&gt;           &lt;total&gt;3.1415&lt;/total&gt;                &lt;/Order&gt;                &lt;/places&gt;                &lt;/Customer&gt;                &lt;/viewitem&gt;                &lt;/view&gt;                      
 
         [0171]    Responding to Data Store Schema Changes  
         [0172]    Since system  700  allows data to be manipulated across multiple data stores  708 , it is important to be able to automatically react to schema changes in these data stores. Referring to the previous example, if additional columns were added to the order_table table in the Oracle database (presumably by the party responsible for this database and application), system  700  can detect these new columns in the data store schema and add them to the object model implemented by the invention.  
         [0173]    As noted above, system  700  includes a Synchronizer module  716  that synchronizes the object model repository with any changes in the schemas of the underlying data stores. The Synchronizer  716  can preferably be invoked in a number of ways: manually or periodically by an automatic program (e.g. daily). Once invoked, the Synchronizer  716  calls the Auto Discovery Engine  704  on the tables in each data store  708 , which returns schema definitions for each table. (See the earlier description of the Auto Discovery Engine  704  for examples of these schema definitions.) Then the Synchronizer  716  determines the set of differences between the schema definitions in the Internal Design Repository  710  and the schema definitions produced by Auto Discovery Engine  704 . We do not describe the algorithm for computing the difference between the schemas; there are several published sources for this algorithm, such as XMLdiff, which is well known in the art.  
         [0174]    Once Synchronizer  716  has the difference sets, it can go about synchronizing the repository schemas with the current schemas in-the data store  708  using the following algorithm. If a property appears in a data store schema but does not appear in the repository schema, then the Synchronizer  716  adds the property to the repository schema. If a property appears in the repository schema but not in the data store schema, then it is removed from the repository schema. Finally, if the property exists in both schemas but the property type is different, the Synchronizer  716  sets the repository&#39;s property type to the new property type. Note that the Synchronizer  716  does not have to change any physical database tables here; the change has already been made before the Synchronizer discovered it.  
         [0175]    In order to handle associations properly, the Synchronizer preferably processes the schemas for all Entities before it processes the schemas for association tables. This allows system  700  to detect the case where the primary key of an Entity has changed so that it is no longer compatible with the foreign key in an association table. The Synchronizer  716  signals an exception to the user in this case.  
         [0176]    Accordingly, using the present invention, it is possible to map objects across multiple types of data stores as described above. Consider the enterprise described above with respect to FIG. 1, in which customer data is stored on customer database  102 , and order data is stored on an SQL server  104 . The customer service agent  114  wants to be able to access order data through the main system. In a preferred embodiment of the invention, the agent  114  can use the user interface provided by the CSR agent&#39;s local client software to select a data source, in this case SQL server  104 , and once the orders table has been brought into the Oracle database  102 , a relationship can be defined between customers in customer database  102  and orders that are not stored in that database. Subsequently, data manipulation can be carried out at the object level by the agent without difficulty, because the entire relationship is viewable and can be manipulated in a single logical view. The present invention enables a client to manipulate a single object, even though the object comprises data from a plurality of data stores. As the object is updated, the updates are translated into updates to the individual objects in the different data stores.  
         [0177]    The present invention has been described in particular detail with respect to a limited number of embodiments. Those of skill in the art will appreciate that the invention may additionally be practiced in other embodiments. First, the particular naming of the components, capitalization of terms, the attributes, data structures, or any other programming or structural aspect is not mandatory or significant, and the mechanisms that implement the invention or its features may have different names, formats, or protocols. Further, the system may be implemented via a combination of hardware and software, as described, or entirely in hardware elements. Also, the particular division of functionality between the various system components described herein is merely exemplary, and not mandatory; functions performed by a single system component may instead be performed by multiple components, and functions performed by multiple components may instead be performed by a single component. For example, the particular functions of the Database Abstraction, Auto Discovery Engine, and so forth may be provided one or more modules.  
         [0178]    Some portions of the above description present the feature of the present invention in terms of algorithms and symbolic representations of operations on information. These algorithmic descriptions and representations are the means used by those skilled in the casino management arts to most effectively convey the substance of their work to others skilled in the art. These operations, while described functionally or logically, are understood to be implemented by computer programs. Furthermore, it has also proven convenient at times, to refer to these arrangements of operations as modules or code devices, without loss of generality.  
         [0179]    It should be borne in mind, however, that all of these and similar terms are to be associated with the appropriate physical quantities and are merely convenient labels applied to these quantities. Unless specifically stated otherwise as apparent from the present discussion, it is appreciated that throughout the description, discussions utilizing terms such as “processing” or “computing” or “calculating” or “determining” or “displaying” or the like, refer to the action and processes of a computer system, or similar electronic computing device, that manipulates and transforms data represented as physical (electronic) quantities within the computer system memories or registers or other such information storage, transmission or display devices.  
         [0180]    Certain aspects of the present invention include process steps and instructions described herein in the form of an algorithm. It should be noted that the process steps and instructions of the present invention could be embodied in software, firmware or hardware, and when embodied in software, could be downloaded to reside on and be operated from different platforms used by real time network operating systems.  
         [0181]    The present invention also relates to an apparatus for performing the operations herein.. This apparatus may be specially constructed for the required purposes, or it may comprise a general-purpose computer selectively activated or reconfigured by a computer program stored in the computer. Such a computer program may be stored in a computer readable storage medium, such as, but is not limited to, any type of disk including floppy disks, optical disks, CD-ROMs, magnetic-optical disks, read-only memories (ROMs), random access memories (RAMs), EPROMs, EEPROMs, magnetic or optical cards, application specific integrated circuits (ASICs), or any type of media suitable for storing electronic instructions, and each coupled to a computer system bus. Furthermore, the computers referred to in the specification may include a single processor or may be architectures employing multiple processor designs for increased computing capability.  
         [0182]    The algorithms and displays presented herein are not inherently related to any particular computer or other apparatus. Various general-purpose systems may also be used with programs in accordance with the teachings herein, or it may prove convenient to construct more specialized apparatus to perform the required method steps. The required structure for a variety of these systems will appear from the description above. In addition, the present invention is not described with reference to any particular programming language. It is appreciated that a variety of programming languages may be used to implement the teachings of the present invention as described herein, and any references to specific languages are provided for disclosure of enablement and best mode of the present invention.  
         [0183]    Finally, it should be noted that the language used in the specification has been principally selected for readability and instructional purposes, and may not have been selected to delineate or circumscribe the inventive subject matter. Accordingly, the disclosure of the present invention is intended to be illustrative, but not limiting, of the scope of the invention.