Software framework that facilitates design and implementation of database applications Number:7,412,455 from the United States Patent and Trademark Office (PTO) owispatent An intelligent framework is provided that is disposed between a high-level language environment and a database system environment. According to one embodiment, the framework programmatically receives information regarding definitions of data structures of objects participating in a software application and information regarding relationships among the objects. Based upon the particular request from the high-level language environment and upon the definitions and relationships, the framework programmatically and dynamically generates appropriate statements associated with the database system environment that accomplish the request. For example, the framework may issue statements to define the structure of a database, access information from the database, and/or manipulate information within the database.<H implementation, applications, Software, framew, 7412455.html, Patent, pto, 7412455

Title: Software framework that facilitates design and implementation of database applications

Abstract: An intelligent framework is provided that is disposed between a high-level language environment and a database system environment. According to one embodiment, the framework programmatically receives information regarding definitions of data structures of objects participating in a software application and information regarding relationships among the objects. Based upon the particular request from the high-level language environment and upon the definitions and relationships, the framework programmatically and dynamically generates appropriate statements associated with the database system environment that accomplish the request. For example, the framework may issue statements to define the structure of a database, access information from the database, and/or manipulate information within the database.

Patent Number: 7,412,455 Issued on 08/12/2008 to Dillon

Inventors: Dillon; David M. (Aurora, CO)
Appl. No.: 10/836,580

Filed: April 30, 2004

Related U.S. Patent Documents


Application Number	Filing Date	Patent Number	Issue Date
60466939	Apr., 2003

Current U.S. Class: 707/102 ; 707/100; 707/101

Current International Class: G06F 17/30 (20060101)

Field of Search: 707/2,102

References Cited [Referenced By]

U.S. Patent Documents


5291583	March 1994	Bapat
5297279	March 1994	Bannon et al.
5426780	June 1995	Gerull et al.
5437027	July 1995	Bannon et al.
5615367	March 1997	Bennett et al.
5729739	March 1998	Cantin et al.
5966707	October 1999	Van Huben et al.
6061515	May 2000	Chang et al.
6101502	August 2000	Heubner et al.
6134559	October 2000	Brumme et al.
6163776	December 2000	Periwal
6169993	January 2001	Shutt et al.
6269373	July 2001	Apte et al.
6330006	December 2001	Goodisman
6418451	July 2002	Maimone
6505211	January 2003	Dessloch et al.
6505228	January 2003	Schoening et al.
6631519	October 2003	Nicholson et al.
6754670	June 2004	Lindsay et al.
6999956	February 2006	Mullins
7020641	March 2006	Leong et al.
7058939	June 2006	Berg et al.
7080084	July 2006	Yoshimura et al.
7136872	November 2006	Krishnamurthy et al.
7177878	February 2007	Wason
2002/0120603	August 2002	Thompson
2003/0030672	February 2003	Hughes et al.
2003/0055826	March 2003	Graham
2003/0163460	August 2003	Shinn et al.
2003/0208505	November 2003	Mullins et al.

Primary Examiner: Wong; Don
Assistant Examiner: Brown; Sheree N
Attorney, Agent or Firm: Hamilton, DeSanctis & Cha, LLP

Parent Case Text

This application claims the benefit of Provisional Application No. 60/466,939, filed Apr. 30, 2003, which is hereby incorporated by reference in its entirety.

Claims

What is claimed is:

1. A method of creating a structure of a data store within a storage system comprising: automatically and programmatically receiving from a software application by an intelligent framework coupled between a high-level language environment and the storage system (a) information regarding definitions of a plurality of data structures associated with a plurality of objects participating in the software application, and (b) information regarding relationships among the plurality of data structures, each object of the plurality of objects generated as a result of compilation of the software application by a compiler and representing an instance of a data structure of the plurality of data structures, wherein said programmatically receiving includes interrogating the plurality of objects; based upon the information regarding definitions of the plurality of data structures and the information regarding relationships among the plurality of data structures, programmatically and dynamically generating a data definition expression (DDE) comprising one or more statements to define the structure of the data store inferred by the relationships; and in response to receipt of a request from the software application, the intelligent framework causing the storage system to create the structure of the data store by directing the storage system based on the one or more statements.

2. The method of claim 1, wherein the one or more statements comprise language statements associated with the storage system.

3. The method of claim 1, wherein the information regarding definitions of a plurality of data structures comprises definitions of a plurality of classes that are specified by semantics of a high-level, object-oriented programming language and generated by the compiler.

4. The method of claim 3, wherein the information regarding relationships is implemented as one or more properties of those of the plurality of classes that embody the relationships.

5. The method of claim 3, wherein complex relationships between classes of the plurality of classes are supported, and include one or more of child, parent, peer, children, recursive peer, recursive parent, foreign parent, foreign child, and constant.

6. The method of claim 4, wherein the storage system comprises a relational database management system.

7. The method of claim 2, wherein the language statements comprise Structured Query Language (SQL) data definition language statements.

