Abstract:
A system and method that provides for representation of any sophisticated relational database model as a set of automatically when needed generated Java bean objects. The system simplifying relational database development in terms of initial development time and ongoing maintenance without being tied to a particular J2EE technology or database or external service/third-party product. Advantageously the model object mapping code is generated either from DDL or directly from the metadata from a database, or from another source. The system and methods allows for high-performance gains and flexibility via a number of configurable parameters enabling complex primary/foreign key relationships to be modeled. The code generation is vendor specific advantageously allowing specific database vendor SQL hints to be added to generated code to improve performance.

Description:
CROSS-REFERENCE TO RELATED APPLICATION  
       [0001]    This patent application is related to and claims the benefit of Provisional U.S. Patent Application No. 60/471,309 filed May 16, 2003, which application is hereby incorporated herein by reference in its entirety. 
     
    
     
       RESERVATION OF RIGHTS IN COPYRIGHTED MATERIAL  
         [0002]    A portion of the disclosure of this patent document contains material which is subject to copyright protection. The copyright owner has no objection to the facsimile reproduction by anyone of the patent document or the patent disclosure, as it appears in the Patent and Trademark Office patent file or records, but otherwise reserves all copyright rights whatsoever.  
         FIELD OF THE INVENTION  
         [0003]    This invention relates to the field of relational databases, and, more specifically, to a representation of a relational database as a Java Object.  
         BACKGROUND OF THE INVENTION  
         [0004]    Relational databases, in general, comprise a plurality of records related to a common item or “thread.” Such databases are data structures organized into rows and columns, much in the manner of a spread sheet. These databases were originally designed for access from procedural programs and were optimized for such linear programming.  
           [0005]    In modern, object-oriented systems, accessing such relational databases can be challenging. Each object must map the data from the database into a form suitable for its own purpose. Therefore, there is a need in the art to represent relational database tables as objects which have the capability of being “persistable.” 
         SUMMARY OF THE INVENTION  
         [0006]    This problem is solved and a technical advance is achieved in the art by a system and method that provides for the representation of any sophisticated relational database model as a set of automatically generated Java bean objects, including the capabilities of get/set methods, default constructors, serializable compliance, etc. The system simplifying relational database development in terms of initial development time and ongoing maintenance without being tied to a particular J2EE technology or database or external service/third-party product. Each database table is modeled by a Java bean object; and advantageously allows for the modeling of inheritance relationships, order criteria for any child/foreign key relationships, and importantly incremental loading and saving of specific “branches” of a relationship. The incremental operations allows for potential speed improvements as only a partial database model is held as a Java bean without loosing database integrity.  
           [0007]    The mapping takes a bottom-up approach so placing most importance on getting the database model correct, and advantageously the model object mapping code is generated either from DDL (Database Description language) or directly from the metadata from a database, or from another source. The system and methods allows for high-performance gains and flexibility via a number of configurable parameters enabling complex primary/foreign key relationships to be modeled. The code generation is vendor specific advantageously allowing specific database vendor SQL hints to be added to generated code to improve performance. Further more code generation is highly configurable as most methods can be overloaded to decorate functionality if required. The generated object code is separated from the value-added business logic relationships.  
           [0008]    An exemplary embodiment of this invention, called “Business Object Model” (herein “BOM”), provides a table in a relational database that typically effects a subclass from the AbstractBOM class. The BOM also overloads the load and remove public methods for handling child relationships and any of the methods wherein a child relationship needs to be defined (e.g., deleteOwnChildrenBeforeParent). The isinDatabase method is changed to reflect criteria for that BOM already being in the database.  
           [0009]    Each BOM includes a reference to the primary key, which has a one-to-one mapping to a database table entry. Each new BOM created has an associated primary key reference, which conforms to a serializable handle reference. A BOM may be accessed independently from a primary key (as a foreign key relationship). All relationships of this type are defined in a finder definition interface.  
       
    
    
     BRIEF DESCRIPTION OF THE DRAWINGS  
       [0010]    A more complete understanding of this invention may be obtained from a consideration of this specification taken in conjunction with the drawings, in which:  
         [0011]    [0011]FIG. 1 is a Business Object Model Pattern, AbstractBOM, defined according to an exemplary embodiment of this invention;  
         [0012]    [0012]FIG. 2 is exemplary code for a remove method according to an exemplary embodiment of this invention;  
         [0013]    [0013]FIG. 3 is exemplary code for a load method according to an exemplary embodiment of this invention;  
         [0014]    [0014]FIG. 4 is exemplary code for a save method according to an exemplary embodiment of this invention;  
         [0015]    [0015]FIG. 5 is an overview illustration of an Automatic Code Generation Infrastructure according to an exemplary embodiment of this invention, showing the relationship among FIGS. 6-12;  
         [0016]    [0016]FIG. 6 is an exemplary ClassMetaData definition of the Automatic Code Generation Infrastructure of FIG. 5;  
         [0017]    [0017]FIG. 7 is an exemplary OracleClassMetaData definition of the Automatic Code Generation Infrastructure of FIG. 5;  
         [0018]    [0018]FIG. 8 is an exemplary RelationshipManager definition of the Automatic Code Generation Infrastructure of FIG. 5;  
         [0019]    [0019]FIG. 9 is an exemplary JavaSourceGenerator definition of the Automatic Code Generation Infrastructure of FIG. 5;  
         [0020]    [0020]FIG. 10 is an exemplary JavaSourceBuilder and related structures definition of the Automatic Code Generation Infrastructure of FIG. 5;  
         [0021]    [0021]FIG. 11 is an exemplary RelationshipXMLManager definition of the Automatic Code Generation Infrastructure of FIG. 5;  
         [0022]    [0022]FIG. 12 provides exemplary MetaData and ClassRelationshipMetaData definitions of the Automatic Code Generation Infrastructure of FIG. 5;  
         [0023]    [0023]FIG. 13 is a normal example of relationship reference code according to an exemplary embodiment of this invention;  
         [0024]    [0024]FIG. 14 is a foreign key example of relationship reference code according to an exemplary embodiment of this invention;  
         [0025]    [0025]FIG. 15 is an example of optimization hints according to an exemplary embodiment of this invention;  
         [0026]    [0026]FIG. 16 is an example of partition hints according to an aspect of this invention;  
         [0027]    [0027]FIG. 17 is an example of primary key field hints in accordance with another aspect of this invention;  
         [0028]    [0028]FIG. 18 is an example of information for the code generator;  
         [0029]    [0029]FIG. 19 is a template example of generated code;  
         [0030]    [0030]FIG. 20 is an exemplary child relationship code according to an exemplary embodiment of this invention;  
         [0031]    [0031]FIG. 21 is an example of generated code for a child relationship according to an exemplary embodiment of this invention;  
         [0032]    [0032]FIG. 22 is exemplary foreign key finder helper code according to an exemplary embodiment of this invention;  
         [0033]    [0033]FIG. 23 shows an example relationship reference for inheritance;  
         [0034]    [0034]FIG. 24 shows an example of the code automatically generated from this inheritance relationship;  
         [0035]    [0035]FIG. 25 shows how the relational tables map to the object model; and  
         [0036]    [0036]FIGS. 26-28 comprise an exemplary relationship.xml snapshot according to an exemplary embodiment of this invention. 
     
    
     DETAILED DESCRIPTION  
       [0037]    All methods and classes are shown herein in bold font in this disclosure.  
         [0038]    Class Synopsis  
         [0039]    Turning now to FIG. 1, a model design of an exemplary Business Object Model (BOM)  100  is shown. For purposes of this exemplary embodiment, BOM  100  uses the Java object-oriented language. The model  100  of FIG. 1 illustrates the typically design pattern for BOM creation in Java. A table in a relational database typically has as a superclass the AbstractBOM class  102  and overloads several public methods, including the public load method  106  and the public remove method  108  for handling child relationships. Further, any of the methods that are child relationship need to be defined in (e.g., deleteOwnChildrenBeforeParent  110 ). The isInDatabase method  112  is changed to reflect criteria for that BOM already being in the database (e.g., optimistic locking via a version or timestamp database field).  
         [0040]    The method setGetMethodsToIgnoreList  104  is an implementation of the ObjectDiff.GetMethodsToIgnore interface, used to filter out methods that do not form part of the criteria for BOM object instance comparisons.  
         [0041]    Each BOM  100  has a reference to the primary key  120 , which is labeled “PrimaryKeyRef”  122  in this exemplary embodiment. PrimaryKeyRef  122  has a one-to-one mapping to a database table entry. Each new BOM  100  created has an associated primary key reference, which conforms to a serializable handle reference. A BOM  100  may also be accessed independently from a primary key (as a foreign key relationship). All relationships of this type should be defined in a finder definition interface (see relationship mapping in the generation code section discussed below in connection with FIGS. 5-12).  
         [0042]    The AbstractBom  102  class encapsulates the requirements of a persistable Java object model. From a client&#39;s perspective there are only two methods that are of interest in terms of transaction control (and object persistence): load method  106  and save method  124 . These methods are defined so that a save  124  updates if already existing in the database, and a load  106  always loads the latest instance of the table data represented as a Java bean. Client code (typically generated code) will overload these methods with the associated child relationships.  
         [0043]    The remove method  108  decides how to remove from a BOM the database. The remove method  108  should be overloaded to remove itself and children. The order is ownership specific, but a typical remove method  108  is illustrated in FIG. 2.  
         [0044]    The load method  106  decides on how to restore a BOM  100  from a database. The load method  106  should be overloaded to load self and children. The order is ownership specific, but a typical load method  106  is illustrated in FIG. 3.  
         [0045]    The save method  124  decides on how to persist a BOM to a database. The save method  124  should be overloaded to save self and children. The order is ownership specific, but a typical save method  124  is illustrated in FIG. 4.  
         [0046]    Transaction Control  
         [0047]    Transaction control is implicit from the database connection passed to a BOM  100 . This is advantageous because control is implicit by the instance of the connection being passed. Transaction control is therefore not part of BOM  100 ; this exemplary embodiment of the BOM is free from any third-party product requirement and is advantageously very light weight.  
         [0048]    Model Design Issues  
         [0049]    SQL is used as the relational to Java object mapping because the database model is best optimized this way rather than having to be created top-down from the BOM model.  
         [0050]    Generated Code  
         [0051]    A further advantage of this invention is automatic generation of BOM code. Automatic code generation is described in connection with FIGS. 5-12. The infrastructure outlined below in connection with FIGS. 5-12 is to enable the creation of Java source code to represent a database table and all its relationships as a Java bean. In all cases the generation is biased towards a bottom up approach. The source for Java bean generation is derived from a database source of some flavor. The current code generation creates a BOM and the entire child associated relationships automatically.  
         [0052]    As a client, a BOM can typically be used “off the shelf.” Only some foreign key relationships may need to be added to a class if such a relationship cannot be defined. For example, generated code will not generate a foreign key relationship where the parent table field name is NOT the same as the child field name.  
         [0053]    Below is a synopsis of key interface/classes and relationship representation. In the following examples, all generated code is prefixed with “Gen,” all table/field names are converted to Camel Case (e.g., AAA_BBB_CCC is be converted to AaaBbbCcc) and all generated BOMS are abstract.  
         [0054]    [0054]FIG. 5 is an overview diagram of the relationship among FIGS. 6-12. Each of FIGS. 6-12 is an enlargement of the relative box or boxes in FIG. 5, so that one skilled in the art may take this diagram and use it as a roadmap to build an automatic code generation infrastructure as shown in FIG. 5.  
         [0055]    Meta Data Relationship Classes  
         [0056]    Turning now to FIG. 6, the abstract class ClassMetaData represents the container for meta data, that is, the data that defines the relationship between a database type and the equivalent Java type. The look-up table defined in this class (s_DBMetaData) is populated with meta-data type relationships for vendor specific conversions, and also for the flavors of transformations required. Typically, this is the only thing a subclass will add to the base class. Currently the product has been implemented for Oracle, so the real implementation handles Java to Oracle type relationships, the class being OracleClassMetaData (FIG. 7).  
         [0057]    s_DBMetaData is a java.util.Hashtable instance, which contains name/value transformation code generation data. The transformation references are defined in four categories outlined below:  
         [0058]    1. Read Data (type converter for Java to database types)  
         [0059]    a. name (string)  
         [0060]    b. Represents the default meta data type held in the database (e.g., number)  
         [0061]    c. value (Java class)  
         [0062]    d. Represent the associated Java class to handle this database type (e.g., Long.class)  
         [0063]    2. Write Data (Java to Database mapping)  
         [0064]    a. name (Java class)  
         [0065]    b. Represents the Java class which requires to be written to the database (e.g., Long.class)  
         [0066]    c. value (string)  
         [0067]    d. Represent the method to be called to write instance out (typically JDBC wrapper) NOT including the value, e.g. “SQLUtil.setLong(ps, index++)” 
         [0068]    3. Read Type Converters (prefix class name with “TypeConverter.”, Database to Java mapping)  
         [0069]    a. name (string)  
         [0070]    b. Represents a fully qualified Java class name which needs type conversion, e.g., “s_TypeConverter+“java.sql.Timestamp”” 
         [0071]    c. value (string)  
         [0072]    d. Represent the method to be called to read instance from (typically JDBC wrapper) NOT including the value, e.g., “SQLUtil.getTimestamp(rs, index++)” 
         [0073]    4. Value added Read Data (prefix class name with “s_TypeReal.” type converter for Java to database types)  
         [0074]    a. name (string)  
         [0075]    b. Represents a fully qualified Java class name which needs type conversion, e.g., “s_TypeReal+ClobMetaData.class.getName( )” 
         [0076]    c. value (Java class)  
         [0077]    d. Represent the associated Java class to handle this reference type (e.g. String.class)  
         [0078]    Normalized Java Meta Data  
         [0079]    The class ClassMetaData (FIG.6) is the main building block. This class represents attributes for generating Java Source Code. The decoration this class requires for relationship automatic code generation is defined via a real implementation of a RelationshipManager (FIG. 8), which this class references.  
         [0080]    Code Generator Sources  
         [0081]    The manager that handles the creation of Java source code from a list of ClassMetaData (FIG. 6) instances will always derive from the abstract base class JavaSourceGenerator (FIG. 9). The way the ClassMetaData (FIG. 6) list is gathered is defined by a concrete subclass. Currently there are two implementations for code generation; both are biased towards Oracle type meta data mappings (i.e. the real implementing class for ClassMetaData (FIG. 6) is an instance of OracleClassMetaData (FIG. 7). One gains its generation information from a source database: OracleJavaSourceGeneratorFromDB (FIG. 9), the other from a SQL script containing DDL: OracleJavaSourceGeneratorFromSQL.  
         [0082]    While the exemplary embodiment of this invention is described for an Oracle implementation, one skilled in the art will appreciate that this invention can be implemented for any JDBC compliant database vendor.  
         [0083]    Any JavaSourceGenerator implementation will create instances of the class MetaData (FIG. 12), as any database table has a name and associated fields: the fields being modeled as a list of MetaData instances holding field name and type (the type gained from the ClassMetaData.getClassFromMetaData method).  
         [0084]    Java Code Generation  
         [0085]    Any type of Java Code generation code will always derive from the abstract base class JavaSourceBuilder FIG. 10.  
         [0086]    Generated Automatic Relationship Management  
         [0087]    Any parent that has children has those associations automatically generated. This means the following methods will be generated automatically with child relationships:  
         [0088]    1. list management auto generated.  
         [0089]    2. load/save/remove updated to include relationships.  
         [0090]    3. finders added to handle child/parent relationships.  
         [0091]    The management interface RelationshipManager (FIG. 8) is currently realized using XML as the relationship mapping tool, via a real implementor class RelationshipXMLManager FIG. 11. Relationships are managed by defining parent/child/foreign key relationships in an XML file (An example may be found below labeled GMDRrelationship.xml, FIGS. 26-28). This holds default relationship values for all children, and specific references.  
         [0092]    The data it holds includes all the standard relationship expected, for instance:  
         [0093]    1. Parent name and associated list of children  
         [0094]    2. For each child, the key fields which map them to the parent(s)  
         [0095]    3. For each child, the multiplicity  
         [0096]    4. For each child, the pre/post condition associated with saving/loading/removing in relation to the parent (e.g., does this child need to be saved before the parent).  
         [0097]    This information is typically available from a database source. However, some relationships cannot be determined or are not required and the source of generation of code may not come from the database. This reason is why this relationship information is maintained as a separate concern from the underling source of table meta-information.  
         [0098]    XML Relationship Tag Description  
         [0099]    The XML Relationship Tag description is defined as:  
         [0100]    1. under the &lt;parent&gt; reference  
         [0101]    a. the parent table  
         [0102]    b. name of the parent  
         [0103]    c. list of children (1 . . . x)  
         [0104]    2. under the &lt;children&gt; reference  
         [0105]    a. name of child table  
         [0106]    b. field (which has relationship with)  
         [0107]    c. multiplicity (×, *, ?)  
         [0108]    d. Save/Remove/Load indicators to determine if save before or after parent, etc.  
         [0109]    Two example relationship references under this closure are defined in FIGS. 13 and 14.  
         [0110]    In XML decoration, as the generated code is typically created in a separate directory package to the real decorator code, any reference in the generated code needs to reference the decorator class, rather than the generated class (it may be decorating a method in the generated class, otherwise the overloaded methods will never be called). To enable this, the &lt;decoration&gt; section is provided which defines, potentially for each table name, the following:  
         [0111]    XML Decoration  
         [0112]    1. under the &lt;decoration&gt; reference  
         [0113]    a. a list of table references (1. . . x)  
         [0114]    2. under the &lt;table&gt; reference  
         [0115]    a. name of table  
         [0116]    b. package where will reside  
         [0117]    c. partition (optional reference to a partition name if table in a partition)  
         [0118]    d. sqlOptimise (option list of name/value pairs representing SQL optimisation hints)  
         [0119]    &lt;/name&gt; 
         [0120]    &lt;value&gt; 
         [0121]    e. assignPKFields (optional list of PK fields which require values assigned against)  
         [0122]    &lt;/name&gt; 
         [0123]    &lt;/value&gt; 
         [0124]    An example of optimization hints under this closure is defined in FIG. 15. An example of partition hints under this closure is defined in FIG. 16. An example of primary key field hints under this closure is defined in FIG. 17. An example decoration reference under this closure is defined in FIG. 18. Note that in all cases “default” is defined if relationship properties are to be used globally under a particular tag context.  
         [0125]    Relationship Code Template  
         [0126]    Turning now to FIG. 19, a generated code template for a parent/child relationship is shown. FIG. 20 defines the parent/child relationship that was used to generate this code. The FLOW and associated children are used as a template example of the generated code produced because of the relationships it defines.  
         [0127]    Child Relationships  
         [0128]    For every child relationship, the following template static method is generated. Typically, a real implementation may override these methods with decoration before calling the base methods.  
         [0129]    1. public static void saveBy&lt;x&gt;(java.util.List &lt;x&gt;, BoMobjectRef parent, Connection con) throws PersistenceException  
         [0130]    2. public static java.util.List findBy&lt;x&gt;(BoMobjectRef parent, Connection con, boolean isoptional) throws PersistenceException  
         [0131]    3. public static void removeBy&lt;x&gt;(BOMObjectRef parent, Connection con) throws PersistenceException  
         [0132]    4. public static java.util.List shallowLoadBy&lt;x&gt;(java.util.List pk, Connection con) throws PersistenceException  
         [0133]    5. public static java.util.List loadBy&lt;x&gt;(java.util.List pk, Connection con) throws PersistenceException  
         [0134]    In points  1  through  5  above, &lt;X&gt; represents the relationship references all concatenated together by “And,” e.g,. xAndyAndz. In this case the relation is via field UNIQUE_FLOW_ID, resulting in &lt;x&gt; being &lt;UniqueFlowId&gt;, i.e., saveByUniqueFlowId, etc. Parent represents the parent object where these relationship references will be gained, e.g., ((Flow) parent).getUniqueFlowId( ) in this case. In this case FLOW is the parent. The isOptional on the findBy method is set to “true” if the relationship is optional (i.e., 0 . . . x multiplicity, for instance). If set to true (i.e., 1 . . . X multiplicity), an exception will be raised if no relationship exists (an empty list).  
         [0135]    Parent Relationships  
         [0136]    For every parent relationship the standard BOM save/load/remove will be decorated with the pre/post conditions for relationship management. Note that updating removes all child relationship references before the update is complete. This will be in the form of calling the methods deleteOwnedChildrenBeforeParent or deleteOwnChildrenAfterParent depending upon the parent/child relationship reference.  
         [0137]    [0137]FIG. 20 show the definition of the partent relationship using the &lt;loadBeforeParent&gt;, &lt;saveBeforeParent&gt; and &lt;removeBeforeParent&gt; tags.  
         [0138]    The example of FIG. 21 show the generated code from the parent relationship defined in FIG. 20. Note here the parent calls the generated static methods already outlined. As the static methods are referenced in relation to the decorated class, this means the class (in this case com.chase.gmdr.app.bom.FlowConfirmation can decorate the methods and then call the generated GenFlowConfirmation).  
         [0139]    Finders and Loaders Template  
         [0140]    In the Finders and Loaders Template, each findBy relationship method follows the EJB convention and returns a list of primary keys representing the BOM under that relationship reference. Each loadBy / shallowLoadBy relationship method expects a list of primary keys as an argument and returns a list of the BOM the PK relationship reference represents.  
         [0141]    Finder Helpers  
         [0142]    For relationships which are not easily generated there are some finder helper interfaces which are defined in the helper class:  
         [0143]    com.chase.gmdr.base.database.SQLFinderUtil.  
         [0144]    This helper class contains the following two interfaces:  
         [0145]    SQLFinderUtil.SQLFinder  
         [0146]    SQLFinderUtil.SQLFinderBuilder  
         [0147]    SQLFinderUtil has helpers for finders, loaders, and update classes. All expect a list of primary keys for database references. An example of their use is defined in FIG. 22.  
         [0148]    Incremental Loading Template  
         [0149]    Loading a bean using the shallowLoad method rather than the load method enables incremental loading of children (if applicable). This means all children (accessed via get . . . ( )) will be loaded automatically. Due to the incremental loading approach the save method will throw an exception is used if the bean is loaded in this way as in this case a partial object representation will be persisted.  
         [0150]    Creation of Inheritance  
         [0151]    Inheritance of tables is managed by subclass references in the code generation. For each table which needs to be subclassed from another table, the subclasses generated code will extend the super class reference. This does mean that a long chain of subclassing can exist if this is how relationships in SQL are defined.  
         [0152]    1. under the &lt;inheritance&gt; reference  
         [0153]    a. name of table  
         [0154]    b. name of class to subclass. This can be a decorated concrete class.  
         [0155]    c. superTable. Name of table that corresponds to the superclass relationship  
         [0156]    [0156]FIG. 23 shows an example relationship reference for inheritance. FIG. 24 shows an example of the code automatically generated from this inheritance relationship. FIG. 25 shows how the relational tables map to the object model.  
         [0157]    Creation of Primary Keys and Utility Classes  
         [0158]    For each table a serializable primary key reference will be created. This is serializable as this handle means a reference to a BOM can be managed remotely (c.f., EJB beans).  
         [0159]    JDBC Code Generated  
         [0160]    All references to JBDC currently use the prepared statement interface. This has the advantage that for continuous usage the server will treat the query as a pseudo-stored procedure  
         [0161]    [0161]FIGS. 26-28 are a GMDR relationship.xml snapshot.  
         [0162]    It is to be understood that the above-described embodiment is merely illustrative of the present invention and that many variations of the above-described embodiment can be devised by one skilled in the art without departing from the scope of the invention. It is therefore intended that such variations be included within the scope of the following claims and their equivalents.