US20010014889A1

US20010014889A1 - Generic execution model for isolating applications from underlying databases

Info

Publication number: US20010014889A1
Application number: US09/070,274
Authority: US
Inventors: Kenneth Ray Blackman; Shyh-Mei Fang Ho; Thomas Beavers Sander
Original assignee: Individual
Current assignee: Twitter Inc
Priority date: 1998-04-30
Filing date: 1998-04-30
Publication date: 2001-08-16
Anticipated expiration: 2018-04-30
Also published as: US6360229B2

Abstract

A method, apparatus, and article of manufacture for accessing a database. The database is modeled as an objects framework having zero or more business objects and one or more data objects. The data objects represent data in the database and the business objects represent logic for operating on the data objects.

Description

BACKGROUND OF THE INVENTION

1. Field of the Invention

The present invention relates generally to computerized methods for accessing databases, and in particular, to a generic execution model for isolating application programs from the structure and operations of the underlying data.

2. Description of Related Art

It is well known in the art to use database management systems, such as IBM's IMS™ (Information Management System) database management system, to manage computerized databases. Indeed, IMS™ has been used for decades and remains in use today. Currently, there is a need to access such “legacy” databases using application programs developed by object-oriented programming systems (OOPS). However, there are few tools available to assist OOPS developers.

One method for allowing object-oriented application programs to access data in an IMS™ database is through transaction wrappering, implemented in such products such as IBM's VisualAge™ IMS Connection. Transaction wrappering creates a class having methods that retrieve data from the IMS™ database, create an object embodying the retrieved data, and manipulate the object in an object-oriented application program. The problem with this approach is that each object-oriented application requires substantial additional coding, both object-oriented and non-object-oriented, before it is able to access the data in the IMS™ database.

Another approach to accessing data in a non-relational, non-object-oriented database is to translate the non-relational database to a relational database, and use existing object-oriented programming techniques developed for relational databases to access the data therein. The problem with this approach is that non-relational data, such as the hierarchical data found in an IMS™ database, does not map well to a relational database.

Thus, there is a need in the art for improved techniques for accessing hierarchical data using object-oriented frameworks.

SUMMARY OF THE INVENTION

To overcome the limitations in the prior art described above, and to overcome other limitations that will become apparent upon reading and understanding the present specification, the present invention discloses a method, apparatus, and article of manufacture for accessing a database, wherein the database is modeled as an objects framework having zero or more business objects and one or more data objects. The data objects represent data in the database and the business objects represent logic for operating on the data objects.

Various advantages and features of novelty which characterize the invention are pointed out with particularity in the claims annexed hereto and form a part hereof. However, for a better understanding of the invention, its advantages, and the objects obtained by its use, reference should be made to the drawings which form a further part hereof, and to accompanying descriptive matter, in which there is illustrated and described specific examples of an apparatus in accordance with the invention.

BRIEF DESCRIPTION OF THE DRAWINGS

Referring now to the drawings in which like reference numbers represent corresponding parts throughout: [0010]
FIG. 1 is a block diagram illustrating an exemplary hardware environment used to implement the preferred embodiment of the present invention; [0011]
FIG. 2 is a block diagram illustrating a layered processing model used in the objects framework according to the present invention; and [0012]
FIG. 3 is a flowchart illustrating the steps performed by the application program and objects framework according to the present invention. [0013]

DETAILED DESCRIPTION OF THE PREFERRED EMBODIMENT

