US 5,202,981 AGrant
Process and Apparatus for Manipulating a Boundless Data Stream in an Object Oriented Programming System
Issue Date:1993-04-13
•50 Claims
•14 Drawing Sheets
Abstract
A process and apparatus for manipulating boundless data streams in an object oriented programming system provides a stream class of objects which includes as attributes an ordered list of object references to selected ones of the data objects stored in the data storage device. Methods for manipulating the object include move to first, move to last, move to next and move to previous which provide a bi-directional data stream. The data appears to the user as though it resides entirely in memory, even though it does not. The stream class implements a "sliding window" in an object oriented programming system which permits manipulation of any number of lists of virtually unlimited size when remaining within the physical limitations of finite storage.
Metadata
Assignee
- International Business Machines Corporation
Inventor
- Floyd W. Shackelford
Application Information
Application Number:US 4258134
Filing Date:1989-10-23
Priority Date:1989-10-23
Art Unit:237
Classifications
IPC:
G06F 1540G06F 15403
Field of Search:
395364600;425;700;62419
Patent Drawings (14 sheets)
Description
FIELD OF THE INVENTION
This invention relates to object oriented programming systems and more particularly to a method and apparatus for manipulating a boundless data stream in an object oriented programming system.
BACKGROUND OF THE INVENTION
Object Oriented Programming systems and processes have been the subject of much investigation and interest in state of the art data processing environments. Object Oriented Programming is a computer program packaging technique which provides reusable and easily expandable programs. In contrast with known functional programming techniques which are not easily adaptable to new functional requirements and new types of data, object oriented programs are reusable and expandable as new requirements arise. With the ever increasing complexity of computer based systems, object oriented programming has received increased attention and investigation.
In an object oriented programming system, the primary focus is on data, rather than functions. Object oriented programming systems are composed of a large number of "objects" An object is a data structure and a set of operations or functions that can access that data structure. The data structure may be represented as a "frame". The frame has many "slots", each of which contains an "attribute" of the data in the slot. The attribute may be a primitive (i.e. an integer or string) or an Object Reference which is a pointer to the object's instance or instances (defined below). Each operation (function) that can access the data structure is called a "method".
FIG. 1 illustrates a schematic representation of an object in which a frame is encapsulated within its methods. FIG. 2 illustrates an example of an object, in which the data structure relates to employee data, and a number of methods surround this data structure. One method, for example, obtains the age of an employee. Each defined object will usually be manifested in a number of instances. Each instance contains the particular data structure for a particular example of the object. For example, an object for individual employee named Joyce Smith is an instance of the "employee" object.
Object oriented programming systems provide two primary characteristics which allow flexible and reusable programs to be developed. These characteristics are referred to as "encapsulation" and "inheritance". As may be seen from FIG. 1, the frame (data set) is encapsulated by its methods (functions). A wall of code has been placed around each piece of data. All access to the frame is handled by the surrounding methods. Data independence is thereby provided because an object's data structure is accessed only by its methods. Only the associated methods know the internal data structure. This ensures data integrity.
The "inheritance" property of object oriented programming systems allows previously written programs to be broadened by creating new superclasses and subclasses of objects. New objects are described by how they differ from preexisting objects so that entirely new programs need not be written to handle new types of data or functions.
FIG. 3 illustrates the inheritance property. For ease of illustration, the objects are illustrated as rectangles rather than as circles, with the object name at the top of a rectangle, the frame below the object name and the methods below the frame. Referring to FIG. 3, three object classes are illustrated for "salesperson", "employee" and "person", where a salesperson is a "kind of" employee, which is a "kind of" person. In other words, salesperson is a subclass of employee and employee is the superclass of salesperson. Similarly, employee is the subclass of person and person is the superclass of employee. Each class shown includes three instances. B. Soutter, W. Tipp and B. G. Blue are salespersons. B. Abraham, K. Yates and R. Moore are employees. J. McEnro, R. Nader and R. Reagan are persons. In other words, an instance is related to its class by an "is a" relation.
Each subclass "inherits" the frame and methods of its superclass. Thus, for example, a salesperson frame inherits age and hire date objects from the employee superclass as well as print and promote methods. Salesperson also includes a unique quota attribute and a pay commission method. Each instance can access all methods and frames of its superclass, so that, for example, B. G. Blue can be promoted.
In an object oriented system, a high level routine requests an object to perform one of its methods by sending the object a "message" telling the object what to do. The receiving object responds to the message by choosing the method that implements the message name, executing this method and then returning control to the calling high level routine, along with the results of the method.
Object oriented programming systems may be employed as database management systems which are capable of operating upon a large database, and which are expendable and adaptable. In an object oriented database management system, the data in the database is organized and encapsulated in terms of objects, with the instances of the objects being the data in the database. Similarly, the database manager may be organized as a set of objects with database management operations being performed by sending messages from one object to another. The target object performs the requested action on its attributes using its methods.
As described above, object oriented database management systems typically operate on large databases. However, it is difficult to manipulate the large database, or a large subset of the database which results from a database query, in order to view, update or delete selected elements therefrom. From a system perspective, the object oriented database, or the large query results, are a "boundless" data stream which is too large to fit in the system's memory, or into the portion of the system's memory allocated to an individual user.
As is well known to those having skill in the art, a data processor typically includes internal, volatile memory, often referred to as random access memory (RAM) or simply as "memory", which is available to the system for data manipulation. For multiuser systems, memory is typically divided among the users. Due to physical memory limitations, each user is limited to a maximum size of data stream which can be manipulated. In order to allow manipulation of data streams which exceed the maximum size, more memory must be provided, or a mechanism must be provided which creates the appearance of manipulating a boundless data stream without exceeding the physical limitations of the data processing environment.
Attempts have been made in prior art functionally programmed database management systems to provide the appearance of access to a boundless data stream by providing a "cursor" For example, in the Structured Query Language (SQL) database management system marketed by IBM Corporation as program product number 5470-XYR, a "cursor" is provided. The cursor is a file which provides forward pointers to a larger data stream. These forward pointers allow the data to be manipulated in the forward direction as one very large data stream. Operation of a cursor in an SQL database system is described in a publication entitled "IBM Database 2 Version 2 SQL Reference Release 1", IBM publication number SC26-4380-0, the disclosure of which is incorporated herein by reference.
Unfortunately an SQL cursor only allows a boundless data stream to be accessed or "scrolled" in the forward direction. Data manipulation often requires backward scrolling as well. In other words, bidirectional scrolling is required. Moreover, one particular SQL cursor may only be employed by one user at one time. Unfortunately, large database management systems often require multiuser capability. Finally, the SQL cursor is implemented in a functionally programmed database management system. A process and apparatus for bidirectional, multiuser manipulation of a boundless data stream in an object oriented database management system has heretofore not been available.
SUMMARY OF THE INVENTION
It is therefore an object of the invention to provide a process and apparatus for manipulating a boundless data stream.
It is another object of the invention to provide a process and apparatus for manipulating a boundless data stream in an object oriented programming system.
It is still another object of the invention to provide a process and apparatus for bidirectionally scrolling a boundless data stream in an object oriented programming system.
It is yet another object of the present invention to provide a process and apparatus for allowing a single user to bidirectionally scroll multiple instances of the same boundless data stream in an object oriented programming system.
These and other objects are provided by the present invention in an object oriented database management system including a data storage device having a database of data objects stored thereon and an object oriented database manager operating in a data processor connected to the data storage device. According to the invention, the object oriented database manager includes a "stream" class of objects. Each time a boundless data stream is manipulated by a user, an instance of the stream class is created.
The stream class of the present invention includes attributes and methods for allowing a boundless data stream to be manipulated bidirectionally by one user without
exceeding the physical limitations of the user's environment. In particular, the stream class attributes include a number of pointers which identify sequential data objects selected from the database, and an attribute which identifies the maximum number of pointers permitted. The maximum number of pointers is limited by the amount of memory available to the user of the stream class instance. In effect, the attributes of the stream class create a "window" into the database for the user, with the maximum size of the window being determined by the amount of memory available to the user.
It will be understood by those having skill in the art that the pointer in the stream attributes may point directly to (i.e. directly identify) data objects in the database. Alternatively, the pointers may point to (identify) data objects in a large data stream produced as a result of a query to a database. In fact, the pointers may point to data elements in an SQL cursor. Each pointer in the stream class attribute may also indirectly point to the data elements in the database by pointing to a stream element which includes therein one or more data elements from the database. Alternatively, each pointer in the stream class attribute may point to a stream element which in turn contains a pointer to one or more data elements from the database. In other words, direct or indirect pointing may be employed.
According to the invention, an instance of the stream class is created when a user desires to manipulate a boundless data stream. The instance will contain space for a number of pointers, the maximum number of which is determined by the amount of available memory.
The data attributes of the stream class of the present invention also include an identification of a current one of the pointers, with the current pointer changing in response to a user request. Thus, each instance of the stream class will include a current value identification of one of the pointers in the set of pointers in the stream class instance.
The stream class of the present invention also includes methods associated therewith. In particular, "move to next" and "move to previous" methods are included. The "move to next" method changes the pointers in the stream class instance attributes to include the data element immediately following the current data element, and to include neighboring data elements of the immediately following data element in the remaining pointers, so that pointers to sequential data elements are included in the stream instance. When the maximum number of pointers are already present in the stream class instance, at least one pointer must be deleted before the immediately following data element may be inserted. Similarly, the "move to previous" method changes the pointers in the stream class instance attributes to include the data element immediately preceding the current data element, and to include neighboring elements of the immediately preceding data element in the remaining pointers, so that pointers to sequential data elements are included in the stream instance. When the maximum number of pointers are already present in the stream class instance, at least one pointer must be deleted before the immediately preceding data element may be inserted. The stream instance thereby provides a "sliding window" into the large data stream, with the sliding window including a desired data element, and as many surrounding data elements as are possible, consistent with the user's memory allocation.
The stream class of the present invention also includes methods to "move to first" and "move to last". In these methods, the pointers in the stream instance attributes are changed to include the first and last stream elements, respectively, and following or remaining elements respectively, up to the maximum allowed names of pointers. The stream class may also include an attribute defining the maximum number of data elements to be read each time the database is physically accessed, to thereby provide input/output buffering. In a preferred embodiment, the maximum number of pointers in the stream class instance attribute is preferably an integer multiple of the maximum number of data elements which can be read by the system at one time. The number of elements in the window is thereby a function of the number of elements which may be physically accessed at one time.
BRIEF DESCRIPTION OF THE DRAWINGS
FIG. 1 illustrates a schematic representation of an object.
FIG. 2 illustrates a schematic representation of an example of an object.
FIG. 3 illustrates the inheritance property of objects.
FIG. 4 illustrates a schematic block diagram of an object oriented computer system according to the present invention.
FIG. 5 illustrates a schematic block diagram of an object oriented program according to the present invention.
FIG. 6 illustrates a representation of the stream class of the present invention.
FIG. 7 illustrates a representation of the stream class of the present invention, as it appears to a user.
FIG. 8 illustrates a representation of the maximum size of a stream class of the present invention.
FIG. 9 illustrates input/output buffering in a stream class of the present invention.
FIG. 10 illustrates stream elements in a stream class of the present invention.
FIG. 11 illustrates a current value pointer in a stream class of the present invention.
FIGS. 12 through 15 illustrate a stream class of the present invention at various stages during operation of a first example of the present invention.
FIG. 16 through 29 illustrate a stream class of the present invention at various stages during operation o a second example of the present invention.
FIGS. 30 through 34 illustrate a stream class of the present invention at various stages during operation of a third example of the present invention.
FIGS. 35 through 40 illustrate a stream class of the present invention at various stages during operation of a fourth example of the present invention.
DESCRIPTION OF THE PREFERRED EMBODIMENT
The present invention now will be described more fully hereinafter with reference to the accompanying drawings, in which a preferred embodiment of the invention is shown. This invention may, however, be embodied in many different forms and should not be construed as limited to the embodiment set forth herein; rather, this embodiment is provided so that this disclosure will be thorough and complete, and will fully convey the scope of the invention to those skilled in the art. Like numbers refer to like elements throughout.
OBJECT ORIENTED COMPUTER SYSTEM
In an object oriented computer system, work is accomplished by sending action request messages to an object which contains (encapsulates) data. The object will perform the requested action on the data according to its predefined methods. The requestor of the action need not know what the actual data looks like or how the object manipulates it.
An object's class defines the types and meanings of the data and the action requests (messages) that the object will honor. The individual objects containing data are called instances of the class. Classes generally relate to real-world things. For example, "Parts" may be a class. The data elements (slots) of a part might be a part number, a status and a part type. The instances of this class represent individual parts, each with its own part number, status, and type information. The programs performing the requested actions are called methods of the class.
Object classes can be defined to be subclasses of other classes. Subclasses inherit all the data characteristics and methods of the parent class. They can add additional data and methods, and they can override (redefine) any data elements or methods of the parent class. While most messages are sent to object instances, the message that requests that a new instance be created is sent to an object class. The class will cause a new instance to be created and will return an object identifier by which that object will be known.
The sender of an action request message need not know the exact class of the object to which it is sending the message. As long as the target object either defines a method to handle the message or has a parent class that defines such a method, then the message will be handled using the data in the object instance and the method in its class or its parent class. In fact, it need not be an immediate parent, but may be a parent's parent, etc. The sender of the method need only have the object ID of the receiving object. This property of object oriented systems is called "inheritance". The inheritance property is used in the present invention.
Referring now to FIG. 4, a schematic block diagram of an object oriented computer system 10 is illustrated. The system 10 includes a data processor 11 which may be a mainframe computer, minicomputer or personal computer. For large databases having multiple users, a mainframe computer is typically employed. As is well known to those having skill in the art, the data processor 10 includes a volatile data storage device 13, typically random access memory (RAM) for providing a working store for active data and intermediate results. Data in RAM 13 is erased when power to the data processor 11 is removed or a new user session is begun. System 10 also includes a nonvolatile data storage device 14 for permanent storage of objects. Device 14 may be a direct access storage device (DASD-a disk file) a tape file, an erasable optical disk or other well known device. Nonvolatile data storage device 14 will also be referred to herein as a "database". Volatile data storage device 13 will also be referred to as "memory". A display terminal 15 including a cathode ray tube (CRT) or other display, and a keyboard, is also shown.
An object oriented operating program 12 is also including in data processor 11. Object oriented operating program 12 may be programmed in object oriented languages such as "C" or "Smalltalk" or variations thereof, or in conventional programming languages such as FORTRAN or COBOL. The design of an object oriented operating program 12 is well known to those skilled in the art of object oriented programming systems, and will only be described generally below.
Referring now to FIG. 5, the main components of an object oriented program (12, FIG. 4) will be described. A more detailed description of the design and operation of an object oriented program is provided in "Object Oriented Software Construction", by Bertrand Meyer, published by Prentice Hall in 1988, the disclosure of which is incorporated herein by reference.
Referring to FIG. 5, object oriented program 12 includes three primary components: a Messenger 51, an Object Management Table 52 and a Loaded Classes Table 53. The Messenger 51 controls communication between calling and called messages, Object Management Table 52 and Loaded Classes Table 53. Object Management Table 52 contains a list of pointers to all active object instances. The Loaded Classes Table 53 contains a list of pointers to all methods of active object classes.
Operation of the Object Oriented Program 12 will now be described for the example illustrated in FIG. 5, in which Method A (block 54) of an object sends a message to Method B (block 55) of an object. Method A sends a message to Method B by calling Messenger 51. Messenger 51 obtains a pointer to the data frame 56 of the instance object specified by Method A, by searching Object Management Table 52 for the instance object. If the specified instance object cannot be found, Object Management Table 52 adds the instance object to the table and calls the instance to materialize its data from the database. Once in the instance table, Object Management Table 52 returns the pointer to the materialized instance object.
Messenger 51 then obtains the address of Method B from the Loaded Classes Table 53. If the instance's class is not loaded, the Loaded Classes Table 53 will load it at this time to materialize its data. The Loaded Classes Table 53 searches for the specified method (Method B) and returns the address of the method to Messenger 51.
The Messenger 51 then calls Method B, passing it a system data area and the parameters from the call made by Method A including the pointer. Method B accesses the data frame 56 using the pointer. Method B then returns control to the Messenger 51 Which returns control to Method A.
BOUNDLESS DATA STREAM
Inherent within object oriented database
Inherent management systems is the necessity to easily manipulate very large amounts of data. Due to the physical limitations of the computer and its operating system, each user is limited to a finite amount of storage. This, in turn, limits the amount of data which can be in memory at any one moment. In order to increase the volume of accessible data, either more memory must be allocated to the application or a mechanism is needed which provides the appearance of access to a very large volume of data while still remaining within the physical limitations of the user's environment. The present invention, a process and apparatus of manipulating boundless data streams, provides the user with the ability to manipulate any number of lists of virtually unlimited size in a finite amount of storage. This invention expands on the "cursor" known to those skilled in the art which permits only uni-directional access to data and which is non-recursive in that the data can only be used once by a single user at any single point in time, e.g. the SQL cursor.
The boundless data steam expands upon the capabilities of a "cursor" by providing more flexible navigation, i.e. bidirectional movement. Memory and I/0 optimization in the boundless data stream can be customized to meet the requirements of a particular application in various ways including altering the size of the stream as well as the amount of data read into memory from the cursor at one time. Furthermore, the data stream transparently manages multiple data streams against the same "cursor" Thus, the boundless data stream reduces the amount of computer application code necessary to manipulate a "cursor" while providing a superior interface to the data.
In an object oriented programming system, according to the present invention, the boundless data stream is an infinitely long linked list of object references. The physical structure of the data stream in memory may be represented as illustrated in FIG. 6. The large, outer stream box 21 is the maximum amount of memory utilized by the stream. The smaller, inner stream boxes 22 are the number of rows read from the cursor 23 at any one time. The arrows show the direction in which one may access the data. The stream, however, logically appears to the user as a bi-directional cursor. This is illustrated in FIG. 7 where the arrows show the direction in which one may access the data. The rows appear in groups of two because, in this example, the data will be read into the stream two elements at a time. This number is arbitrary and can be designated by the user in order to optimize I/O.
In an object oriented programming system, the boundless data stream may be implemented by two object classes, namely the Stream class and the Stream Element class. The Stream Element class is where the actual data is stored about the individual data objects for which the stream was developed. It could be something as simple as an object ID to a join of any number of objects. These appear in memory only while the Stream class needs them. They are discarded and recreated as memory requirements dictate.
The Stream class is composed of a linked list of object references to Stream Elements. Additionally, it has all those methods necessary for converting a "cursor" or any other similar uni-directional database access mechanism into a boundless linked list. This linked list allows both forward and backward movement and transparently handles all the cursor interfacing. Essentially, a user just moves up and down the Stream and accesses the data directly. The Stream handles all the cursor opens, closes, and positioning as well as all the memory management chores. Thus, for all practical purposes, the Stream appears to the user as a "smart" linked list. That is, all the data within the Stream appears automatically. The user need only reference it.
The Stream class allows a user to create any number of lists based upon the same cursor. The user can move to the first, last, next, or previous elements. In addition, the user can specify the maximum number of Stream Elements to maintain in memory at any one time. He also can specify the number of elements to be read with each physical access of the database, i.e. designate I/O buffer size. Finally, the user can refresh the list at any time with a single instruction so that the list contains the current, updated value of the data as stored in the database.
Some of the attributes and methods of the stream class and stream element class of the present invention will now be described in detail.
STREAM CLASS--ATTRIBUTES
Max.sub.-- List.sub.-- Size
Max.sub.-- List.sub.-- Size, an instance attribute (sometimes referred to as maximum attribute), permits the user to specify the maximum number of elements to keep in the linked list in RAM at any one time. Through its use, the overall memory requirements of a stream are reduced. For example, if the number of elements in the list is equal to Max.sub.-- List.sub.-- Size and an additional element is to be added to the end of the list, then a Delete.sub.-- First is done by the Move.sub.-- to.sub.-- Next method. The default value for Max.sub.-- List.sub.-- Size is LONG.sub.-- MAX. Where Max.sub.-- List.sub.-- Size is reduced to less than this default, it is desirable to set the new value to a multiple of the Number.sub.-- to.sub.-- Read instance attribute. It is preferable to use an integer multiple greater than 1 such as 10 or 100 times Number.sub.-- to.sub.-- Read.
Number.sub.-- to.sub.-- Read
Number.sub.-- to.sub.-- Read attribute (sometimes referred to as Number.sub.-- to.sub.-- Read number attribute) is the number of rows to be read from the cursor at any one time, i.e. the small box 22 in FIG. 6. This may also be called Buffer.sub.-- Size. By reading a set number of rows at any given time, physical I/O performance is optimized.
Nb.sub.-- Elements
The Nb.sub.-- Elements instance attribute contains the total number of elements in the logical linked list. It has three states:
`zero`
Nb.sub.-- Elements is set to "zero" when the stream has just been created but the database has not been accessed.
`Unknown.sub.-- Nb.sub.-- Elem` (999999999)
This is known as the "unknown" state since although elements have been read from the database, the actual end of the logical linked list has not been reached, i.e. the end of the cursor has not been reached.
`Known`
This state is the actual number of elements in the logical linked list. This state comes in to existence only when the end of the cursor has been reached, and only then can it be assigned to Nb.sub.-- Elements.
An alternative embodiment adds an additional select statement which actually returns the count of the number of elements which will meet the selection criteria and assign that value at that time.
Current.sub.-- Cursor
The Current.sub.-- Cursor instance attribute is used to The Current indicate which cursor is the active cursor for the stream instance. Although it is possible to define any number of cursors within a particular stream class, any stream instance can only use one cursor within a particular stream class at a time.
Current.sub.-- Value.sub.-- Pointer Current.sub.-- Value.sub.-- Pointer (sometimes referred to as current attribute) is the OREF to the Current Stream Element in the linked list.
Row.sub.-- Count
Row.sub.-- Count refers to the count of the rows in the database or in the result of the selection criteria.
STREAM CLASS--METHODS
Current.sub.-- Value
The Current.sub.-- Value instance method, returns the OREF to the current Stream Element in the linked list.
Move.sub.-- to.sub.-- First
The Move.sub.-- to.sub.-- First instance method positions the user at the first element in the logical linked list.
Move.sub.-- to.sub.-- Last
The Move.sub.-- to.sub.-- Last instance method positions the user at the last element in the logical linked list.
Move.sub.-- to.sub.-- Next
The Move.sub.-- to.sub.-- Next instance method positions the user at the next element in the logical linked list.
Move.sub.-- to.sub.-- Prev
The Move.sub.-- to.sub.-- Prev instance method positions the user at the previous element in the logical linked list.
Restart
The Restart instance method closes the physical database access link, i.e. the "cursor". It deletes all stream elements from memory and clears out the physical linked list. Finally, it resets the stream instance attributes to their original state. In other words, it forces the stream to refresh itself without having to delete it and create a new stream instance.
Reopen
The reopen method reopens a closed cursor and sets the pointer to the beginning of the cursor.
Other methods and attributes which are utilized to implement the above methods will be described in the examples which follow.
STREAM ELEMENT CLASS--ATTRIBUTES
Object.sub.-- Id
The Object.sub.-- Id instance attribute is an OREF to any object.
STREAM ELEMENT CLASS--METHODS
Create
This method creates a new Stream Element object.
Initialize
This method stores the values in the Stream Element object's instance attributes
DETAILED DESCRIPTION OF STREAM AND STREAM ELEMENT CLASS METHODS
Examples are now presented to illustrate the operation of the invention. Example 1 describes the move to first method which manipulates the data stream to set the current value pointer to point at the first element in the cursor. Example 2 describes the move to last method which manipulates the data stream to set the current value pointer to point at the last element in the cursor. Example 3 describes the move to next method which manipulates the data stream to set the current value pointer to point at the next element in the cursor. Example 4 describes the move to previous method which manipulates the data stream to set the current value pointer to point at the previous element in the cursor.
For purposes of these examples, arbitrary values are chosen for various attributes including Max.sub.-- List.sub.-- Size=12, Number.sub.-- to.sub.-- Read=4, and 19 rows in the database meet the selection criteria. In all examples, the term "database" is used to refer to nonvolatile data storage device 14 (FIG. 4). The terms "RAM" and "memory" are used to refer to a volatile data storage device 13 (FIG. 4).
The term "row" refers to an entry in a database table. It can represent either the physical row in the database table or the row as stored in memory. Thus, it is sometimes used interchangeably with the term Stream Element. "Stream Element" refers to an object instance which is pointed to by an object reference (OREF) within the physical list. OREF's are commonly used in object oriented programming systems to point to an instance of an object. Stream Elements are the memory images of rows retrieved from the database.
"Logical list", "logical linked list", or "virtual list" is the entire list as defined by the cursor's selection criteria against the physical database table(s). This is the list which "appears" to the user to be in memory but in reality is not. If instance attribute Max.sub.-- List.sub.-- Size, were set to infinity and all rows from the cursor could be placed into memory at one time, then the logical list would be the same as the physical list. "Physical list", "physical linked list", or "actual list" refer to the actual in-memory linked list used to track the Stream Elements. This is the "sliding window" of the database. Its size is the number of elements in this linked list is bounded by: 1.ltoreq.number of elements in the physical list.ltoreq.Max.sub.-- List.sub.-- Size.
"Maximum list size" or "max-size" refer to the value defined by the Max.sub.-- List.sub.-- Size instance attribute. This is the maximum number of rows in memory at any one time. If the number of rows in the physical list exceeds this number, the first row in the physical list must be removed from memory before an additional row may be added at the end of the physical list. "Number to read", "read buffer", "burst mode read", or "burst read" refer to the value defined by the Number.sub.-- to.sub.-- Read instance attribute. A certain number of rows are read each time the stream must access the database with I/O commands. Since most database access mechanisms provide for some sort of data buffering, selection of the buffer size for this burst read optimizes the utilization of the database's buffering.
The reserved word SELF appears throughout the examples. As is well known to those having skill in the art, the use of SELF in an expression having a method and object denotes the current instance of the class. The function of SELF in the present invention denotes the current instance of the Stream Class.
Deferred methods also appear throughout the examples. As is well known to those having skill in the art, a deferred method which is defined by a class but is only implemented by the dependents (children) of the class. The function of the deferred method is precisely specified by the Stream Class of the present invention, although it is implemented by children of the Stream Class.
Memory utilization at a particular time ("flash points") are also conceptually represented in the Examples. The data stream is illustrated as a vertical box as shown, for example in FIG. 6 and 7. The memory occupied by the physical list is illustrated as a long horizontal box as depicted in FIG. 8. It will hold at most Max.sub.-- List.sub.-- Size elements. The memory occupied by the elements read in any one burst mode from the database will be shown as a short horizontal box, usually within the physical list box, as illustrated in FIG. 9. Each burst mode box will hold a maximum of Number.sub.-- to.sub.-- Read elements.
As illustrated in FIG. 10, row numbers will often be seen within the burst read boxes to demonstrate which rows, i.e. stream elements, are in memory at that time. Finally, the current value pointer will be represented by a vertical arrowhead underneath the physical list. As illustrated in FIG. 11, it will point to the current element. In this figure, it is pointing to element 05.
EXAMPLE 1--MOVE TO FIRST
As a first example, assume that there is a stream My.sub.-- Stream which has already been created but has not yet been accessed. The physical list in memory is illustrated in FIG. 12. This example will load the first Number.sub.-- to.sub.-- Read elements which the buffer can hold. Once these are in the physical list, the current value pointer is set to point to the first element.
A user of My.sub.-- Stream issues a call to the Move.sub.-- to.sub.-- First method, and the Move.sub.-- to.sub.-- First method receives control. This call can be represented as:
My.sub.-- Stream.Move.sub.-- to.sub.-- First
The Move.sub.-- to.sub.-- First method determines that this is the first time the stream has been accessed. Thus, it makes a call to the stream's Load.sub.-- Next method. Load.sub.-- Next invokes the Fetch.sub.-- Row method to retrieve a stream element. Fetch.sub.-- Row now receives control. It determines that this is the first time this stream has been accessed and issues a call to the Open method. Open receives control and invokes the deferred method for the appropriate database query language to open the stream. This deferred method receives control.
The operation to this point can be illustrated on the program invocation stack as:
My.sub.-- Stream.Move.sub.-- to.sub.-- First, which in turn called
SELF.Load.sub.-- Next, which in turn called
SELF.Fetch.sub.-- Row, which in turn called
SELF.Open, which in turn called
SELF.database.sub.-- query.sub.-- language.sub.-- Open
The deferred method loads the relevant search criteria and opens the actual data cursor, i.e. cursor 23 in FIG. 6. It then returns a result code to its caller. Assuming that the open by the deferred method is successful, OK is returned to the caller, i.e. the Open method. Open determines that the open was successful and initializes instance attributes. Cursor Status is set to `open` and Nb.sub.-- Elements is set to Unknown.sub.-- Nb.sub.-- Elems. The Row.sub.-- Count instance attribute is set to 0. Open then returns to its caller, i.e. Fetch.sub.-- Row. Fetch.sub.-- Row now issues a call to the database.sub.-- query.sub.-- language to Fetch, i.e. to get a stream element. Fetch receives control. The program invocation stack can be illustrated as:
My.sub.-- Stream.Move.sub.-- to.sub.-- First, which in turn called
SELF.Load.sub.-- Next, which in turn called
SELF.Fetch.sub.-- Row, which in turn called
SELF.database.sub.13 query.sub.-- language.sub.-- Open
The deferred Fetch routine fetches cursor row 01 into the appropriate host variables and issues a call to the Stream Element's Create method. The Stream Element's Create method creates an instance of the Stream Element and invokes the Initialize method. The program invocation stack can be illustrated as:
My.sub.-- Stream.Move.sub.-- to.sub.-- First, which in turn called
SELF.Load.sub.-- Next, which in turn called
SELF.Fetch.sub.-- Row, which in turn called
SELF.datatbase.sub.-- query.sub.-- language.sub.-- Fetch, which in turn called
Stream.sub.-- Element.Create, which in turn called
Stream.sub.-- Element.Initialize.
The Stream Element s Initialize method stores the values in its instance attributes and returns to the Create method. The Stream Element's Create method returns control to its caller, database.sub.-- query.sub.-- language.sub.-- Fetch. Fetch returns the OREF of the newly created Stream Element to its caller, Fetch.sub.-- Row. The Fetch.sub.-- Row method increments the Row.sub.-- Count instance attribute from 0 to 1 and returns control to its caller, Load.sub.-- Next.
The Load.sub.-- Next method adds the stream element to the end of the list which is currently empty. The physical list is illustrated in FIG. 13. The Load.sub.-- Next method then invokes Fetch.sub.-- Row and adds the resultant stream element to the physical list three more times, for a total of Number.sub.-- to.sub.-- Read times, in this example, 4 times. The physical list can be represented in FIG. 14.
Load.sub.-- Next has caused Number.sub.-- to.sub.-- Read, i.e. 4, rows to be read from the database. It now returns control to its caller, Move.sub.-- to.sub.-- First. At this point, the Current.sub.-- Value.sub.-- Pointer is undefined. Thus, the Move.sub.-- to.sub.-- First method now establishes the Current.sub.-- Value.sub.-- Pointer to point to the first element in the list. The physical list is illustrated in FIG. 15. Note that 4 elements were read in at one time in a single burst. These are illustrated in FIG. 15 in the burst read box (read buffer). The Current.sub.-- Value.sub.-- Pointer is pointing to the first element, stream element 01.
EXAMPLE 2--MOVE TO LAST
For the second example, again assume that there is a stream My.sub.-- Stream which has already been created but has not yet been accessed. The physical list is illustrated in FIG. 16. This example reads in the elements a buffer at a time. Since the size of memory is 12 and buffer size is 4, three buffers will be read. Another buffer is read. Memory is then full. The first element in memory will be deleted end of memory. This will be repeated until the buffer is empty. Another buffer will be read from the database. Elements from the front of the physical list will be deleted and Elements from the buffer will be added to the end of the physical list. This process will continue until the end of the cursor is reached. The Current.sub.-- Value.sub.-- Pointer will then be set to point to the last element in the physical list.
A user of My.sub.-- Stream issues a call to the Move.sub.-- to.sub.-- Last method and the Move.sub.-- to.sub.-- Last method receives control. The call can be represented as:
My.sub.-- Stream.Move.sub.-- to.sub.-- Last
Move.sub.-- to.sub.-- Last determines that this is the first time the stream has been accessed. Thus, it calls the stream's Load.sub.-- Next method. Load.sub.-- Next invokes the Fetch.sub.-- Row method to retrieve a stream element. Fetch.sub.-- Row receives control. It determines that this is the first time this stream has been accessed and calls the Open method. Open receives control and invokes the deferred database.sub.-- query.sub.-- language.sub.-- Open method. This deferred Open method receives control. The program invocation stack can be represented as:
My.sub.-- Stream.Move.sub.-- to.sub.-- Last, which in turn called
SELF.Load.sub.-- Next, which in turn called
SELF.Fetch.sub.-- Row, which in turn called
SELF.Open, which in turn called
SELF.database.sub.-- query.sub.-- language.sub.-- Open
Deferred Open loads the relevant search criteria and opens the actual data cursor, i.e. cursor 23 in FIG. 6. It then returns a result code to its caller, Open. Assuming that the open is successful, OK is returned to the caller, Open. Open determines that the open was successful and initializes the instance attributes. Cursor Status is set to `open` and Nb.sub.-- Elements is set to Unknown.sub.-- Nb.sub.-- Elems. The Row.sub.-- Count instance attribute is set to 0. Open then returns control to its caller, Fetch.sub.-- Row. Fetch.sub.-- Row calls database.sub.-- query.sub.-- language.sub.-- Fetch, to get a stream element. Fetch receives control. The program invocation stack can be represented as:
My.sub.-- Stream.Move.sub.-- to.sub.-- Last, which in turn called
SELF.Load.sub.-- Next, which in turn called
SELF.Fetch.sub.-- Row, which in turn called
SELF.database.sub.-- query.sub.-- language.sub.-- Fetch
Fetch fetches cursor row 01 into the appropriate host variables and issues a call to the Stream Element's Create method. The Stream Element's Create method creates an instance of the stream element and invokes the Initialize method. The program invocation stack can be represented as:
My.sub.-- Stream.Move.sub.-- to.sub.-- Last, which in turn called
SELF.Load.sub.-- Next, which in turn called
SELF.Fetch.sub.-- Row, which in turn called
SELF.database.sub.-- query.sub.-- language.sub.-- Fetch, which in turn called
Stream.sub.-- Element.Create, which in turn called
Stream.sub.-- Element.Initialize.
The Stream Element's Initialize method stores the values in its instance attributes and returns control to the Create method. The Stream Element's Create method returns control to its caller database.sub.-- query.sub.-- language.sub.-- Fetch. Fetch returns the OREF of the newly created Stream Element to its caller, Fetch.sub.-- Row. Fetch.sub.-- Row increments the Row.sub.-- Count instance attribute from 0 to 1 and returns control to its caller, Load.sub.-- Next.
The Load.sub.-- Next method adds Stream Element 01, i.e. Stream Element from Row 01 of the database selected results, to the end of the list which is currently empty. The physical list is illustrated in FIG. 17. Load.sub.-- Next then invokes Fetch.sub.-- Row and adds the resultant stream element to the physical list three more times, for a total of Number.sub.-- to.sub.-- Read times, i.e. 4 times. Thus, 4 elements are read in a single burst. The physical list can is illustrated in FIG. 18.
Load.sub.-- Next has caused Number.sub.-- to.sub.-- Read rows, i.e. 4 rows, to be read from the database. It now returns control to its caller, Move.sub.-- to.sub.-- Last. Move.sub.-- to.sub.-- Last determines that the end of the cursor has not been reached. Thus, it calls the Load.sub.-- Next method again, to load the next Number.sub.-- to.sub.-- Read block of rows. Load.sub.-- Next invokes the Fetch.sub.-- Row method to retrieve a stream element. Fetch.sub.-- Row calls database.sub.-- query.sub.-- language.sub.-- Fetch, to get a stream element. Fetch receives control. The program invocation stack can be represented as:
My.sub.-- Stream.Move.sub.-- to.sub.-- Last, which in turn called
SELF.Load.sub.-- Next, which in turn called
SELF.Fetch.sub.-- Row, which in turn called
SELF.database.sub.-- query.sub.-- language.sub.-- Fetch.
Fetch fetches cursor row 05 into the appropriate host variables and issues a call to the Stream Element's Create method. The Stream Element's Create method creates an instance of the Stream Element and invokes the Initialize method. The program invocation stack can now be represented as:
My.sub.-- Stream.Move.sub.-- to.sub.-- Last, which in turn called
SELF.Load.sub.-- Next, which in turn called
SELF.Fetch.sub.-- Row, which in turn called
SELF.database.sub.-- query.sub.-- language.sub.-- Fetch, which in turn called
Stream.sub.-- Element.Create, which in turn called
Stream.sub.-- Element.Initialize.
The Stream Element's Initialize method stores the values in its instance attributes and returns control to its caller, the Create method. The Stream Element's Create method returns control to its caller, database.sub.-- query.sub.-- language.sub.-- Fetch. The Fetch routine returns the OREF of the newly created Stream Element to its caller, Fetch.sub.-- Row.
Fetch.sub.-- Row increments the Row.sub.-- Count instance attribute from 4 to 5 and returns control to its caller, Load.sub.-- Next. Load.sub.-- Next adds the 05 Stream Element, i.e. the element from row 5 of the cursor, to the end of the list. The physical list is illustrated in FIG. 19. Load.sub.-- Next then invokes Fetch.sub.-- Row and adds the resultant stream element to the physical list three more times, for a total of Number.sub.-- to.sub.-- Read times, i.e. 4 times. This is because 4 elements are read in a single burst. The physical list is illustrated in FIG. 20. Load.sub.-- Next has caused Number.sub.-- to.sub.-- Read rows, i.e. 4 rows, to be read from the database. It now returns control to its caller, Move.sub.-- to.sub.-- Last.
Move.sub.-- to.sub.-- Last determines that the end of the cursor has not been reached. Thus, it calls the Load.sub.-- Next method again, to load the next Number.sub.-- to.sub.-- Read block of rows, i.e. 4 rows. The Load.sub.-- Next invokes the Fetch.sub.-- Row method to retrieve a stream element. Fetch.sub.-- Row issues a call to database.sub.-- query.sub.-- language.sub.-- Fetch. Fetch receives control. The program invocation stack can be represented as:
My.sub.-- Stream.Move.sub.-- to.sub.-- Last, which in turn called
SELF.Load.sub.-- Next, which in turn called
SELF.Fetch.sub.-- Row, which in turn called
SELF.database.sub.-- query.sub.-- language.sub.-- Fetch.
Fetch fetches cursor row 09 into the appropriate host variables and issues a call to the Stream Element's Create method. The Stream Element's Create method creates an instance of the Stream Element and invokes the Initialize method. The program invocation stack can be represented as:
My.sub.-- Stream.Move.sub.-- to.sub.-- Last, which in turn called
SELF.Load.sub.-- Next, which in turn called
SELF.Fetch.sub.-- Row, which in turn called
SELF.database.sub.-- query.sub.-- language.sub.-- Fetch, which in turn called
Stream.sub.-- Element.Create, which in turn called
Stream.sub.-- Element.Initialize.
The Stream Element's Initialize method stores the values in its instance attributes and returns control to the Create method. The Stream Element's Create method returns control to its caller, database.sub.-- query.sub.-- language.sub.-- Fetch. Fetch returns the OREF of the newly created Stream Element to its caller, Fetch.sub.-- Row.
Fetch.sub.-- Row increments the Row.sub.-- Count instance attribute from 8 to 9 and returns control to its caller, Load.sub.-- Next. Load.sub.-- Next adds the 09 Stream Element to the end of the list. The physical list is illustrated in FIG. 21.
Load.sub.-- next then invokes Fetch.sub.-- Row and adds the resultant Stream Element to the physical list three more times, for a total of Number.sub.-- to.sub.-- Read times, i.e. 4 times. This is because 4 rows are read in a single burst. The physical list is illustrated in FIG. 22. Load.sub.-- Next has caused Number.sub.-- to.sub.-- Read rows, i.e. 4 rows, to be read from the database. It now returns control to its caller, Move.sub.-- to.sub.-- Last.
Move.sub.-- to.sub.-- Last determines that the end of the cursor has not been reached, so it issues a call to the Load.sub.-- Next method again, to load the next Number.sub.-- to.sub.-- Read block of rows, i.e. 4 rows. Load.sub.-- Next invokes Fetch.sub.-- Row to retrieve a stream element. Fetch.sub.-- Row calls database.sub.-- query.sub.-- language.sub.-- Fetch, to get a Stream Element. Fetch receives control. The program invocation can be represented as:
My.sub.-- Stream.Move.sub.-- to.sub.-- Last, which in turn called
SELF.Load.sub.-- Next, which in turn called
SELF.Fetch.sub.-- Row, which in turn called
SELF.database.sub.-- query.sub.-- language.sub.-- Fetch.
Fetch fetches cursor row 13 into the appropriate host variables and issues a call to the Stream Element's Create method. The Stream Element's Create method creates an instance of the Stream Element and invokes the Initialize method. The program invocation stack can be represented as:
My.sub.-- Stream.Move.sub.-- to.sub.-- Last, which in turn called
SELF.Load.sub.-- Next, which in turn called
SELF.Fetch.sub.-- Row, which in turn called
SELF.database.sub.-- query.sub.-- language.sub.-- Fetch, which in turn called
Stream.sub.-- Element.Create, which in turn called
Stream.sub.-- Element.Initialize.
The Stream Element's Initialized method stores the values in its instance attributes and returns control to the
Create method. The Stream Element's Create method returns control to its caller, Fetch. The Fetch routine returns the OREF of the newly created Stream Element to its caller, Fetch.sub.-- Row.
The Fetch.sub.-- Row method increments the Row.sub.-- Count instance attribute from 12 to 13 and returns control to its caller, Load Next. Load.sub.-- Next determines that the physical list has reached the Max.sub.-- List.sub.-- Size boundary, so it deletes the first element off the list. The physical list is illustrated in FIG. 23. Load.sub.-- Next next adds the stream element to the end of the list. The physical list is illustrated in FIG. 24. Notice that no more than a total of Max.sub.-- List.sub.-- Size, i.e. 12, elements are in the list at any one time.
Load.sub.-- Next invokes Fetch.sub.-- Row and drops off the front elements and adds the resultant Stream Elements to the physical list three more times, for a total of Number.sub.-- to.sub.-- Read times. As is well known to those having skill in the art, elements are deleted from the front of a list by freeing the memory. The physical list is illustrated in FIG. 25. Load.sub.-- Next has caused Number.sub.-- to.sub.-- Read rows, i.e. 4 rows, to be read from the database. It now returns control to its caller, Move.sub.-- to.sub.-- Last.
Move.sub.-- to.sub.-- Last determines that the end of the cursor still has not been reached. Thus, it calls the Load.sub.-- Next method again, to load the next Number.sub.-- to.sub.-- Read block of rows, i.e. 4 rows. Load.sub.-- Next invokes Fetch.sub.-- Row to retrieve a Stream Element. Fetch.sub.-- Row calls database.sub.-- query.sub.-- language.sub.-- Fetch, to get a Stream Element. Fetch receives control. The program invocation stack can be represented as:
My.sub.-- Stream.Move.sub.-- to.sub.-- Last, which in turn called
SELF.Load.sub.-- Next, which in turn called
SELF.Fetch.sub.-- Row, which in turn called
SELF.database.sub.-- query.sub.-- language.sub.-- Fetch.
Fetch fetches cursor row 17 into the appropriate host variables and issues a call to the Stream Element's Create method. The Stream Element's Create method creates an instance of the Stream Element and invokes the Initialize method. The program invocation stack can be represented as:
My.sub.-- Stream.Move.sub.-- to.sub.-- Last, which in turn called
SELF.Load.sub.-- Next, which in turn called
SELF.Fetch.sub.-- Row, which in turn called
SELF.database.sub.-- query.sub.-- language.sub.-- Fetch, which in turn called
Stream.sub.-- Element.Create, which in turn called
Stream.sub.-- Element.Initialize.
The Stream Element's Initialize method stores the values in its instance attributes and returns control to the Create method. The Stream Element's Create method returns control to its caller, Fetch. Fetch returns the OREF of the newly created Stream Element to its caller, Fetch.sub.-- Row.
Fetch.sub.-- Row increments the Row.sub.-- Count instance attribute from 16 to 17 and returns to its caller, Load.sub.-- Next. Load.sub.-- Next determines that the physical list has reached the Max.sub.-- List.sub.-- Size boundary, i.e. 12, so it deletes the first element off the list. The physical list is illustrated in FIG. 26. Load.sub.-- Next adds the stream element to the end of the list. The physical list is illustrated in FIG. 27. Notice that no more than a total of Max.sub.-- List.sub.-- Size, i.e. 12, elements are in the list at any one time. Load.sub.-- next invokes Fetch.sub.-- Row and drops off the front elements and adds the resultant Stream Element to the physical list two more times. The physical list is illustrated in FIG. 28.
The Load.sub.-- Next method invokes the Fetch.sub.-- Row method a fourth time. Load.sub.-- Next invokes the Fetch.sub.-- Row method to retrieve a Stream Element. Fetch.sub.-- Row calls database.sub.-- query.sub.-- language.sub.-- Fetch, to get a Stream Element. Fetch receives control. The program invocation stack can be represented as:
My.sub.-- Stream.Move.sub.-- to.sub.-- Last, which in turn called
SELF.Load.sub.-- Next, which in turn called
SELF.Fetch.sub.-- Row, which in turn called
SELF.database.sub.-- query.sub.-- language.sub.-- Fetch.
Fetch receives an End.sub.-- of.sub.-- Cursor from the fetch and returns control to Fetch.sub.-- Row with the appropriate indicator. The Fetch.sub.-- Row method sets Nb.sub.-- Elements equal to Row.sub.-- Count, sets the Cursor Status attribute to End.sub.-- of.sub.-- Cursor and returns control to its caller, Load.sub.-- Next. The Load.sub.-- Next method determines that the cursor has been closed from the value in Cursor Status and returns control to its caller, Move.sub.-- to.sub.-- Last, without modifying the physical list. The Move.sub.-- to.sub.-- Last method determines that the end of the cursor has now been reached. Since the Current.sub.-- Value.sub.-- Pointer is currently undefined, Move.sub.-- to.sub.-- Last establishes the Current.sub.-- Value.sub.-- Pointer to point to the last element in the list. The physical list is illustrated in FIG. 29. Note that there are only Max.sub.-- Size.sub.-- List elements, i.e. 12 elements, in the list. Also note that the Current.sub.-- Value.sub.-- Pointer is pointing to the last element, i.e. the element from row 19 in the result of the database selection.
EXAMPLE 3--MOVE TO NEXT
For purposes of this example, assume that a partial list is currently in memory. The physical list is illustrated in FIG. 30 shows where the maximum 12 elements (Max.sub.-- List.sub.-- Size) are in memory and the Current.sub.-- Value.sub.-- Pointer is pointing to the last element in the physical list, i.e. the element from the row 16 in the database. In this example, since the Current.sub.-- Value.sub.-- Pointer is pointing to the last element will be read from the cursor into the buffer. Elements will be deleted from the front of the physical list and added to the end of the physical list from the buffer, one at a time until the contents of the entire buffer is in the physical list. The Current.sub.-- Value.sub.-- Pointer will then be set to point to the next element in the physical list.
A user of My.sub.-- Stream issues a call to the Move.sub.-- to.sub.-- Next method and the Move.sub.-- to.sub.-- Next method receives control. The call can be represented as:
My.sub.-- Stream.Move.sub.-- to.sub.-- Next (End.sub.-- of.sub.-- List.sub.-- Indicator)
End.sub.-- of.sub.-- List.sub.-- Indicator is passed as a parameter and is assigned a state as control is returned. Move.sub.-- to.sub.-- Next determines that the Current.sub.-- Value.sub.-- Pointer is on the last element, i.e. the 12th element, in the physical list and also that the End.sub.-- of.sub.-- the.sub.-- Cursor has not been reached. Thus, it invokes Load.sub.-- Next to load in the next buffer, i.e. 4 elements, from a single burst. Load.sub.-- Next invokes the Fetch.sub.-- Row method to retrieve a Stream Element. Fetch.sub.-- Row calls database.sub.-- query.sub.-- language.sub.-- Fetch, to get a stream Element. Fetch receives control. The program invocation stack can be represented as:
My.sub.-- Stream.Move.sub.-- to.sub.-- Next, which in turn called
SELF.Load.sub.-- Next, which in turn called
SELF.Fetch.sub.-- Row, which in turn called
SELF.database.sub.-- query.sub.-- language.sub.--Fetch.
Fetch fetches cursor row 17 into the appropriate host variables and issues a call to the Stream Element's Create method. The Stream Element's Create method creates an instance of the Stream Element and invokes the Initialize method. The program invocation stack can be represented as:
My.sub.-- Stream.Move.sub.-- to.sub.-- Next, which in turn called
SELF.Load.sub.-- Next, which in turn called
SELF.Fetch.sub.-- Row, which in turn called
SELF.database.sub.-- query.sub.-- language.sub.-- Fetch, which in turn called
Stream.sub.-- Element.Create, which in turn called
Stream.sub.-- Element.Initialize.
The Stream Element's Initialize method stores the values in its instance attributes and returns control to the control to its caller, Fetch. Fetch returns the OREF of the newly created Stream Element to its caller, Fetch.sub.-- Row.
The Fetch.sub.-- Row method increments the Row.sub.-- Count instance attribute from 16 to 17 and returns control to its caller, Load.sub.-- next. The Load.sub.-- Next method determines that the physical list has reached the Max.sub.-- List.sub.-- Size boundary, i.e. 12 elements. Thus, it deletes the first element off the list. The physical list is illustrated in FIG. 31.
The Load.sub.-- Next method adds the Stream Element to the end of the list. The physical list is illustrated in FIG. 32. Notice that no more than a total of Max.sub.-- List.sub.-- Size, i.e. 12, elements are in the list at any one time. The Load.sub.-- Next method then invokes Fetch.sub.-- Row and drops off the front elements and adds the resultant Stream Element to the physical list two more times. The physical list is illustrated in FIG. 33.
The Load.sub.-- Next method invokes the Fetch.sub.-- Row method a fourth time. The Load.sub.-- Next invokes the Fetch.sub.-- Row method to retrieve a Stream Element. Fetch.sub.-- Row calls database.sub.-- query.sub.-- language.sub.-- Fetch, to get a Stream Element. Fetch receives control. The program invocation stack can be represented as:
My.sub.-- Stream.Move.sub.-- to.sub.-- Next, which in turn called
SELF.Load.sub.-- Next, which in turn called
SELF.Fetch.sub.-- Row, which in turn called
SELF.database.sub.-- query.sub.-- language.sub.-- Fetch.
Fetch receives an End.sub.-- of.sub.-- Cursor from the fetch and returns control to Fetch.sub.-- Row with the appropriate End.sub.-- of.sub.-- Cursor indicator. The Fetch.sub.-- Row method sets the Cursor.sub.-- Status attribute to End.sub.-- of.sub.-- Cursor and returns control to its caller, Load.sub.-- Next. The Load.sub.-- Next method determines that the cursor has been closed from the value in Cursor.sub.-- Status and returns control to its caller, Move.sub.-- to.sub.-- Next, without modifying the physical list. The Move.sub.-- to.sub.-- Next method then moves the Current.sub.-- Value.sub.-- Pointer to the next element in the list, i.e. the element that was row 17 in the database. The physical list is illustrated in FIG. 34. Notice that there are Max.sub.-- Size.sub.-- List elements, i.e. 12 elements, in the physical list and the current value pointer is pointing to the element which was in row 17 in the database.
EXAMPLE 4--MOVE TO PREV
For purposes of this example, assume that a partial list is currently in memory with the Current.sub.-- Value.sub.-- Pointer pointing to the first element of the list. The physical list is illustrated in FIG. 35. In this example, it will be determined that Current.sub.-- Value.sub.-- Pointer is set to the first element of the physical list. The cursor pointer will be determined. All elements in the physical list will be deleted. The cursor will then be closed. The cursor will be reopened with the pointer pointing to the beginning of the cursor. Memory will be loaded with elements a Number.sub.-- to.sub.-- Read elements at a time. The Current.sub.-- Value.sub.-- Pointer will then be set to point to the previous element in memory (the physical list).
A user of My.sub.-- Stream issues a call to the Move.sub.-- to.sub.-- Prev method and the Move.sub.-- to.sub.-- Prev method receives control. The call can be represented as:
My.sub.-- Stream.Move.sub.-- to.sub.-- Prev (End.sub.-- of.sub.-- List.sub.-- Indicator)
End.sub.-- of.sub.-- List.sub.-- Indicator is passed as a parameter and is assigned its state as control is returned. The Move.sub.-- to.sub.-- Prev method determines that the Current.sub.-- Value.sub.-- Pointer is on the first element in the physical list and that some elements have previously been dropped from the beginning of the list. This is determined by comparing Row.sub.-- Count to Max.sub.-- List.sub.-- Size. If it is greater, then some elements have been deleted from the beginning of the list. Thus, it invokes Load.sub.-- Prev to load in the previous buffer. The Load.sub.-- Prev method determines the physical row number of the element as it resided in the result of the database selection immediately preceding the first element in the physical list, i.e. row number 4. It then closes the cursor by calling the Close method.
Close calls the database.sub.-- query.sub.-- language.sub.-- Close method. If there is more than one cursor open, database.sub.-- query.sub.-- language.sub.-- Close determines which is open, closes it, and returns control to the Close method. Close returns control to its caller, Load.sub.-- Prev. The Load.sub.-- Prev method then deletes all the physical list elements and frees memory. The physical list is illustrated in FIG. 36.
The Load.sub.-- Prev method then executes the Load.sub.-- Next method for Max.sub.-- List.sub.-- Size/Number.sub.-- to.sub.-- Read times since Max.sub.-- List.sub.-- Size is 12 and Number.sub.-- to.sub.-- Read is 4, Load.sub.-- Prev executes Load.sub.-- Next 3 times. For the first of the 3 times, Load.sub.-- Next receives control on the first loop and invokes the Fetch.sub.-- Row method to retrieve a Stream Element. Fetch.sub.-- Row calls database.sub.-- query.sub.-- language.sub.-- Fetch, to get a Stream Element. Fetch receives control. The program invocation stack can be represented as:
My.sub.-- Stream.Move.sub.-- to.sub.-- Prev, which in turn called
SELF.Load.sub.-- Prev, which in turn called
SELF.Load.sub.-- Next, which in turn called
SELF.Fetch.sub.-- Row, which in turn called
SELF.database.sub.-- query.sub.-- language.sub.--Fetch.
Fetch finds that the cursor is closed and returns to its caller with an appropriate closed cursor indication. The Fetch.sub.-- Row method, upon finding that the cursor is closed, calls the Reopen method to reopen and reposition the cursor. The Reopen method opens the cursor and positions the pointer to the beginning of the cursor. It then returns to the Fetch.sub.-- Row method.
Fetch.sub.-- Row now issues a call to itself to call database.sub.-- query.sub.-- language.sub.-- Fetch, to get a Stream Element. Fetch receives control. The program invocation stack can be represented as:
My.sub.-- Stream.Move.sub.-- to.sub.-- Prev, which in turn called
SELF.Load.sub.-- Prev, which in turn called
SELF.Load.sub.-- Next, which in turn called
SELF.Fetch.sub.-- Row, which in turn called
SELF.Fetch.sub.-- Row, which in turn called
SELF.database.sub.-- query.sub.-- language.sub.--Fetch.
Fetch fetches cursor row 01 into the appropriate host variables and issues a call to the Stream Element's Create method. The Stream Element's Create method creates an instance of the Stream Element and invokes the Initialize method. The program invocation stack can be represented as:
My.sub.-- Stream.Move.sub.-- to.sub.-- Prev, which in turn called
SELF.Load.sub.-- Prev, which in turn called
SELF.Load.sub.-- Next, which in turn called
SELF.Fetch.sub.-- Row, which in turn called
SELF.Fetch.sub.-- Row, which in turn called
SELF.database.sub.-- query.sub.-- language.sub.-- Fetch, which in turn called
Stream.sub.-- Element.Create, which in turn called
Stream.sub.-- Element.Initialize.
The Stream Element's Initialize routine stores the values in its instance attributes and returns to the Create method.
The Stream Element's Create method returns control to its caller, database.sub.-- query.sub.-- language.sub.-- Fetch. Fetch returns the OREF of the newly created Stream Element to its caller, the second Fetch.sub.-- Row. The second Fetch.sub.-- Row method increments the Row.sub.-- Count instance attribute from 0 to 1 and returns control to its caller, the first Fetch.sub.-- Row. The first Fetch.sub.-- Row returns control to Load.sub.-- Next.
The Load.sub.-- Next method adds the Stream Element to the end of the list, which is currently empty. The physical list is illustrated in FIG. 37. The Load.sub.-- Next method then invokes Fetch.sub.-- Row and adds the resultant Stream Element to the physical list three more times, for a total of Number.sub.-- to.sub.-- Read times. The physical list is illustrated in FIG. 38. Load.sub.-- Next has caused Number.sub.-- to.sub.-- Read rows, i.e.. 4 rows, to be read from the database since Number.sub.-- To.sub.-- Read is 4. It returns control to its caller, Load.sub.-- Prev. Load.sub.-- Prev invokes Load.sub.-- Next two more times, for a total of three times. The physical list is illustrated in FIG. 39. Load.sub.-- Next is called 3 times because Max.sub.-- List.sub.-- Size is 12 and Number.sub.-- to.sub.-- Read is 4.
Load.sub.-- Prev now returns control to its caller, Move.sub.-- to.sub.-- Prev. The Move.sub.-- to.sub.-- Prev method positions the Current.sub.-- Value.sub.-- Pointer to the appropriate element in the list. The physical list is illustrated in FIG. 40. Notice that the Current.sub.-- Value.sub.-- Pointer is pointing to the element from the 4th row in the database, i.e. one before the row number from the database which the pointer pointed to in the physical list (row 5).
PSEUDO CODE APPENDIX A--STREAM CLASS
The following Appendix contains a pseudo code listing of an implementation of the stream class of the present invention in an object oriented computer system. The pseudo code listing is designed to operate with IBM's well-known Structured Query Language (SQL). ##SPC1##
PSEUDO CODE APPENDIX B--STREAM ELEMENT CLASS
The following Appendix contains a pseudo code listing of an implementation of the stream class of the present invention in an object oriented computer system. The pseudo code listing is designed to operate with IBM's well-known Structured Query Language (SQL). ##SPC2##
In the drawings and specification, there have been disclosed typical preferred embodiments of the invention and, although specific terms are employed, they are used in a generic and descriptive sense only and not for purposes of limitation, the scope of the invention being set forth in the following claims.
Claims
Certificate of Correction present
The claims shown below may not include correction changes. Use the corrected PDF for authoritative text.
That which we claim is:
1. A method for bidirectionally accessing data in a database management system comprising a data storage device, a database of a first plurality of data elements stored in the data storage device, a data processor connected to the data storage device, said data processor executing a database manager for converting a plurality of unidirectional pointers into bidirectional pointers to manipulate said first plurality of data elements; said bidirectional access method comprising the steps of: accepting a query request; processing the accepted query request to obtain a second plurality of pointers to a second plurality of data elements selected from said first plurality of data elements as a result of said query; creating a file in said data storage device for storing said second plurality of pointers therein in a predetermined sequence, from a first to a last pointer, said file allowing only unidirectional access to said second plurality of pointers, from said first to said last pointers; accepting a request to manipulate said second plurality of data elements, including a selected one of said second plurality of data elements; creating a data window in said data storage device, for storing therein a third plurality of pointers selected from said second plurality of pointers stored in said file allowing only unidirectional access to said second plurality of pointers; storing the selected third plurality of pointers in said data window, the selected third plurality of pointers comprising a third plurality of sequential pointers from said second plurality of pointers stored in said file allowing only unidirectional access to said second plurality of pointers, including a pointer to said selected one of said second plurality of data elements; and bidirectionally accessing said third plurality of pointers stored in said data window and selected from said second plurality of pointers stored in said file allowing only unidirectional access to said second plurality of pointers.
2. The method of claim 1 wherein said query request accepting step comprises the step of accepting a request to manipulate a first data element in said file and wherein said storing step comprises the step of storing a third plurality of sequential pointers from said second plurality of pointers, beginning with said first pointer.
3. The method of claim 1 wherein said query request accepting step comprises the step of accepting a request to manipulate a last data element in said file and wherein said storing step comprises the step of storing a third plurality of sequential pointers from said second plurality of pointers, ending with said last pointer.
4. The method of claim 1 wherein said query request accepting step comprises the step of accepting a request to manipulate a next data element in said file and wherein said storing step comprises the step of storing a third plurality of sequential pointers from said second plurality of pointers, including a pointer to said next data element.
5. The method of claim 1 wherein said query request accepting step comprises the step of accepting a request to manipulate a previous data element in said file and wherein said storing step comprises the step of storing a third plurality of sequential pointers from said second plurality of pointers, including said next data element.
6. The method of claim 3 wherein said storing step further comprises the step of repeatedly storing the third plurality of sequential pointers beginning with said first pointer, until said last pointer is stored.
7. A database management system comprising: a data storage device; a database of a first plurality of data elements stored in said data storage device; a data processor connected to said data storage device; and said data processing executing a database manager, for converting a plurality of unidirectional pointers into bidirectional pointers to manipulate said first plurality of data elements, comprising: means for accepting a query request; means for processing the accepted query request to obtain a second plurality of pointers to a second plurality of data elements selected from said first plurality of data elements as a result of said query; means for creating a file in said data storage device for storing said second plurality of pointers therein in a predetermined sequence, from a first to a last pointer, said file allowing only unidirectional access to said second plurality of pointers, from said first to said last pointers; means for accepting a request to manipulate said second plurality of data elements, including a selected one of said second plurality of data elements; means for creating a data window in said data storage device, for storing therein a third plurality of pointers selected from said second plurality of pointers stored in said file allowing only unidirectional access to said second plurality of pointers; means for storing the selected third plurality of pointers in the data window, the selected third plurality of pointers comprising a third plurality of sequential pointers from said second plurality of pointers stored in said file allowing only unidirectional access to said second plurality of pointers, including the pointer to said selected one of said plurality of said elements; and means for bidirectionally accessing said third plurality of pointers stored in said data window and selected from said second plurality of pointers stored in said file allowing only unidirectional access to said second plurality of pointers.
8. The system of claim 7 wherein said query request accepting means comprises means for accepting a request to manipulate a first data element in said file and wherein said means for storing comprises means for storing a third plurality of sequential pointers from said second plurality of pointers, beginning with said first pointer.
9. The system of claim 7 wherein said query request accepting means comprises means for accepting a request to manipulate a last data element in said file and wherein said means for storing comprises means for storing a third plurality of sequential pointers from said second plurality of pointers, beginning with said last pointer.
10. The system of claim 7 wherein said query request accepting means comprises means for accepting a request to manipulate a next data element in said file and wherein said means for storing comprises means for storing a continuous third plurality of sequential pointers from said second plurality of pointers, including a pointer to said next data element.
11. The system of claim 7 wherein said query request accepting means comprises means for accepting a request to manipulate a previous data element in said file and wherein said means for storing comprises means for storing a third plurality of sequential pointers from said second plurality of pointers, including a pointer to said previous data element.
12. The system of claim 9 wherein said means for storing further comprises means for storing a series of third pluralities of sequential pointers beginning with said first pointer, until said last pointer is stored.
13. The system of claim 7 wherein said file comprises a structured query language cursor.
14. A process for manipulating a data stream comprising a second plurality of data objects in an object oriented database management system comprising a data storage device, a database of a first plurality of data objects stored in said data storage device in a predetermined sequence, a data processor connected to said data storage device, said data processor executing an object oriented database manager, for manipulating said first plurality of data objects; said process comprising the steps of: providing a stream class of objects in said object oriented database manager, said stream class of objects including stream class attributes and stream class methods; said stream class attributes comprising: a second plurality of pointers for identifying a second plurality of data objects selected from said first plurality of data objects in said database; a current attribute for identifying a current one of said second plurality of pointers; and a maximum attribute for identifying the maximum number of pointers in said second plurality of pointers; said stream class methods comprising: a first method for placing in an instance of said stream class, a second plurality of pointers including a pointer for identifying a data object immediately preceding the data object identified in said current attribute; and a second method for placing in an instance of said stream class, a second plurality of pointers including a pointer for identifying a data object immediately succeeding the data object identified in said current attribute; creating an instance of a stream class object to manipulate said first plurality of data objects using said second plurality of pointers; and processing said instance of said stream class object on said data processor using said first and second stream class methods.
15. The process of claim 14 wherein said stream class methods further comprise: a third method for placing in an instance of said stream class, a second plurality of pointers including a pointer for identifying a first data object in the predetermined sequence of said first plurality of data objects; and a fourth method for placing in an instance of said stream class, a second plurality of pointers including a pointer for identifying a last data object in the predetermined sequence of said first plurality of data objects; and wherein said processing step further comprises processing said instance of said stream class object on said data processor using said third and fourth stream class methods.
16. The process of claim 14 wherein said second plurality of pointers directly identify said second plurality of data objects.
17. The process of claim 14 wherein said second plurality of pointers comprise said second plurality of data objects.
18. The process of claim 14 further comprising the step of creating a stream element class of objects, and creating a second plurality of instances of said stream element class of objects, a respective one of said second plurality of pointers identifying a respective one of said second plurality of instances of said stream element class.
19. The process of claim 18 wherein said second plurality of instances of said stream element class of objects includes a pointer for identifying a respective one of said second plurality of data objects.
20. The process of claim 18 wherein said second plurality of instances of said stream element class of objects comprises a respective one of said second plurality of data objects.
21. The process of claim 14 further comprising the step of selecting said maximum attribute to be less than or equal to the maximum number of pointers which may be stored in said data storage device.
22. The process of claim 14 wherein said first method performs the following steps: deleting at least one of said second plurality of pointers from said stream class attributes; and inserting said pointer for identifying a data object immediately preceding the data object identified in said current attribute, into said stream class attributes.
23. The process of claim 14 wherein said second method performs the following steps: deleting at least one said second plurality of pointers from said stream class attributes; and inserting said pointer for identifying a data object immediately succeeding the data object identified in said current attribute, into said stream class attributes.
24. The process of claim 15 wherein said third method performs the following steps: deleting all of said second plurality of pointers from said stream class attributes; and inserting said pointer for identifying said first data object into said second plurality of pointers.
25. The process of claim 15 wherein said third method performs the following steps: deleting all of said second plurality of pointers from said stream class attributes; and inserting a second plurality of pointers for identifying said stream class, with the inserted second plurality of pointers beginning with said first data object.
26. The process of claim 15 wherein said fourth method performs the following steps: deleting all of said second plurality of pointers from said stream class attributes; and inserting a second plurality of pointers for identifying said stream class, with the inserted second plurality of pointers ending with said last data object.
27. The process of claim 14 wherein said step of creating an instance comprises the step of creating an instance of said stream class object for each user of said object oriented database management system.
28. The process of claim 14 wherein said step of creating an instance comprises the step of creating an instance of said stream class object for each query of said database in said object oriented database management system.
29. An object oriented database management system comprising: a data storage device; a database of a first plurality of data objects stored in said data storage device in a predetermined sequence; a data processor connected to said data storage device; said data processing executing an object oriented database manager, for manipulating said first plurality of data objects, said object oriented database manager including a stream class of objects, said stream class of objects including stream class attributes and stream class methods; said stream class attributes comprising: a second plurality of pointers for identifying a second plurality of data objects selected from said first plurality of data objects in said database; a current attribute for identifying a current one of said second plurality of pointers; and a maximum attribute for identifying the maximum number of pointers in said second plurality of pointers; said stream class methods comprising: a first method for placing in an instance of said stream class, a second plurality of pointers including a pointer for identifying a data object immediately preceding the data object identified in said current attribute; and a second method for placing in an instance of said stream class, a second plurality of pointers including a pointer for identifying a data object immediately succeeding the data object identified in said current attribute; creating means, including in said object oriented database manager, for creating an instance of a stream class object; and stream class method processing means, included in said object oriented database manager, for processing said instance of said stream class object using said first and second stream class methods.
30. The object oriented database management system of claim 29 wherein said stream class methods further comprise: a third method for placing in an instance of said stream class, a second plurality of pointers including a pointer for identifying a first data object in the predetermined sequence of said first plurality of data objects; and a fourth method for placing in an instance of said stream class, a second plurality of pointers including a pointer for identifying a last data object in the predetermined sequence of said first plurality of data objects; and wherein said stream class method processing means also processes said instance of said stream class object using said third and fourth stream class methods.
31. The object oriented database management system of claim 29 wherein said database of data objects comprises a subset of a larger database of data objects, said first plurality of data objects resulting from a query of said larger database.
32. The object oriented database management system of claim 29 wherein said data storage device comprises a nonvolatile data storage device and wherein said database is stored in said nonvolatile data storage device.
33. The object oriented database management system of claim 29 wherein said data storage device comprises a volatile data storage device and wherein said database is stored in said volatile data storage device.
34. The object oriented database management system of claim 31 wherein said subset of a larger database comprises a cursor of said larger database.
35. The object oriented database management system of claim 29 wherein said second plurality of pointers directly identify said second plurality of data objects.
36. The object oriented database management system of claim 29 wherein said second plurality of pointers comprise said second plurality of data objects.
37. The object oriented database management system of claim 29 wherein said object oriented database manager further includes a stream element class of objects, and means for creating a second plurality of instances of said stream element class of objects, a respective one of said second plurality of pointers identifying a respective one of said second plurality of instances of said stream element class.
38. The object oriented database management system of claim 37 wherein said second plurality of instances of said stream element class of objects includes a pointer for identifying a respective one of said second plurality of data objects.
39. The object oriented database management system of claim 37 wherein said second plurality of instances of said stream element class of objects comprises a respective one of said second plurality of data objects.
40. The object oriented database management system of claim 29 wherein said maximum attribute is selected to be less than or equal to the maximum number of pointers which may be stored in said data storage device.
41. The object oriented database management system of claim 29 wherein said first method comprises: means for deleting at least one of said second plurality of pointers from said stream class attributes; and means for inserting said pointer for identifying a data object immediately preceding the data object identified in said current attribute, into said stream class attributes.
42. The object oriented database management system of claim 29 wherein said second method comprises: means for deleting at least one of said second plurality of pointers from said stream class attributes; and means for inserting said pointer for identifying a data object immediately succeeding the data object identified in said current attribute, into said stream class attributes.
43. The object oriented database management system of claim 30 wherein said third method comprises: means for deleting all of said second plurality of pointers from said stream class attributes; and means for inserting said pointer for identifying said first data object into said second plurality of pointers.
44. The object oriented database management system of claim 30 wherein said third method comprises: means for deleting all of said second plurality of pointers from said stream class attributes; and means for inserting a second plurality of pointers for identifying said stream class, with the inserted second plurality of pointers beginning with said first data object.
45. The object oriented database management claim 30 wherein said fourth method comprises: means for deleting all of said second plurality of pointers from said stream class attributes; and means for inserting a second plurality of pointers for identifying said stream class, with the inserted second plurality of pointers ending with said last data object.
46. The object oriented database management system of claim 29 wherein said second plurality of data objects comprises a second plurality of sequential data objects selected from said first plurality of data objects.
47. The object oriented database management system of claim 29 wherein said stream class attributes further comprise: a number attribute for identifying the number of said first plurality of objects to be read from said data storage device at one time.
48. The object oriented database management system of claim 47 wherein said maximum attribute is an integer multiple of said number attribute.
49. The object oriented database management system of claim 29 wherein said means for creating an instance comprises means for creating an instance of said stream class object for each user of said object oriented database management system.
50. The object oriented database management system of claim 29 wherein said means for creating an instance comprises means for creating an instance of said stream class object for each query of said database in said object oriented database management system.
Patent Citations (3)
Non-Patent Literature (1)
- Gray, S. N., "Notes on Database Operating Systems", In Operating Systems: An Advanced Course, ed. R. Bager et al., 1977, Chapter 3.f., 394-481.