8. The method of claim 6, wherein within the relational database management system, tables are used to represent the objects participating in the software application.

9. The method of claim 8, wherein each table has a primary key.

10. The method of claim 1, wherein the storage system comprises an extensible markup language (XML) database system.

11. The method of claim 1, wherein the storage system comprises an object-oriented database system.

12. A method of accessing a data store within a storage system comprising: automatically and programmatically receiving from a software application by an intelligent framework coupled between a high-level language environment and the storage system (a) information regarding definitions of a plurality of data structures associated with a plurality of objects participating in the software application, and (b) information regarding relationships among the plurality of data structures, each object of a plurality of objects generated as a result of compilation of the software application by a compiler and representing an instance of a data structure of the plurality of data structures, wherein said programmatically receiving includes interrogating the plurality of objects; in response to receipt of a request from the software application to read an object of the plurality of objects from the data store, programmatically and dynamically generating a data query expression (DQE) comprising one or more statements based at least in part upon the object's relationship with one or more other objects of the plurality of objects; and responsive to the request, the intelligent framework causing the storage system to retrieve information associated with the object from the data store by querying the storage system based on the one or more statements.

13. The method of claim 12, wherein the one or more statements comprise language statements associated with the storage system.

14. The method of claim 12, wherein the information regarding definitions of a plurality of data structures comprises definitions of a plurality of classes that are specified by semantics of a high-level, object-oriented programming language and generated by the compiler.

15. The method of claim 14, wherein the information regarding relationships is implemented as one or more properties of those of the plurality of classes that embody the relationships.

16. The method of claim 14, wherein complex relationships between classes of the plurality of classes are supported, and include one or more of child, parent, peer, children, recursive peer, recursive parent, foreign parent, foreign child, and constant.

17. The method of claim 15, wherein the storage system comprises a relational database management system.

18. The method of claim 13, wherein the language statements comprise Structured Query Language (SQL) data query language statements.

19. The method of claim 17, wherein within the relational database management system, tables are used to represent the objects participating in the software application.

20. The method of claim 19, wherein each table has a primary key.

21. The method of claim 12, wherein the storage system comprises an extensible markup language (XML) database system.

22. The method of claim 12, wherein the storage system comprises an object-oriented database system.

23. A method of manipulating a data store within a storage system comprising: automatically and programmatically receiving from a software application by an intelligent framework coupled between a high-level language environment and the storage system (a) information regarding definitions of a plurality of data structures associated with a plurality of objects participating in the software application, and (b) information regarding relationships among the plurality of data structures, each object of a plurality of objects generated as a result of compilation of the software application by a compiler and representing an instance of a data structure of the plurality of data structures, wherein said programmatically receiving includes interrogating the plurality of objects; in response to receipt of a request from the software application to manipulate an object of the plurality of objects, programmatically and dynamically generating a data manipulation expression (DME) comprising one or more statements based at least in part upon the object's relationship with one or more other objects of the plurality of objects; and responsive to the request, the intelligent framework causing the storage system to manipulate the data store by directing the storage system based on the one or more statements.

24. The method of claim 23, wherein the one or more statements comprise language statements associated with the storage system.

25. The method of claim 23, wherein the information regarding definitions of a plurality of data structures comprises definitions of a plurality of classes that are specified by semantics of a high-level, object-oriented programming language and generated by the compiler.

26. The method of claim 25, wherein the information regarding relationships is implemented as one or more properties of those of the plurality of classes that embody the relationships.

27. The method of claim 25, wherein complex relationships between classes of the plurality of classes are supported, and include one or more of child, parent, peer, children, recursive peer, recursive parent, foreign parent, foreign child, and constant.

28. The method of claim 26, wherein the storage system comprises a relational database management system.

29. The method of claim 24, wherein the language statements comprise Structured Query Language (SQL) data manipulation language statements.

30. The method of claim 28, wherein within the relational database management system, tables are used to represent the objects participating in the software application.

31. The method of claim 30, wherein each table has a primary key.

32. The method of claim 28, wherein the request to manipulate the object of the plurality of objects comprises one of (i) a request to insert the object into the data store; (ii) a request to update the object in the data store; or (iii) a request to delete the object from the data store.

33. The method of claim 23, wherein the storage system comprises an extensible markup language (XML) database system.

34. The method of claim 23, wherein the storage system comprises an object-oriented database system.