In the following description of the preferred embodiment, reference is made to the accompanying drawings which form a part hereof, and in which is shown by way of illustration a specific embodiment in which the invention may be practiced. It is to be understood that other embodiments may be utilized and structural changes may be made without departing from the scope of the present invention. [0014]
Overview [0015]
The present invention introduces a new model for accessing databases, such as an IMS™ database, by modeling the database into an objects framework and providing the mechanisms that allow object-oriented application programs to access the database data using standard tools, such as the DL/I™ query language for the IMS™ database. The objects framework instantiates IMS™ data objects upon demand from application programs and manages those objects from creation to deletion. Further, the objects framework uses these objects to dynamically construct DL/I™ calls from application program requests. [0016]
The objects framework can be used in a number of different environments, such as: (1) DL/I™ batch processing and (2) on-line transactions including both IMS™ and CICS™ transactions. Moreover, the objects framework can be executed in any MVS address space, including IMS™ and non-IMS™ address spaces, such as web server address spaces. [0017]
Thus, the present invention offers improved IMS™ application programming productivity by supporting IMS™ business objects and data objects, by eliminating complicated DL/I™ programming, and by supporting use of object-oriented programming tools. [0018]
Hardware Environment [0019]
FIG. 1 is a block diagram illustrating an exemplary hardware environment used to implement the preferred embodiment of the invention. A [0020] client computer 100 communicates with a server computer 102. Both the client computer 100 and the server computer 102 are typically comprised of one or more processors, random access memory (RAM), read-only memory (ROM), and other components such data storage devices and data communications devices.
The [0021] client computer 100 executes one or more computer programs 104 operating under the control of an operating system. These computer programs 104 transmit requests to the server computer 102 for performing various functions and receive data from the server computer 102 in response to the requests.
The [0022] server computer 102 also operates under the control of an operating system, and executes one or more computer programs 106, 108, and 110. These computer programs 106, 108, and 110 receive requests from the client computer 100 for performing various functions and transmit data to the client computers 100 in response to the requests.
The [0023] server computer 102 manages one or more databases 112 stored on one or more data storage devices (such as a fixed or hard disk drive, a floppy disk drive, a CD-ROM drive, a tape drive, or other device). In a preferred embodiment, the database 112 is managed by the IMS™ database management system (DBMS) offered by IBM Corporation. Those skilled in the art will recognize, however, that the present invention may be applied to any database and associated database management system.
The present invention is generally implemented using five major components executed by [0024] client computers 100 and server computers 102, including a client program 104, object-oriented application program 106, objects framework 108, database management system DBMS) 110 and database 112, wherein each of these components comprise instructions and/or data. The client program 104 provides a user interface, the object-oriented application program 106 performs application functions, the objects framework 108 materializes data retrieved from the database 112 as objects, and the database management system 110 controls access to the database 112.
Generally, these instructions and/or data [0025] 104-112 are all tangibly embodied in or retrievable from a computer-readable device, medium, or carrier, e.g., a data storage device, a data communications device, etc. Moreover, these instructions and/or data, when read, executed, and/or interpreted by the client computer 100 and/or server computer 102, causes the client computer 100 and/or server computer 102 to perform the steps necessary to implement and/or use the present invention.
Thus, the present invention may be implemented as a method, apparatus, or article of manufacture using standard programming and/or engineering techniques to produce software, firmware, hardware, or any combination thereof. The term “article of manufacture” (or alternatively, “computer program product”) as used herein is intended to encompass a computer program accessible from any computer-readable device, carrier, or media. Of course, those skilled in the art will recognize many modifications may be made to this configuration without departing from the scope of the present invention. [0026]
Those skilled in the art will recognize that any combination of the above components, or any number of different components, including computer programs, peripherals, and other devices, may be used to implement the present invention, so long as similar functions are performed thereby. [0027]
Objects Framework Model [0028]
FIG. 2 is a block diagram illustrating a layered processing model provided by the [0029] objects framework 108 according to the present invention. The layered processing model corresponds to the application views, database definitions, and data defined and stored in an IMS™ database management system.
The [0030] objects framework 108 comprises a C++ class library that interfaces to the application program 106. The application program 106 dynamically loads previously-defined objects into the objects framework 108 to access the database 112 during execution time. The objects loaded into the objects framework 108 include a DL/I™ object 200, one or more applView objects 202, one or more dbdView objects 204, one or more business objects (BOs) 206, one or more data objects (DOs) 208, and an iterator object 210.
The [0031] application program 106 first loads the objects framework 108 class library by instantiating the DL/IT™ object 200, one applView object 202, and one dbdView object 204. The objects framework 108 then dynamically loads in the BO 206 and DO 208 class library requested by the application program 106 to create an iterator object 210, which then instantiates the BOs 206 and their corresponding DOs 208 during execution.
All the class objects, except the [0032] iterator class 210, are organized into a tree structure to represent the hierarchical structure of data retrieved from the database 112. In the preferred embodiment, the tree structure ensures that there is exactly one path through the hierarchy to each object and consequently exactly one identity, i.e., segment occurrence, for an object.
Each of the objects encapsulates a logical unit of data retrieved from the [0033] database 112 and includes member functions for manipulating the encapsulated data. The structure and member functions of these various objects are described in more detail below.
DL/I Object [0034]
In the preferred embodiment, the [0035] database 112 is an IMS™ database 112, which is an “application views database”. The DL/I™ object 200 is the root of the objects framework 108, and thus is a root for a collection of application views (applView objects 202) in the IMS™ database 112. Thus, the objects framework 108 provides for multiple application views of the database 112 in a layered processing model.
applView Object [0036]
Each applView object [0037] 202 represents an “application (appl) view” of the IMS™ database 112. Each applView object 202 contains and manages a collection of dbdView objects 204.
dbdView Object [0038]
Each dbdView object [0039] 204 represents a “database description (dbd) view” associated with a given “application view” of the IMS™ database 112. Each dbdView object 204 includes information about the structure of the segments in the IMS™ database 112 and the record layouts, including formatting information for the records in the database 112. The dbdView objects 204 also define the hierarchy to help locate segments for the database 112. In the objects framework 108, each dbdView object 204 contains and manages a collection of data objects (DOs) 206 and business objects (BOs) 208.
Business Objects and Data Objects [0040]
The [0041] IMS™ database 112 is comprised of a collection of segment types, and each segment type contains a collection of segment occurrences. A DO 208 class represents each segment type and each segment occurrence is represented by an instance of the class, i.e., a DO 208. Thus, the DOs 208 provide a direct mapping of the data within each segment occurrence. Moreover, the object-oriented application program 106 can directly access the data of the segment occurrence by interacting with the DO 208 via the objects framework 108 to perform the necessary operations on the database 112.
In addition, a [0042] BO 206 may be instantiated with a DO 208 to provide business logic for the application program 106. In such an embodiment, the application program 106 accesses the business logic via the BO 206, which in turns invokes the methods of its corresponding DO 208 to perform the necessary operations on the database 112, to manage its essential state data. Thus, the DO 208 isolates the BO 206 from the specifics of the database 112. With the BO/DO model, customers can easily separate business logic from the physical data access logic to accommodate more diversified business needs. Furthermore, because of the nature of the separation of BO 206 and DO 208, the objects framework 108 can be easily extended to other non-hierarchical databases, e.g. DB2™.
Iterator Object [0043]
In the [0044] objects framework 108, the application program 106 uses a DL/I™ query string to access the IMS™ database 112. The application program 106 first instantiates a desired applView object 202. If the associated DL/I™ object 200 has not been instantiated yet, this also results in its instantiation as the root of the objects framework 108 and the root for the collection of application views (applView objects 202) in the IMS™ database 112. The application program 106 then provides the DL/I™ query string to an “evaluate” method of the applView object 202. The applView object 202 builds a DL/I™ segment search argument list based on the values within the DL/I™ query string.
The [0045] application program 106 then creates the iterator object 210 that is used to point to an incrementally-materialized collection of BOs 206 and DOs 208 that meet the search criteria specified in the DL/I™ query string. The “evaluate” method of the applView object 202 reads the DL/I™ query string and sets a pointer in the iterator object 210 to point to the collection of BOs 206 and DOs 208 that meet the DL/I™ segment search criteria.
A “next” method of the [0046] iterator object 210 is invoked to instantiate each BO 206 and/or DO 208 from the database 112, wherein the resulting state data of the BO 206 and DO 208 are cached in the memory of the server computer 104. Using the pointer and “next” method of the iterator object 202, the application program 106 can iterate through a collection of BOs 206 and/or DOs 208 to materialize one BO 206 and/or DO 208 after the other in the memory of the server computer 102.
Each [0047] BO 206 and DO 208 class contains both “get” and “set” methods associated for each class attribute. The application program 106 can then retrieve or update the attributes of a DO 208 by invoking these methods. Preferably, no I/O operations are performed at the invocation of these “get” and “set” methods, and all state data is changed in memory only until a commit occurs.
As described above, the [0048] BOs 206 are used by the application program 106 to perform needed business logic on the associated DOs 208. In addition, the application program 106 can perform DL/I™ operations (e.g., retrieve, update, delete and insert) using methods of the BOs 206. The BO 206 will, in turn, invoke methods of its corresponding DO 208 to perform the actual DL/I™ calls.
The following methods exemplify the [0049] BO 206 methods that allow the application program 106 to retrieve a DO 208 from the database 112, to update state data for the DO 208 in the database 112, to add a new instance of the DO 208 to the database 112, or to delete a DO 208 from the database 112:
RetrieveFromDS ( ) [0050]
UpdateToDS( ) [0051]
InsertToDS( ) [0052]
DeleteFromDS ( ) [0053]
In a preferred embodiment, only the above four methods will result in actual I/O operations on the [0054] database 112.
Example Application Program [0055]

