JP2767767B2 - Data processing apparatus and method for accessing relational database - Google Patents

Description

DETAILED DESCRIPTION OF THE INVENTION

[0001]

FIELD OF THE INVENTION The present invention relates generally to an improved data retrieval system, and more particularly to a method and apparatus for retrieving data in a relational database outside of an object-oriented environment. More particularly, the invention relates to a method and apparatus for retrieving data without leaving the object-oriented environment.

[0002]

BACKGROUND OF THE INVENTION Although object oriented languages have the advantage of extensibility and code reusability, in an object oriented environment it may be necessary to access data in relational databases outside this environment. . At present, an object-oriented database in which an existing relational database is redesigned and rewritten as an object-oriented database is under consideration. Have been. In such a state, it is necessary to access the data of these relational databases without leaving the object-oriented environment. Unfortunately, at present, no system for searching relational database data without leaving the object-oriented environment exists in a true object-oriented environment. Currently, individual tasks within an object-oriented environment must exit the object-oriented environment in order to access data using conventional relational database access techniques.

[0003] Objects in an object-oriented environment are composed of related code and data. Objects have a library of methods that are unique to each object, which gives each object a unique behavior. An object class defines a group based on one or more properties, and an instance is a single item in a class. For example, a class of an object may be a profession, such as a lawyer, doctor, technician, or programmer, and an instance of the object may be considered to be a particular individual in the class.

[0004] One class defines how to interpret a new instance and an instance method that defines how one instance behaves and reacts to an incoming message. Instance variables define certain characteristics of one instance of an object, such as an individual's salary. These instance variables may be defined, or may be blank in a definition waiting state.
The data structure of an instance is described by a set of instance variables. Pointers are used to point to object-type structures.

[0005] Smalltalk-80 uses a model-view-controller architecture to construct applications. Model objects have the ability to retrieve and process data, while view objects are responsible for displaying the screen and interacting with the user. View
Objects manage application flows and send messages to model objects to retrieve or modify data. The controller manages input signals and output signals from external devices.

[0006] There is a fundamental incompatibility between an object-oriented environment and a relational database. The object-oriented environment has many pointers to data structures, whereas the relational database has a flat structure.
Thus, the relationships between the data in the object-oriented environment are built into the structure of the data object. Because relational databases use a flat table-oriented approach to data storage, the relations of the relational database are not specified as part of the data storage technology. This makes it difficult to convert the data stored in the relational database into an object-oriented format.

For example, Digitalk, Inc.
The product Smalltalk V / PM language does not support direct access to external relational databases. However, the language can call OS / 2 dynamic link library (DLL) routines and have the parameters transferred to those routines. Unfortunately,
Only a single value is returned from the routine. Typically, this is a half word integer or pointer. The above restrictions make it difficult to return multiple column values for one row and assign them directly to instance variables, since one return must point to one structure of the object form. .

The C ++ language allows direct access to retrieve C programming language data from a relational database, which is an extension of the C language for object-oriented programming. Although this adds class structure to the C language, it is primarily aimed at improving the C language. The C ++ language is a hybrid language, not an object-oriented language. The concept of the environment in the C ++ language is Smallt, where all messages use dynamic constraints.
Not the same as alk language.

[0009]

Thus, it is apparent that there is a need for a method and apparatus for accessing data in a relational database without leaving the user from an object-oriented environment.

It is an object of the present invention to provide an improved data access system.

It is another object of the present invention to provide a method and apparatus for accessing data in a relational database outside of an object-oriented environment.

It is another object of the present invention to provide a method and apparatus for accessing data in a relational database without leaving the object-oriented environment.

[0013]

SUMMARY OF THE INVENTION The method and apparatus of the present invention allows access to a relational database outside an object-oriented environment without leaving the object-oriented environment. The requesting object in the object oriented environment sends a data access message requesting data located in a relational database outside the object oriented environment.
This message is sent to the interface, which creates a data object containing instance variables to hold the results from the data access request. This interface executes a data access routine that accesses data from the relational database, and places the result in a data object. And
A pointer to the data object is sent to the requesting object.

[0014]