35. A method comprising: automatically and programmatically receiving by an intelligent framework coupled between a high-level language environment and a relational database management system information regarding definitions of a plurality of classes associated with a plurality of objects participating in a software application, each class of the plurality of classes containing information regarding its relationships with one or more other classes of the plurality of classes, each object of the plurality of objects generated as a result of compilation of the software application by a compiler and representing an instance of a class of the plurality of classes, wherein said programmatically receiving includes interrogating the plurality of objects; based upon the definitions of the plurality of classes, programmatically and dynamically generating one or more Structured Query Language (SQL) statements associated with the relational database management system, the one or more SQL statements defining the structure of a relational database inferred by the relationships; causing the storage system to create the structure of the relational database by directing the relational database management system based on the one or more SQL statements; in response to receipt of a request to read an object of the plurality of objects from the relational database: programmatically and dynamically generating one or more SQL statements associated with the relational database management system based at least in part upon relationships of the object with one or more other objects of the plurality of objects; and causing the relational database management system to retrieve information associated with the object by querying the relational database management system based on the one or more SQL statements; and in response to receipt of a request to manipulate an object of the plurality of objects: programmatically and dynamically generating one or more SQL statements associated with the relational database management system based at least in part upon relationships of the object with one or more other objects of the plurality of objects; and causing the relational database management system to manipulate the relational database by directing the relational database management system based on the one or more SQL statements.

36. A method of accessing a database within a relational database management system comprising: automatically and programmatically receiving by an intelligent framework coupled between a high-level language environment and the relational database management system (a) information regarding definitions of a plurality of classes specified by semantics of a high-level, object-oriented programming language and generated by a compiler that are associated with a plurality of objects participating in a software application, and (b) information regarding relationships among the plurality of classes, wherein said programmatically receiving includes interrogating the plurality of objects; in response to receipt of a request from the software application to read one or more objects of the plurality of objects from the database, the intelligent framework programmatically and dynamically generating one or more Structured Query Language (SQL) data query language statements based at least in part upon a relationship of an object template associated with the one or more objects with one or more other objects of the plurality of objects and a state of the object template; and the intelligent framework causing the relational database management system to retrieve information associated with the one or more objects by querying the relational database management system based on the one or more SQL data query language statements.

37. The method of claim 1, wherein said interrogating the plurality of objects comprises use of language reflection.

38. The method of claim 12, wherein said interrogating the plurality of objects comprises use of language reflection.

39. The method of claim 23, wherein said interrogating the plurality of objects comprises use of language reflection.

40. The method of claim 35, wherein said interrogating the plurality of objects comprises use of language reflection.

41. The method of claim 36, wherein said interrogating the plurality of objects comprises use of language reflection.

42. An article of manufacture comprising a computer-readable medium having stored thereon instructions, which when executed by one or more processors cause the method of claim 1 to be performed.

43. An article of manufacture comprising a computer-readable medium having stored thereon instructions, which when executed by one or more processors cause the method of claim 12 to be performed.

44. An article of manufacture comprising a computer-readable medium having stored thereon instructions, which when executed by one or more processors cause the method of claim 23 to be performed.

45. An article of manufacture comprising a computer-readable medium having stored thereon instructions, which when executed by one or more processors cause the method of claim 35 to be performed.

Description

COPYRIGHT NOTICE

Contained herein is material that is subject to copyright protection. The copyright owner has no objection to the facsimile reproduction of the patent disclosure by any person as it appears in the Patent and Trademark Office patent files or records, but otherwise reserves all rights to the copyright whatsoever.

BACKGROUND

1. Field of Invention

Embodiments of the present invention generally relate to design and implementation of database applications. More particularly, embodiments of the present invention relate to methods and techniques of programmatically managing the creation of database structure, populating the database structure, and accessing and/or manipulating data stored in a database.

2. Description of the Related Art

Development of database applications currently involves two distinct skill sets typically requiring the involvement of both database engineers and software engineers. An example of current database modeling activities may include the following: (1) One or more database engineers capture the requirements of the database application in an entity relationship diagram (ERD); (2) manually or with the assistance of a database tool, such as Oracle9i Designer of Oracle Corporation, the database engineer(s) create an appropriate database schema to support the relationships presented by the ERD; (3) the database engineer(s) convey the requirements of the database application to one or more software engineers; (4) the software engineer(s) capture the requirements in an appropriate form, such as uniform modeling language (UML) diagrams, for development of needed data structures, e.g., class definitions; and (5) the software engineer(s) create the data structures. Other tasks, such as provisioning and providing for access and manipulation of the database typically require similar interactions among the database engineers and the software engineers.

As can be appreciated, a software development team composed of both database engineers and software engineers implementing the above database modeling process is costly both in terms of communication overhead and payroll. Consequently, a need exists to reduce the complexity of and/or automate database design and development tasks thereby allowing application developers with limited or no database skills to efficiently and effectively perform such tasks.

BRIEF DESCRIPTION OF THE SEVERAL VIEWS OF THE DRAWINGS

Embodiments of the present invention are illustrated by way of example, and not by way of limitation, in the figures of the accompanying drawings and in which like reference numerals refer to similar elements and in which:

FIG. 1 is a block diagram that illustrates a typical architecture that may be used in many database applications and in connection with one or more embodiments of the present invention.

FIG. 2 is an example of a computer system with which embodiments of the present invention may be utilized.

FIG. 3 is a UML diagram illustrating relationships between objects of an example web portal application.

FIG. 4 is an entity relationship diagram for the example web portal application.

FIG. 5 is a flow diagram illustrating schema object initialization processing according to one embodiment of the present invention.