Following is a sample object-oriented

application program

106 according to the present invention:



// application program
main( )
{

	// instantiate desired applView object (and DL/I object if necessary)
	applView_SSM applView(“applViewName”);
	// instantiate iterator object and set pointer using applView object's
	// “evaluate” method and query string
	iterator* ltr=applView.evaluate(queryString);
	// use “next” method to instantiate a BO and its associated DO
	BO*pObj=ltr->next( );
	// use indicated methods to retrieve, update, or
	// delete BOs and DOs
	pObj->RetrieveFromDS( );
	pObj->UpdateToDS( );
	pObj->DeleteFromDS( );
	// use “newObject” method to instantiate new DO
	DO*pObj=ltr->newObject( );
	// use indicated method to insert new DO
	pObj->InsertToDS( );

}

Following is a example DL/I™ query string that could be used by the object-oriented

application program

106 that accesses the database 112:



	SELECT	doClassNameC
	FROM	database ViewName
	WHERE	doClassNameA.keyname relop keyvalue,
		doClassNameB.keyname relop keyvalue,
		doClassNameC.keyname relop keyvalue

where “relop” is a relational operator, such as: [0058]
EQ or = or=[0059]
GT or > or >[0060]
LT or < or <[0061]
GE or >=or=>[0062]
LE or <=or=<[0063]
NE or ! or=![0064]
AND or & or * [0065]
OR or | or+[0066]
Logic of the Objects Framework [0067]
FIG. 3 is a flowchart illustrating the steps performed by the [0068] application program 106 and objects framework 108 according to the present invention.
[0069] Block 300 represents the DL/I™ object 200 of the objects framework 108 being instantiated in the memory of the server computer 102. Usually, this occurs either when the objects framework 108 is loaded or when the application program 106 first requests an applView object 202.
[0070] Block 302 represents the application program 106 instantiating the requested applView object 202 in the memory of the server computer 102.
[0071] Block 304 represents the dbdView objects 204 of the objects framework 108 being instantiated in the memory of the server computer 102. Usually, this occurs either when the objects framework 108 is loaded or when the application program 106 first requests an applView object 202.
[0072] Block 306 represents the application program 106 instantiating the iterator object 210 in the memory of the server computer 102 and setting its object pointer by invoking the “evaluate” method with a DL/I™ query string.
Blocks [0073] 308-316 represent a loop that may be performed by the application program 108 to iterate through all the associated BOs 206 and/or DOs 208 in the collection.
[0074] Block 310 represents the application program 106 invoking the “next” member function or method of the iterator object 210 to instantiate/materialize the next DO 208 and/or BO 206 in the memory of the server computer 102.
[0075] Block 312 represents the iterator object 210 instantiating the requested DO 208 and/or BO 206 in the memory of the server computer 102.
[0076] Block 314 represents the application program 106 invoking the “getter”, “setter”, or other methods of the DOs 208 and/or BOs 206 to perform the desired functionality. Thereafter, control transfers back to Block 308.
[0077] Block 316 represents the end of the logic.
Conclusion [0078]
This concludes the description of the preferred embodiment of the invention. The following paragraphs describe some alternative methods of accomplishing the same objects. [0079]
In alternative embodiments of the present invention, other types and configurations of computers could be used. For example, the invention need not be restricted to client-server configurations. In addition, mainframes, minicomputers, or personal computers, could be used with the present invention. [0080]
In alternative embodiments of the present invention, other types and configurations of computer programs could be used. For example, the invention need not be restricted to client-server configurations. [0081]
In alternative embodiments of the present invention, other database management systems could be used. For example, the invention need not be restricted to IMS™ database management systems. Instead, the present invention could be used to model other types of databases or datastores. [0082]
In summary, the present invention discloses a method, apparatus, and article of manufacture for accessing a database, wherein the database is modeled as an objects framework. The database is modeled as an objects framework having zero or more business objects and one or more data objects. The data objects represent data in the database and the business objects represent logic for operating on the data objects. [0083]
The foregoing description of the preferred embodiment of the invention has been presented for the purposes of illustration and description. It is not intended to be exhaustive or to limit the invention to the precise form disclosed. Many modifications and variations are possible in light of the above teaching. It is intended that the scope of the invention be limited not by this detailed description, but rather by the claims appended hereto. [0084]