1, there is shown a data processing system 8 to which the method of the present invention can be applied. As shown, data processing system 8 includes a plurality of networks, such as local area networks (LANs) 10 and 32. Each of the local area networks preferably includes a plurality of individual computers 12 and 30. Of course, those skilled in the art will appreciate that a plurality of intelligent workstations (IWS) connected to a host processor can be used in such a network.

As is common in such data processing systems, each computer is coupled to a storage device 14 and a printer / output device. Such a storage device 14 is used in accordance with the method of the present invention to store documents, i.e., resource objects, which are periodically accessed by all users of the data processing system 8. The documents, i.e. each of the resource objects, stored in the storage device 14 are freely exchangeable via the data processing system 8, for example by transferring the documents to the user of the individual computer 12 or 30.

In FIG. 1, data processing system 8 is connected by a communication link 24 to a local area network.
It includes a plurality of mainframe computers, such as a mainframe computer 18, which is preferably coupled to (LAN) 10. The mainframe computer 18 is a local area network (LAN)
It can also be connected to a storage device 20 which serves as a remote storage for 10. Similarly, local area network 10 is coupled via communication link 24 to subsystem server / communication controller 26 and to gateway server 28 via communication link 34. Gateway server 28 is preferably a separate computer, or interactive workstation (IWS), that serves to link local area network 32 to local area network 10.

As described above with respect to local area networks 32 and 10, a plurality of documents or resource objects are stored in storage device 20 and as a resource manager or library service for the stored resource objects. It is controlled by the mainframe computer 18. Of course, mainframe computer 18 is located geographically remote from local area network 10, and similarly, local area network 10 is
Those skilled in the art will appreciate that the remote location is remote from the area network 32. For example, setting up a local area network 10 in Texas,
Mainframe computer 18 is located in New York.

Within the distributed data processing system 8, individual users can execute different programs on individual computers 12 and 30, and have access to other areas of the distributed data processing system 8. For example,
One user uses one object-oriented environment,
The relational database of the mainframe computer 18 or the storage 14, 20 at some location can be accessed.

Due to differences in data structure and structure,
Problems arise in accessing relational databases from object-oriented environments. Specific applications that apply to specific object-oriented environments are described below.

Referring to FIG. 2, a preferred embodiment is illustrated for a user to access a relational database without leaving the object-oriented environment. One object-oriented environment suitable for use in this embodiment is IBM's product OfficeVisio.
n) It is a program. As shown, the distributed data processing system 8 includes an address book window 40.
Including object-oriented environments. Address book
Window 40 is one object in the object-oriented environment. When the user selects the entry icon 42, the address book record window 52
Is opened. Address book record window 52 contains address book record entries from relational database 48.

The user of the address book window 40 receives the requesting object (address book record 4).
6), no interaction between the interface object 50 and the relational database 48 is seen. Address book record 46 is the requesting object that sends a message to interface object 50 to get the data. This interface object 50 translates the request into a query, which is sent to the relational database 48 and receives the query result in reply. Next, the interface object 50 converts the query result into a format recognizable by the address book record of the requesting object. Interface object 50 transfers a pointer to address book record 46 containing the location of the requested data. Address book record 46 displays the results returned from interface object 50.

FIG. 3 shows an object-oriented language Smalltalk V /
FIG. 3 illustrates a preferred embodiment of the present invention that includes a PM and a relational database using Structured Query Language (SQL), a well-known language for querying relational databases.

In this embodiment, interface 50 includes a table object 63, a translator object 66, a query open routine 68, a query fetch routine 70, and a commit routine 72. The table object 63 creates a data object, and the query open routine 68, the query fetch routine 70 and the commit routine 7
2 comprises a data access routine used to access the relational database 80 and place data in data objects. Each data object preferably contains and corresponds to data from one row of the relational database 80. The translator object 66 is a dynamic link library (DL
L) to call the application program interface (API) to the appropriate data access routine.

Multiple rows of the relational database may match one query. Each row that matches the query is 1
Corresponding to one data object. The data object pointers are aggregated and the table object 63 returns a pointer to the aggregate to the requesting object 60. The aggregate may be, for example, an array of pointers or a list of linked pointers, the aggregate being returned by returning the pointer to the head of the array or linked list.