FIG. 6 is a flow diagram illustrating table object creation processing according to one embodiment of the present invention.

FIG. 7 is a flow diagram illustrating JoinTable object creation processing according to one embodiment of the present invention.

FIG. 8 is a flow diagram illustrating database schema generation processing according to one embodiment of the present invention.

FIG. 9 is a flow diagram illustrating generation of a data definition expression to create tables according to one embodiment of the present invention.

FIG. 10 conceptually illustrates structural relationships for primitive attributes according to one embodiment of the present invention.

FIG. 11 conceptually illustrates structural relationships for inheritance according to one embodiment of the present invention.

FIG. 12 conceptually illustrates structural relationships for parent attributes according to one embodiment of the present invention.

FIG. 13 conceptually illustrates structural relationships for recursive parent according to one embodiment of the present invention.

FIG. 14 conceptually illustrates structural relationships for Foreign Parent, Foreign Child or Constant according to one embodiment of the present invention.

FIG. 15 conceptually illustrates structural relationships for peer or children according to one embodiment of the present invention.

FIG. 16 conceptually illustrates structural relationships for recursive peer according to one embodiment of the present invention.

FIG. 17 is a flow diagram illustrating processing associated with saving an object according to one embodiment of the present invention.

FIG. 18 is a flow diagram illustrating generation of data manipulation language statements to save the state of a storable object according to one embodiment of the present invention.

FIG. 19 is a flow diagram illustrating provider traversal processing used in connection with a save algorithm according to one embodiment of the present invention.

FIG. 20 is a flow diagram illustrating storable preparation processing used to conditionally assign a primary key value during save according to one embodiment of the present invention.

FIG. 21 is a flow diagram illustrating processing associated with persisting a storable according to one embodiment of the present invention.

FIG. 22 is a flow diagram illustrating peer traversal processing according to one embodiment of the present invention.

FIG. 23 is a flow diagram illustrating update children processing according to one embodiment of the present invention.

FIG. 24 is a flow diagram illustrating processing associated with deleting an object according to one embodiment of the present invention.

FIG. 25 is a flow diagram illustrating generation of data manipulation language statements to delete a storable object according to one embodiment of the present invention.

FIG. 26 is a flow diagram illustrating processing associated with updating RecursiveParent relationships during deletion of a storable object according to one embodiment of the present invention.

FIG. 27 is a flow diagram illustrating dependent traversal processing according to one embodiment of the present invention.

FIG. 28 is a flow diagram illustrating extension traversal processing according to one embodiment of the present invention.

FIG. 29 is a flow diagram illustrating foreign child traversal processing according to one embodiment of the present invention.

FIG. 30 is a flow diagram illustrating processing associated with reading an object according to one embodiment of the present invention.

FIG. 31 is a flow diagram illustrating reading of storable object(s) using class and filter according to one embodiment of the present invention.

SUMMARY

Apparatus and methods are described for providing a software framework that facilitates efficient design and implementation of database applications. According to one embodiment, a software framework creates a structure of a data store within a storage system by programmatically receiving information regarding definitions of data structures of objects participating in a software application and information regarding relationships among the data structures. Based upon the information regarding definitions and the information regarding relationships, the framework programmatically and dynamically generates appropriate statements associated with the database system environment that define the structure of a database. The framework then creates the structure of the database by issuing the statements.

According to one embodiment, a method is provided for the framework to accesses the data store by programmatically receiving information regarding definitions of data structures associated with objects participating in a software application and information regarding relationships among the data structures. In response to receipt of a request to read an object from the data store, the framework programmatically and dynamically generates one or more statements based at least in part upon the object's relationship with other objects. Then, the framework queries the data store by issuing to the storage system the one or more statements.

According to one embodiment, a method is provided for the framework to manipulate the data store by programmatically receiving information regarding definitions of data structures associated with objects participating in a software application and information regarding relationships among the data structures. In response to receipt of a request to manipulate an object, the framework programmatically and dynamically generates one or more statements based at least in part upon the object's relationship with one or more other objects. Then, the framework manipulates the data store by issuing to the storage system the one or more statements.

Other features of embodiments of the present invention will be apparent from the accompanying drawings and from the detailed description that follows.

DETAILED DESCRIPTION

Apparatus and methods are described for providing a software framework that facilitates efficient design and implementation of database applications. Broadly stated, embodiments of the present invention seek to automate the tasks of defining the structure, accessing and manipulating a database by abstracting the underlying syntax and semantics of the particular database system being employed. According to one embodiment, such abstraction is accomplished by providing an interface layer, referred to below as "Lentils," between a high-level programming language environment and the database environment provided by the particular database vendor. For example, a Lentils application programming interface (API) may be provided that programmatically and dynamically generates appropriate data definition, data query, and/or data manipulation expressions, which according to one embodiment may be one or more statements from a data definition language, data query language and/or data manipulation language associated with a database storage system, responsive to receipt of information concerning a desired operation and appropriate data structure definitions.