Claims

What is claimed is:

1. A computer-implemented method for accessing a database, comprising the steps of:

(a) modeling the database into an objects framework having zero or more business objects and one or more data objects, wherein the data objects represent data in the database and the business objects represent logic for operating on the data objects; and

(b) accessing the database through the objects framework.

2. The method of

claim 1

, wherein the objects framework comprises a class library that interfaces to the application program.

3. The method of

claim 1

, wherein the application program dynamically loads the business objects and data objects into the objects framework to access the database during execution time.

4. The method of

claim 1

, wherein the objects framework further includes a DL/I™ object representing a root of the objects framework, one or more application view objects that represent an application view of the database, and one or more database definition view objects that represent a structure and layout for the database.

5. The method of

claim 4

, wherein the objects are organized into a tree structure to represent a hierarchical structure of data retrieved from the database.

6. The method of

claim 5

, wherein the tree structure comprises:

the DL/I™ object as a root for a collection of the application view objects;

the application view object managing a collection of the database definition view objects; and

the database definition view object managing a collection of the data objects and business objects.

7. The method of

claim 1

, wherein the data object class represents a segment type in the database and the data object represents a segment occurrence in the database.

8. The method of

claim 7

, wherein the data object provides a direct mapping of the data within each segment occurrence.

9. The method of

claim 7

, further comprising the step of accessing data in the segment occurrence by interacting with the data object.

10. The method of

claim 1

, further comprising the step of accessing the business logic of the business object to invoke methods of the data object.

11. The method of

claim 1

, further comprising the step of isolating the business object from specifics of the database by invoking methods of the data object.

12. The method of

claim 1

, further comprising the step of retrieving the data objects and/or business objects in response to a query.

13. The method of

claim 12

, further comprising the step of incrementally materializing the data objects and/or business objects in a memory of a computer that satisfy search criteria of the query .

14. The method of

claim 13

, wherein the objects framework further comprises an iterator object that points to the incrementally materialized data objects and business objects.

15. The method of

claim 14

, further comprising the step of instantiating additional data objects and business objects via the iterator object.

16. A computerized apparatus for accessing a database, comprising:

(a) means for modeling the database into an objects framework having zero or more business objects and one or more data objects, wherein the data objects represent data in the database and the business objects represent logic for operating on the data objects; and

(b) means for accessing the database through the objects framework.

17. A program storage medium readable by a computer, the medium embodying one or more instructions executable by the computer to perform method steps for accessing a database, the method comprising the steps of:

(b) accessing the database through the objects framework.