In this particular embodiment, the model object 60, which is the requesting object and corresponds to the address book record 46 of FIG. 2, performs the process of opening the table 62 in response to the user's request. Execution invokes one of the table objects 63 and sends a content fetch message to the table object 63.

As a result, table object 63 creates a data object containing the instance variables, which is transferred to the data access routine for instance variable assignment. The data object created by table object 63 contains instance variables in the same order as the columns from which data was retrieved by the data access routines (query open routine 68, query fetch routine 70, and commit routine 72). In. table·
Object 63 is a translator object 66
Performs the content retrieval 64 process, sends an inquiry open message, and transfers parameters or pointers to the data object.

The translator object 66 performs a query open 74 operation, which sends an application program interface (API) call to the query open routine 68 with parameters or pointers to the data object.
As a result, the query open routine 68 sets up a structured query language data area (SQLDA) and SQLDA pointer. This SQLDA is a query open routine 6
8 by transferring a parameter or start pointer. This SQLDA basically tells the relational database 80 where to put the data. afterwards,
The open query routine 68 is a translator object 66 with an SQLDA and an SQLDA pointer set.
Send a message to This message is sent to the table object 63, and the process of the content fetch 64 sends a query fetch message to the translator object 66. The translator object 66 calls the query fetch 76 processing routine and sends an API call to the query fetch routine 70. The query retrieval routine 70 returns one row of data to the data object created by the translator object 66. The query fetch routine 70 uses an SQLDA in the same order as the data object instance variables.
Are preferably repeated. The table object 63 contains different tables for retrieving different types of data or different orders of data. Each table has a set of data access routines configured to retrieve specific data in the order set by the specific table.

After the data object instance variables have been filled in, the data object pointer is added to the collection containing the data object pointer. The content fetching routine 64 cycles through the loop, calling the translator object 66 until the routine receives a message indicating that there is no more data to be retrieved. Query retrieval routine 76
Sends a message with no data to be retrieved to the translator object 66, this message is sent to the table object 63.

In response to the no data message, the translator object 66 sends a commit message to the translator object so that a commit 78 is executed and the commit routine 72
Is sent, which causes the relational database 80
Is closed. Thereafter, translator object 66 receives the message that relational database 80 has been closed and forwards the message to table object 63. Finally, the model object 60
The aggregate of data objects is sent to the model object 60 by sending the aggregate pointer to.

The table object 63 has a plurality of tables, each table having a set of data access routines used to place data correctly in the data object. For example, the model object 60 is an address book, and the last name,
When requesting data in the order of first name and telephone number, table object 63 invokes a set of data access routines that retrieve specific data in the order requested by model object 60. Call. Model object 60
If requesting data in the order of first name, last name, and telephone number, table object 63 will retrieve a second set of data access data to retrieve the data in the requested order. Use a second table that calls the routine. Thus, if the data to be retrieved or the order of the data is changed, different tables of the table object 63 and different sets of data access routines are used.

The present invention should not be construed as being limited to the above-described embodiment. For example, in the embodiment shown in FIG. 3, in addition to returning a pointer to a data object,
Other methods of returning the data object to the requesting object can also be used. In addition, the requesting object can create and fill in data objects, thereby eliminating the need for table objects 63.
Also, the table object 63 and the translator object 66 can be combined into one object under the present invention.

The data access routine can be further reordered so that the order of the data retrieved can be changed by sending parameters to the data access routine which tells the routine where to place the data. It is possible to have flexibility. For example, the data access routine can retrieve the first name, gender (last name), and telephone number. User is surname (last name), first name (first name)
And wants to have the data in the order of telephone numbers, or wants to have the data in the order of first name, last name and telephone number. Changing the order of the data placed in the data object is achieved by having a table for each order of the table object 63, respectively. By transferring the parameters to the data access routine, one table in the table object 63 causes the first name to be placed first. The second table of the table object 63 sends a different set of parameters to allow the last name to be sent.
Name) is first placed in the data object.
Thus, if the order of first name, last name and telephone number is desired, the table associated with this particular order is called.