According to one embodiment, the Lentils API reduces or eliminates the need for the software developer that is coding in the high-level programming language environment to understand SQL. For example, storable objects may be read from a database by the software developer creating an instance of a specific type of storable object, called the pattern storable, optionally associating data values with primitive attributes, optionally creating and preparing a DBFilter, and making the appropriate API call including the pattern storable and optionally the DBFilter. Within the API call, appropriate DQEs are prepared based upon the state of the pattern storable and optional DBFilter, thus abstracting the complexities of direct interfaces with the underlying storage system.

In the following description, for the purposes of explanation, numerous specific details are set forth in order to provide a thorough understanding. It will be apparent, however, to one skilled in the art that the embodiments of the present invention may be practiced without some of these specific details. In other instances, well-known structures and devices are shown in block diagram form.

Embodiments of the present invention include various steps, which will be described below. Such steps may be performed by hardware components or may be embodied in machine-executable instructions, which may be used to cause a general-purpose or special-purpose processor programmed with the instructions to perform the steps. Alternatively, the steps may be performed by a combination of hardware and software or firmware.

Embodiments of the present invention may be provided as a computer program product which may include a machine-readable medium having stored thereon instructions which may be used to program a computer (or other electronic devices) to perform a process according to the methods and techniques described herein. The machine-readable medium may include, but is not limited to, floppy diskettes, optical disks, CD-ROMs, and magneto-optical disks, ROMs, RAMs, EPROMs, EEPROMs, magnetic or optical cards, flash memory, or other type of media/machine-readable medium suitable for storing electronic instructions. Moreover, embodiments of the present invention may also be downloaded as a computer program product, wherein the program may be transferred from a remote computer to a requesting computer by way of data signals embodied in a carrier wave or other propagation medium via a communication link (e.g., a modem or network connection).

While, for convenience, embodiments of the present invention are described with reference to a relational database and Java.TM., the present invention is equally applicable to various other databases and high-level programming languages. For example, the teachings herein are useful in connection with design and development of database applications involving object oriented databases, extensible markup language (XML) databases and the like. Similarly, various other high-level languages may be employed to interface with Lentils, such as current or future versions of C, C++, C# and the like. While the implementation specifics may vary, conceptually, the embodiments described herein would function in the same manner. While an intermediate layer interposed between a high-level language and a database management system is a likely choice for implementation of embodiments of the present invention, it is also contemplated that the mechanisms described herein could be incorporated into semantics of a high-level language or incorporated into the database management system itself

Terminology

Brief definitions of terms, abbreviations, and phrases used throughout this application are given below.

Each table has a set of "ascendant tables", which is a collection of table objects having an order corresponding to the levels of inheritance of the storable class to which the owning table is associated with. The first table in the set corresponds to the most significant super-table.

The term "COMMITTED" generally refers to a state of a storable object that has been saved at least once before to the database.

The term "COMMITTING" generally refers to a state of a storable with respect to the database when the storable is undergoing transition. According to one embodiment, if the full save cycle is successful, the state of the storable will roll forward to COMMITTED.

The terms "connected" or "coupled" and related terms are used in an operational sense and are not necessarily limited to a direct physical connection or coupling.

The phrase "database application" generally refers to a software program that makes use of a database to store, access and/or manipulate information.

The phrase "data definition expression" or "DDE" generally refers to one or more language statements, such as data definition language (DDL) statements, that define structure or schema of a storage system.

The phrase "data manipulation expression" or "DME" generally refers to one or more language statements, such as data manipulation language (DML) statements, that are used to cause changes to a database. Exemplary DML statements include, but are not limited to, INSERT, UPDATE and DELETE.

The phrase "data query expression" or "DQE" generally refers to one or more language statements, such as data query language (DQL) statements that are used to extract information from a database.

According to one embodiment, a "dependent table" is any table whose associated storable class contains a dependent relational attribute, which includes, but is not limited to, parent and ForeignParent attributes.

Each table has a set of "descendant tables", which is a collection of table objects having an order corresponding to the levels of inheritance of the storable to which the owning table is associated with. The last table in the set corresponds to the most significant super-table.

The term "DELETED" generally refers to a state of a storable with respect to the database when a full delete cycle has been completed on the storable.

The term "DELETING" generally refers to a state of a storable with respect to the database when the storable is undergoing transition. According to one embodiment, if the full delete cycle is successful, the state of the storable will roll forward to DELETED.

The phrases "in one embodiment," "according to one embodiment," and the like generally mean the particular feature, structure, or characteristic following the phrase is included in at least one embodiment of the present invention, and may be included in more than one embodiment of the present invention. Importantly, such phases do not necessarily refer to the same embodiment.

If the specification states a component or feature "may", "can", "could", or "might" be included or have a characteristic, that particular component or feature is not required to be included or have the characteristic.

An "object template" generally refers to an instance of a specific type of object of the class desired to be retrieved from a storage system and having a state (e.g., one or more data values) that are used to extract matching objects from the storage system. An example of an object template is a pattern storable.

According to one embodiment, an "orphan table" is used to create a sub-query that identifies super-records that are to be deleted. When a storable is deleted, the records that are deleted are based on the data values associated with a storable's attributes, and the class ID. When the records from a sub-table are deleted, there is no longer any information that might be necessary to identify which super-records should be deleted. According to one embodiment, a WHERE NOT IN clause is included in the Primary Key Specification (PKS), that identifies all still existing sub-records, and is then used in a NOT IN clause that identifies all the super-records that are orphaned. This technique depends on the inclusion of a clause that binds the CLASS column to the class ID value of the storable that is being deleted.

A "Primary Key Specification" or "PKS" generally refers to a SELECT sub-query, which when executed returns a set of rows from a table containing only primary key data. According to one embodiment, the structure of the PKS is as follows: SELECT primary keys FROM tables WHERE matching record specification. If current table corresponds to a storable that extends some storable, the PKS will include conditions where the primary columns of a sub-table equal the primary columns of the super-table. If the storable contains data values that are associated with primitive attributes via columns associated with the current table and super-tables, the PKS will include conditions where the columns must equal the data values in storable that are associated with the columns. If the orphan table is defined, the PKS will include conditions where the primary columns from the super-table are not in a list of existing records in the orphan table, which is otherwise referred to as a sub-table with respect to the previous iteration of the descendant tables. If the nested WHERE IN clause is defined, it is included as an additional clause in the PKS.

The term "programmatically" generally refers to an automated process the steps of which are executed by one or more computer programs.

The term "responsive" includes completely or partially responsive.

The phrase "storage system" generally refers to a data repository for persisting data. According to various embodiments of the present invention a storage system may be a relational database system (RDBS), an extensible Markup Language (XML) database, an object-oriented database or the like.

The term "TRANSIENT" generally refers to a state of a storable object that has never been saved to the database.

Overview

A software framework that intelligently and efficiently connects software applications to a database system is proposed. This intelligent connection simplifies some of the regular tasks that are commonly associated with designing and implementing database applications, such as database modeling, provisioning, and providing for access and manipulation. These functions are artfully abstracted within Lentils to reduce the skill level required to develop database applications and allow potential reduction in headcount required to staff such development efforts.

The Application

FIG. 1 is a block diagram that illustrates a typical architecture 100 that may be used in many database applications and in connection with one or more embodiments of the present invention. In the present example, the architecture 100 includes a database 120, a computer 115, a console 170, a personal digital assistant (PDA) 180 and a laptop computer 190.

On the computer 115 runs an operating system 130, such as UNIX, Linux, Windows, etc. An application 110, such as a database application or software application that relies upon a database to perform its tasks, runs within the operating system 130 and the operating system 130 supports a set of database access and services 140, such as a Java Database Connectivity (JDBC) API, an Open DataBase Connectivity (ODBC) database API, etc., which allows the application 110 to create, access, and manipulate data within the database 120 and otherwise interact with the database 120. A console input/output (I/O) interface 160 and an Internet/intranet I/O interface 150 faclitate interactions among the application and the console 170, PDA 180, and laptop computer 190.

Depending upon the particular implementation, the application 110 may be simple, like an address book, or complex, for example, an order entry application that automatically generates factory orders, downloads instructions to machines and schedules production.

As explained above, the application 110 runs on the operating system 130, which in turn runs on the computer 115. The application 110 may interact with users using some form of input/output (I/O) through the console terminal 170, connected directly to the computer 115, or through other devices connected to a network such as the Internet, a local intranet, or both.

An exemplary computer system 200, representing an exemplary computer 115, with which various features of the present invention may be utilized, will now be described with reference to FIG. 2. In this simplified example, the computer system 200 comprises a bus 230 or other communication means for communicating data and control information, and one or more processors 205, such as Intel.RTM. Itanium.RTM. or Itanium 2 processors, coupled with bus 230.

Computer system 200 further comprises a random access memory (RAM) or other dynamic storage device (referred to as main memory 215), coupled to bus 230 for storing information and instructions to be executed by processor(s) 205. Main memory 215 also may be used for storing temporary variables or other intermediate information during execution of instructions by processor(s) 215.

Computer system 200 also comprises a read only memory (ROM) 220 and/or other static storage device coupled to bus 230 for storing static information, such as instructions for processor(s) 205.

A mass storage device 225, such as a magnetic disk or optical disc and its corresponding drive, may also be coupled to bus 230 for storing information and instructions.

One or more communication ports 210 may also be coupled to bus 230 for supporting network connections and communication of information to/from the computer system 200 by way of a Local Area Network (LAN), Wide Area Network (WAN), the Internet, or the public switched telephone network (PSTN), for example. The communication ports 210 may include various combinations of well-known interfaces, such as one or more modems to provide dial up capability, one or more 10/100 Ethernet ports, one or more Gigabit Ethernet ports (fiber and/or copper) or other well-known network interfaces commonly used in internetwork environments. In any event, in this manner, the computer system 200 may be coupled to a number of other network devices, clients, and/or servers via a conventional network infrastructure, such as an enterprise's Intranet and/or the Internet, for example.