Greater flexibility is also achieved by using a data access routine that retrieves all columns of the relational database. A table object by transferring parameters to a data access routine that indicates which columns should be placed in the data object and in what order the selected columns should be placed in the data object 6
3 different tables and 1 for relational database
By using one data access routine, various combinations of data and ordering can be made.

For example, consider the case where the relational database contains names, telephone numbers and addresses. At some point, the user may need to make a call and only want to retrieve the name and phone number. At times, a user may want to search for a name and address, rather than a telephone number, to mail a document. In any case, the table of the table object 63 is used to transfer parameters to the data access routine in order to direct the routine as to what data should be placed in the data object and in what order. used.
This allows personalization of the data retrieval by setting the table object 63 to the desired specific format table without having to create a new set of data access routines. Thus, a single data access routine for a particular relational database can be used by multiple users.

In the above-described embodiment, data reading is described. However, the present invention can also be used for correcting data, adding data, or changing data. In order to modify the data under the embodiment shown in FIG. 3, the processing of the query fetch routine 76 is not necessary for the translator object 66, and the processing of the query open 74 is to change which data or To identify information about whether data should be added to relational database 80,
Includes more parameters.

[0036]

The invention makes it possible to access relational databases outside the object-oriented environment without leaving the object-oriented environment. In the present invention, a plurality of types of data access routine tables are stored, and a table having a data access routine for retrieving data corresponding to the data access message received from the requesting object is stored. Is selected from a plurality of types of tables stored in advance, a high-speed search can be performed even for a plurality of types of search requests in which data is arranged in different orders, for example.

[Brief description of the drawings]

FIG. 1 illustrates a distributed data processing system used to implement the method of the present invention.

FIG. 2 is a diagram for explaining a method of retrieving data from a relational database according to the method of the present invention.

FIG. 3 is a block diagram for retrieving data from a relational database written in the language of Smalltalk V / PM.

[Explanation of symbols]

 8 Data Processing System 10, 32 Local Area Network 12, 30 Computer 14, 20 Storage 16 Printer 18 Mainframe Computer 24, 34 Communication Link 26 Subsystem Control Unit / Communication Controller 28 Gateway Server 40 Address Book Window 42 Entry Icon 46 Address Book Record 48, 80 Relational Database 50 Interface 52 Address Book Record Window 60 Requester Object 62 Table Open 63 Table Object 64 Contents Retrieval Routine 66 Translator Object 68 Query Open Routine 70 Query Retrieval Routine 72 Commit Routine

 ──────────────────────────────────────────────────続 き Continuing on the front page (72) Inventor Kathy J. Cavendish, 7715 La Verdra Drive, Dallas, Texas, USA Cruces, Gladys Drive, number 15 1625 (56) Reference US Patent 4930071 (US, A) Communications of the ACM Vol. 33, No. 11 (1990-11) p. 99-109

Claims (2)

(57) [Claims] 1. A data processing apparatus for accessing a relational database outside an object-oriented environment in response to a data access message from a request source object in an object-oriented environment whose data structure is pointed to by a pointer. Storage means for storing a plurality of types of data access routine tables; receiving means for receiving a data access message from the request source object; and data for retrieving data corresponding to the data access message. Selecting means for selecting a table having an access routine from a plurality of types of tables stored in the storage means; creating means for creating a data object including instance variables in an object-oriented environment for holding data; The selected text Transmitting means for transmitting a command to a data access routine for accessing the relational database corresponding to the table, receiving means for receiving a result of access to the relational database from the data access routine, A data processing apparatus for accessing a relational database, comprising: arranging means for arranging a result in a data object; and transmitting means for transmitting a pointer to the data object to a requesting object. 2. A method for accessing a relational database outside an object-oriented environment in response to a data access message from a requesting object within the object-oriented environment pointed to by a pointer to a data structure, the method comprising: Storing a data access routine table of a type; receiving a data access message from the requesting object; and a data access routine for retrieving data corresponding to the data access message. Selecting a table having the following from the plurality of types of tables: creating a data object including instance variables in an object-oriented environment for retaining data; and storing the relational database corresponding to the selected table. Access Sending a command to a data access routine for receiving a result of the access to the relational database from the data access routine; placing the result of the access in a data object; Sending a pointer to the object to the requesting object; and accessing the relational database.