Finally, removable storage media 240, such as one or more external or removable hard drives, tapes, floppy disks, magneto-optical discs, compact disk-read-only memories (CD-ROMs), compact disk writable memories (CD-R, CD-RW), digital versatile discs or digital video discs (DVDs) (e.g., DVD-ROMs and DVD+RW), Zip disks, or USB memory devices, e.g., thumb drives or flash cards, may be coupled to bus 230 via corresponding drives, ports or slots.

Example Application

An example application is introduced for purposes of explaining and illustrating how one embodiment of Lentils may be used, and illustrating the advantages over traditional technologies. The example application is a web portal application. A web portal is an Internet (or intranet) application that limits user access to the application, and further restricts user access to specific pages in the application.

A user interacts with the application using a web browser. To access the application the user must log in, providing a domain name, username and password. A user is a person that belongs to an organization and has access to the application.

The domain name is a simple word, phrase, or sequence of characters that uniquely identifies an organization the user belongs to. For example, it may be the organization's Internet domain name.

An organization has many persons and demographic information. An organization may have multiple sub-organizations. An organization has many page groups. Page groups are described later in this document.

A user is associated with a collection of page groups, and has access to any page that belongs to the page groups in the collection. The application restricts the page groups a user may be associated with to the page groups belonging to the organization to which the user belongs.

The application monitors each time a user accesses the application by recording session information. A session begins when a user first logs in, and lasts until the user logs out, or times out.

The application provides features that are only available to a super user. A super user is a user, and typically has the responsibility of interacting with the applications most critical features.

FIG. 3 is a UML diagram 300 illustrating relationships between objects of an example web portal application. This type of diagram is well understood by those who are skilled in the art of object-oriented software development. Each of the boxes 305-350 in FIG. 3 represents a class. The classes are shown as containing data members (e.g., 355) and relationships (e.g., 360) to other classes. Instances of the classes are referred to as objects. While the present example is discussed with reference to classes and objects, it is to be understood that embodiments of the present invention are applicable to data structures generally and not limited to object oriented languages, applications, or databases.

Depending upon the embodiment, the information regarding relationships among the classes may be contained within the data structures representing the classes or may be provided via a separate configuration file. The configuration file may override or supplement relationships defined in classes or not otherwise provided by the classes.

Table 1 shows exemplary class definitions using pseudo code with syntax similar to that employed by Java or C++. These classes contain example members and references for implementing the models shown in FIG. 3.

TABLE-US-00001 TABLE 1 CLASS DEFINITIONS (I.E., JAVA, C++) Class ACCESS (320) { Integer id; String username; String password; PAGEGROUP [] page groups; }; Class DEMOGRAPHIC (330) { Integer id; String address; String address2; String city; String zipcode; String phone; String email; STATE state; }; Class ORGANIZATION (345) { Integer id; String name; String domain; DEMOGRAPHIC profile; PERSON [] personnel; PAGEGROUP [] pageGroups; ORGANIZATION parent; }; Class PAGEDESCRIPTOR (340) { Integer id; String name; }; Class PAGEGROUP (335) { Integer id; String title; PAGEDESCRIPTOR [] pages; }; Class PERSON (315) { Integer id; String first; String last; DEMOGRAPHIC profile; }; Class SESSION (325) { Integer id; Boolean expired; Access access; }; Class STATE (350) { Integer id; String name; String abbreviation; }; Class SUPERUSER extends USER (305) { }; Class USER extends PERSON (310) { ACCESS passkey; };

In the present example, the application is required to persist and/or otherwise save, update, read and delete objects, the relationships between objects to a storage system, and adhere to the implications of the relationships between the objects.

The storage system may be a relational database system (RDBS), an XML database, an object-oriented database or the like. Consistent with the intended purpose of this document, this example is explained with reference to a relational database system. Those skilled in the art will be able to apply the teachings contained herein to other storage system environments.

This example has been described first with a generic description, independent of the assumption that software would be used to implement the application, but then quickly transitions from a generic description to UML diagrams to supporting classes. This progression occurs frequently in industry as applications are developed. However, it is also a frequent occurrence that the progression starts with a generic description, and transitions into a database design space involving entity relationship diagrams (ERDs) and a schema. Once these elements are stable, then software is developed.

As described earlier in the background, this leads to a problem frequently experienced in industry. Applications that are both database and software intensive typically require individuals who are skilled in database technology, and individuals who are skilled in software development technologies.

FIG. 4 is an entity relationship diagram (ERD) 400 for the example web portal application. Assuming the initial design model is software centric, FIG. 4 represents an example of what a resulting ERD 400 might look like for the web portal example. The ERD 400 is capable of supporting the application requirement for persisting data. Notice that there are more "boxes" (e.g., 470-485) in the ERD 400. This is because the relationships between the primary entities are modeled like primary entities themselves.

Note that if the design of the application was initiated from a database design space, the generic description would have to be augmented to support the relationship entities in the ERD 400. This is called artificial modeling, and tends to make it more difficult to understand the design. Using a software-centric design space, the generic description uses natural modeling, and is easier to understand.

Note that if a software developer initially developed the model from a generic description, to a UML model, to pseudo code, some time and coordination must be given for the software developer to communicate the elements of the design to a database developer, who then in turn after understanding the requirements, creates a schema in agreement with the needs of the software developer. The information that must be communicated includes the content of the objects, the relationships between the objects, and any constraints associated with the contents and relationships.

It is not always obvious from the ERD or UML diagram what kind of dependencies exists between two primary entities. For example, referencing FIG. 4, compare the relationship between ACCESS 420 and PAGE_GROUP 435, and ORGANIZATION 445 and PAGE_GROUP 435. Both of these relationships show an intermediate entity joining the two primary entities together. ORGANIZATION_PAGEGROUPS 475 joins ORGANIZATION 445 and PAGE_GROUP 435, and ACCESS_PAGEGROUPS 470 joins ACCESS 420 and PAGE_GROUP 435. Structurally, the joining entities RGANIZATION_PAGEGROUPS and ACCESS_PAGEGROUPS are similar. However, there are differences implied by the relationship that govern the dependencies between the data. When an Organization is deleted, all Page Groups associated with the Organization should be deleted. When an Access is deleted, its relationship to the Page Groups deleted, but the Page Groups themselves should be left in tact.

What would be the benefits if the relationships and dependencies between classes could be annotated in a UML diagram, and implemented as properties of the classes that embody the relationships and dependencies? The information exchange between the software developer and the database developer could be conveyed programmatically.

Further, if the creation of a storage structure or schema, and query for, and manipulation of the data uses some structured process or language, the acts of creating the storage structure, and querying and manipulating data could be programmatically automated based on the properties of the classes participating in the application.

Relational database systems use SQL to create structure, and query and manipulate data, and thus is a prime candidate for programmatically automating these processes.

Scenarios

Included herein are a number of sample scenarios and a corresponding description of actions that occur within the example application and supporting RDBS. The purpose is to provide a sense of the complexities involved in accommodating the rules that govern the relationships between the classes and the constraints of the underlying RDBS.

Software implements the requirements of the applications and is the means of accommodating the rules that govern the relationships between the classes and the constraints of the underlying RDBS. The software is implicitly complex. According to one embodiment, Lentils may be employed to encapsulate the complexities. In the attached Appendix, two techniques for implementing the scenario of saving and organization are compared. The comparison demonstrates at least some of the benefits of using Lentils.

Creating a Schema

In simple terms, a database schema is a collection of database tables and columns. A schema is created by executing CREATE TABLE SQL statements. Other SQL statements may be used to establish indexes, foreign key constraints and other constraints or structures.

Saving an Organization

In accordance with the present example application, saving an organization follows a sequence that satisfies the constraints of the underlying database in accordance with the dependencies of the relationships, and the intent of "saving" the state of an object. The order of the sequence will be noted in a "lazy" fashion.

An organization must be saved. If an organization has a parent organization, the parent organization should be saved first. According to the present example, the parent organization is saved in accordance with the sequences outlined in this section.

An organization's demographic should be saved before the organization is saved. If there are new relationships between organization and page groups, the prior relationships between the organization and page groups are deleted.

Any page group in the prior relationships to organization that are not in the new relationships between organization and page groups are deleted.

Each page group in the new relationships between organization and page groups are saved.

The new relationships between organization and page groups are saved after the organization and page groups have been saved.

If there are new relationships between organization and persons, the prior relationships between the organization and persons are deleted.

Any person in the prior relationships to organization that are not in the new relationships between organization and persons are deleted.

Each person in the new relationships between organization and persons are saved. The new relationships between organization and persons are saved after the organization and persons have been saved.

For each person being deleted, if that person is a user, the user is deleted before the person is deleted.

For each user that is deleted, the user's access is deleted, after the user is deleted.

For each access that is deleted, any session belonging to the access is deleted before the access is deleted.

For each access that is deleted, the relationships between an access and page group is deleted before the access is deleted.

For each page group that is deleted, the relationship between the page group and page descriptors are deleted before the page group is deleted.

For each person being saved, the person's demographic is first saved.

For each person being saved, if the person is a user, the user is saved after the person is saved.

For each user being saved, the user's access is first saved.

For each access being saved, if there are any sessions associated with the access, the sessions are saved after the access is saved.

For each access being saved, if there are any pages groups associated with the access, the page groups and access are saved before the relationship between the access and page groups are saved.

Collections of data manipulation language (DML) SQL statements are used to cause the changes to the database. The DML statements may include, among other statements, INSERT, UPDATE and DELETE.

In general, if an object or corresponding record pre-exists in the database, the record is saved using an UPDATE SQL statement, otherwise the record is saved using an INSERT