Managing results of federated searches across heterogeneous datastores with a federated result set cursor object

Abstract

A method, apparatus, and article of manufacture for managing results of federated searches across heterogeneous datastores with a federated result set cursor object. One or more commands are executed in a computer to perform a datastore operation at a computer. Data is located in one or more datastores. A cursor is set to the located data in each datastore. A set of cursors to the located data is returned.

Claims

What is claimed is:

1. A method of executing one or more commands in a computer to perform a datastore operation at a computer, the method comprising the steps of:

locating data in one or more heterogeneous datastores;

setting a cursor to the located data in each heterogeneous datastore; and

returning a federated result set cursor object, said federated result set cursor object aggregating the cursors to the located data.

2. The method of claim 1, wherein one of the cursors is a federated cursor.

3. The method of claim 1, wherein one of the cursors is a native cursor.

4. The method of claim 1, further comprising receiving a fetch command to retrieve located data.

5. The method of claim 4, wherein the fetch command specifies one of the cursors.

6. The method of claim 5, further comprising retrieving located data identified by the specified cursor.

7. An apparatus for executing one or more commands in a computer, comprising:

a computer having a datastore; and

one or more computer programs, performed by the computer, for locating data in one or more heterogeneous datastores, setting a cursor to the located data in each heterogeneous datastore, and returning a federated result set cursor object, said federated result set cursor object aggregating the cursors to the located data.

8. The apparatus of claim 7, wherein one of the cursors is a federated cursor.

9. The apparatus of claim 7, wherein one of the cursors is a native cursor.

10. The apparatus of claim 7, further comprising receiving a fetch command to retrieve located data.

11. The apparatus of claim 10, wherein the fetch command specifies one of the cursors.

12. The apparatus of claim 11, further comprising retrieving located data identified by the specified cursor.

13. An article of manufacture comprising a program storage medium readable by a computer and embodying one or more instructions executable by the computer to perform method steps for executing one or more commands to perform a datastore operation at the computer, the method comprising the steps of:

locating data in one or more heterogeneous datastores;

setting a cursor to the located data in each heterogeneous datastore; and

returning a federated result set cursor object, said federated result set cursor object aggregating the cursors to the located data.

14. The article of manufacture of claim 13, wherein one of the cursors is a federated cursor.

15. The article of manufacture of claim 13, wherein one of the cursors is a native cursor.

16. The article of manufacture of claim 13, further comprising receiving a fetch command to retrieve located data.

17. The article of manufacture of claim 16, wherein the fetch command specifies one of the cursors.

18. The article of manufacture of claim 17, further comprising retrieving located data identified by the specified cursor.

Description

BACKGROUND OF THE INVENTION

1. Field of the Invention

This invention relates in general to database management systems performed by computers, and in particular, to managing results of federated searches across heterogeneous datastores with a federated result set cursor object.

2. Description of Related Art

The present invention relates to a system and method for representing and searching multiple heterogeneous datastores and managing the results of such searches. Datastore is a term used to refer to a generic data storage facility, such as a relational data base, flat-file, hierarchical data base, etc. Heterogeneous is a term used to indicate that the datastores need not be similar to each other. For example, each datastore may store different types of data, such as image or text, or each datastore may be based on a different theory of data model, such as Digital Library/VisualInfo or Domino Extended Search (DES).

For nearly half a century computers have been used by businesses to manage information such as numbers and text, mainly in the form of coded data. However, business data represents only a small part of the world's information. As storage, communication and information processing technologies advance, and as their costs come down, it becomes more feasible to digitize other various types of data, store large volumes of it, and be able to distribute it on demand to users at their place of business or home.

New digitization technologies have emerged in the last decade to digitize images, audio, and video, giving birth to a new type of digital multimedia information. These multimedia objects are quite different from the business data that computers managed in the past, and often require more advanced information management system infrastructures with new capabilities. Such systems are often called "digital libraries."

Bringing new digital technologies can do much more than just replace physical objects with their electronic representation. It enables instant access to information; supports fast, accurate, and powerful search mechanisms; provides, new "experiential" (i.e. virtual reality) user interfaces; and implements new ways of protecting the rights of information owners. These properties make digital library solutions even more attractive and acceptable not only to corporate IS organizations, but to the information owners, publishers and service providers.

Generally, business data is created by a business process (an airline ticket reservation, a deposit at the bank, and a claim processing at an insurance company are examples). Most of these processes have been automated by computers and produce business data in digital form (text and numbers). Therefore it is usually structured coded data. Multimedia data, on the contrary, cannot be fully pre-structured (its use is not fully predictable) because it is the result of the creation of a human being or the digitization of an object of the real world (x-rays, geophysical mapping, etc.) rather than a computer algorithm.

The average size of business data in digital form is relatively small. A banking record--including a customers name, address, phone number, account number, balance, etc.--represents at most a few hundred characters, i.e. few hundreds/thousands of bits. The digitization of multimedia information (image, audio, video) produces a large set of bits called an "object" or "blobs" (Binary Large Objects). For example, a digitized image of the parchments from the Vatican Library takes as much as the equivalent of 30 million characters (30 MB) to be stored. The digitization of a movie, even after compression, may take as much as the equivalent of several billions of characters (3-4 GB) to be stored.

Multimedia information is typically stored as much larger objects, ever increasing in quantity and therefore requiring special storage mechanisms. Classical business computer systems have not been designed to directly store such large objects. Specialized storage technologies may be required for certain types of information, e.g. media streamers for video or music. Because certain multimedia information needs to be preserved "forever" it also requires special storage management functions providing automated back-up and migration to new storage technologies as they become available and as old technologies become obsolete.

Finally, for performance reasons, the multimedia data is often placed in the proximity of the users with the system supporting multiple distributed object servers. This often requires a logical separation between applications, indices, and data to ensure independence from any changes in the location of the data.

The indexing of business data is often imbedded into the data itself. When the automated business process stores a person's name in the column "NAME," it actually indexes that information. Multimedia information objects usually do not contain indexing information. This "meta data" needs to be created in addition by developers or librarians. The indexing information for multimedia information is often kept in "business like" databases separated from the physical object.

In a Digital Library (DL), the multimedia object can be linked with the associated indexing information, since both are available in digital form. Integration of this legacy catalog information with the digitized object is crucial and is one of the great advantages of DL technology. Different types of objects can be categorized differently as appropriate for each object type. Existing standards like MARC records for libraries, Finding Aids for archiving of special collections, etc . . . can be used when appropriate.

The indexing information used for catalog searches in physical libraries is mostly what one can read on the covers of the books: authors name, title, publisher, ISBN, . . . enriched by other information created by librarians based on the content of the books (abstracts, subjects, keywords, . . . ). In digital libraries, the entire content of books, images, music, films, etc. are available and "new content" technologies are needed; technologies for full text searching, image content searching (searching based on color, texture, shape, etc . . . ), video content searching, and audio content searching. The integrated combination of catalog searches (e.g. SQL) with content searches will provide more powerful search and access functions. These technologies can also be used to partially automate further indexing, classification, and abstracting of objects based on content.

To harness the massive amounts of information spread throughout these networks, it has become necessary for a user to search numerous storage facilities at the same time without having to consider the particular implementation of each storage facility.

Object-oriented approaches are generally better suited for such complex data management. The term "object-oriented" refers to a software design method which uses "classes" and "objects" to model abstract or real objects. An "object" is the main building block of object-oriented programming, and is a programming unit which has both data and functionality (i.e., "methods"). A "class" defines the implementation of a particular kind of object, the variables and methods it uses, and the parent class it belongs to.

Some known programming tools that can be used for developing search and result-management frameworks include IBM VisualAge C++, Microsoft Visual C++, Microsoft Visual J++, and Java. A result set cursor is a feature supported by modern database management systems, such as relational databases (e.g., DB2, Oracle, Sybase, Informix, etc.). A result set cursor is an indicator that indicates the location of data. All conventional result set cursors are flat in that they provide a single cursor to the retrieved data. Consequently, all implementations of result set cursors in the above mentioned frameworks are also flat implementations.

There is a need in the art for an improved federated system. In particular, there is a need in the art for managing results of federated searches across heterogeneous datastores with a federated result set cursor object.

SUMMARY OF THE INVENTION

To overcome the limitations in the prior art described above, and to overcome other limitations that will become apparent upon reading and understanding the present specification, the present invention discloses a method, apparatus, and article of manufacture for managing results of federated searches across heterogeneous datastores with a federated result set cursor object.

According to an embodiment of the invention, one or more commands are executed in a computer to perform a datastore operation at a computer. Data is located in one or more datastores. A cursor is set to the located data in each datastore. A set of cursors to the located data is returned.

BRIEF DESCRIPTION OF THE DRAWINGS

Referring now to the drawings in which like reference numbers represent corresponding parts throughout:

FIG. 1 is a diagram illustrating a computer architecture that could be used in accordance with the present invention;

FIG. 2 is a diagram illustrating a class hierarchy for Data Object classes;

FIG. 3 is a diagram illustrating a class hierarchy for Datastore classes;

FIG. 4 is a diagram illustrating a conceptual view of a federated result set cursor object;

FIG. 5 is a diagram of an extended Grand Portal architecture;

FIG. 6 is a diagram illustrating individual datastores and federated compositions;

FIG. 7 is a diagram illustrating a conceptual view of a federated result set cursor object

FIG. 8 is a diagram illustrating one use of the present invention;

FIG. 9 is a flow diagram illustrating steps performed by a federated datastore to process a query; and

FIG. 10 is a flow diagram illustrating steps performed by a federated datastore to process a fetch.

DETAILED DESCRIPTION OF THE PREFERRED EMBODIMENT

In the following description of the preferred embodiment, reference is made to the accompanying drawings which form a part hereof, and in which is shown by way of illustration a specific embodiment in which the invention may be practiced. It is to be understood that other embodiments may be utilized and structural and functional changes may be made without departing from the scope of the present invention.

Federated Architecture

FIG. 1 is a diagram illustrating a computer architecture that could be used in accordance with the present invention. The present invention is described herein by way of example and is not intended to be limited to the described embodiment. The description of the preferred embodiment is based on, but certainly not limited to, the IBM design of Java Grand Portal Class Library, the Digital Library Java Application Programming Interface (API).

The Java Grand Portal 120 is comprised of client and server classes. In particular, Java Grand Portal is a set of Java classes which provides access and manipulation of local or remote data stored in Digital Library storage facilities. It uses Java APIs based on OMG-Object Query Services (OQS) and a Dynamic Data Object protocol, which is a part of OMG/Persistence Object Services.

The Java APIs provide multi-search capabilities such as:

1. Searching within a given datastore using one or a combination of supported query types, i.e.

Parametric query--Queries requiring an exact match on the condition specified in the query predicate and the data values stored in the datastore.

Text query--Queries on the content of text fields for approximate match with the given text search expression, e.g. the existence (or non-existence) of certain phrases or word-stems.

Image query--Queries on the content of image fields for approximate match with the given image search expression, e.g. image with certain degree of similarity based on color percentages, layout, or texture.

2. Each search type is supported by one or more search-engines.

3. Searching on the results of a previous search.

4. Searching involving heterogeneous datastores.

The Digital Library Grand Portal classes provide a convenient API for Java application users; the applications can be located at local or remote sites. Java classes will typically reside on both server and client sides; both sides providing the same interface. The client side of Java classes communicates with the server side to access data in the Digital Library through the network. Communication between client and server sides is done by these classes; it is not necessary to add any additional programs.

In particular, FIG. 1 is an architectural diagram outlining the structure of the federated search for Digital Library repositories using the federated datastore 100, comprised of a federated datastore client and server. A federated datastore 100 is a virtual datastore which combines several heterogeneous datastores 102 into a consistent and unified conceptual view. This view, or a federated schema, is established via schema mapping 104 of the underlying datastores. The users interact with a federated datastore 100 using the federated schema, without needing to know about the individual datastores 102 which participate in the federated datastore 100.

One embodiment of the invention provides a federated result set cursor object across heterogeneous datastores. In one embodiment of the invention, one or more classes implement the federated result set cursor object, and one or more methods are provided to manipulate the federated result set cursor object. In one embodiment, the class definitions and methods reside at the federated datastore client and server.

The federated datastore 100 does not have a corresponding back-end client. Since it is a virtual datastore, the federated datastore 100 relies on the underlying physical back-end client associated with it, such as the DL client (i.e., Digital Library client), OnDemand, VisualInfo, DB2, etc. Digital Library, OnDemand, VisualInfo, and DB2 are all products from International Business Machines Corporation. As mentioned before, this association is established by a schema mapping component 104.

The communication between the federated datastore 100 client and server can be done by any appropriate protocol. On top of Java Grand Portal client classes, the users can develop application programs using, for example, any existing Java Beans 122 development environment.

The federated datastore 100 coordinates query evaluation, data-access, and transaction processing of the participating heterogeneous datastores 102. Given the federated schema, a multi-search query can be formulated, executed, and coordinated to produce results in the form of a datastore-neutral dynamic data object.

Note that each heterogeneous datastore and the federated datastore are created using one datastore definition or superclass. The federated datastore 100 and the heterogeneous datastores 102 are all subclasses of a class called Datastore, therefore, all of these datastores 100 and 102 have the same interface. Therefore, a user would be able to access the federated datastore 100 and the heterogeneous datastores 102 in a consistent and uniform manner.

Additionally, the objects stored in the federated datastore 100 and the heterogeneous datastores 102 are subclasses of a Data Object class. The Data Object class includes subclasses for dynamic data objects (DDOs) and extended data objects (XDOs). A DDO has attributes, with type, value, and properties. The value of an attribute can be a reference to another DDO or XDO, or a collection of DDOs or XDOs.

FIG. 2 is a diagram illustrating a class hierarchy for Data Object classes. The objects stored in and manipulated by the datastores and fetch operations belong to data object classes. These objects are returned as the result of a fetch, or created and used in CRUD (add, retrieve, update, delete) operations.

A DataObjectBase 200 is an abstract base class for all data objects known by datastores. It has a protocol attribute, that indicates to the datastore which interface can be used to operate on this object. A DOBase 210 is the base class used to represent user-defined-types (UDT) or large objects. In particular, the XDOBase 210 is the base class for some user-defined types 212 and XDOs 214. A XDO 214 represents complex UDTs or large objects (LOB). This object can exist stand-alone or as a part of a DDO 236. Therefore, it has a persistent object identifier and CRUD operations capabilities.

Blob 216 is a base class for BLOBs as a placeholder to share all generic operations pertaining to BLOBs. Clob 218 is a base class for CLOBs (Character Large Objects) as a placeholder to share all generic operations pertaining to CLOBs. DBClob 220 is a base class for DBCLOBs (database character large object) as a placeholder to share all generic operations pertaining to DBCLOBs. BlobDB2222 represents a BLOB specific to DB2, and BlobDL 22 represents a BLOB specific to DL. Similarly, though not shown, there may be subclasses for ClobDB2, ClobDL, etc.

A DataObject 230 is a base class for PersistentObject 232 and DDOBase 234. A PersistentObject 232 represents a specific object whose code is statically generated and compiled. This type of object will not be covered in this document. A DDOBase 234 is a base class for a dynamic data object 236 (without the CRUD methods). A DDO (Dynamic Data Object) 236 represents generic data objects which are constructed dynamically at runtime. This object fits well with query and browsing activities in Grand Portal where objects are only known and generated at runtime. It supports the CRUD operations (add, retrieve, update, and delete), and, with the help of its associated datastore, a DDO can put itself into and out of the datastore.

One skilled in the art would recognize that these are only example classes and subclasses and other structures maybe used for objects and other classes or subclasses may be added to or removed from the tree shown in FIG. 2.

With respect to the notion of "federation", each participating datastore preserves the right to maintain its "personality", i.e. its own query language, data-model or schema, method of interaction, etc, and at the same time cooperating in a federation to provide a federated schema. This design allows the users to preserve the natural view to their favorite datastore as well as access them in conjunction with other datastores in a federated context.

The federated datastore 100 can combine the participating native datastores in two ways:

With mapping. As described above, mapping of concepts across participating datastores is established to provide a unified conceptual view. Based on this federated schema, federated queries with both join and union expressions can be formulated.

Without mapping. In this case, the federated datastore 100 only reflects the union of each participating datastore's conceptual view. Although it coordinates query processing and data-access for each underlying datastore, the federated datastore 100 must accept queries in each datastore's native language since the query translation process can not be performed without mapping. In addition, since there is no conceptual mapping between datastores, the FederatedQuery 19 results can only reflect the union of results from each datastore.

The embodiment of the invention is incorporated into one or more software programs that reside at the federated datastore 100. Generally, the software programs and the instructions derived therefrom, are all tangibly embodied in a computer-readable medium, e.g. one or more of the data storage devices, which may be connected to the federated datastore 100. Moreover, the software programs and the instructions derived therefrom, are all comprised of instructions which, when read and executed by the computer system 100, causes the computer system 100 to perform the steps necessary to implement and/or use the present invention. Under control of an operating system, the software programs and the instructions derived therefrom, may be loaded from the data storage devices into a memory of the federated datastore 100 for use during actual operations.

Thus, the present invention may be implemented as a method, apparatus, or article of manufacture using standard programming and/or engineering techniques to produce software, firmware, hardware, or any combination thereof. The term "article of manufacture" (or alternatively, "computer program product") as used herein is intended to encompass a computer program accessible from any computer-readable device, carrier, or media. Of course, those skilled in the art will recognize many modifications may be made to this configuration without departing from the scope of the present invention.

Those skilled in the art will recognize that the exemplary environment illustrated in FIG. 1 is not intended to limit the present invention. Indeed, those skilled in the art will recognize that other alternative hardware environments may be used without departing from the scope of the present invention.

Federated Datastore

FIG. 3 is a diagram illustrating a class hierarchy for Datastore classes. A main datastore class 300 is an abstract base class (i.e., superclass) for all datastores. In particular, some datastore classes that are based on the datastore class 300 and inherit its characteristics are the following: a DL Datastore class 302, a VisualInfo Datastore class 304, a Federated Datastore class 306, and an OnDemand Datastore class 308. It is to be understood that the techniques of the invention may be applied to any data source and is not limited to the mentioned datastores.

FIG. 4 is a diagram illustrating one composition of a federated datastore. The federated datastore 400 connects to heterogeneous datastores 402, 404, 406, and 408. As illustrated, a federated datastore 406 may connect to and be nested under federated datastore 400. Additionally, the federated datastore 406 may connect to heterogeneous datastores 410, 412, and 414. The depicted architecture is only a sample, and one skilled in the art would recognize that other examples fall within the scope of the invention.

In the preferred embodiment, the federated datastore 100 takes query strings expressed in a federated query language. An example class definition for the federated datastore (DKDatastoreFedjava) 100 is set forth below.

    DKDatastoreFed.java
        package com.ibm.mm.sdk.server;
        public class DKDatastoreFed extends dkAbstractDataStore
            implements DKConstantFed,
                      DKConstant,
                      DKMessageIdFed,
                      DKMessageId,
                      dkFederation,
                      java.io.Serializable
        {
        public dkCollection listEntities( ) throws DKException, Exception
        public String[ ] listEntityNames( ) throws DKException, Exception
        public String[ ] listTextEntityNames( ) throws DKException,
          Exception
        public String[ ] listParmEntityNames( ) throws DKException,
          Exception
        public dkCollection listEntityAttrs(String entityName) throws
          DKException, Exception
        public String[ ] listEntityAttrNames(String entityName)
          throws DKException, Exception
        public String registerMapping(DKNVPair sourceMap) throws
          DKException, Exception
        public void unRegisterMapping(String mappingName) throws
          DKException, Exception
        public String[ ] listMappingNames( ) throws
          DKException, Exception
        public dkSchemaMapping getMapping(String mappingName) throws
          DKException, Exception
        public synchronized dkExtension getExtension(String
          extensionName) throws DKException, Exception
        public synchronized void addExtension(String extensionName,
          dkExtension extensionObj) throws DKException, Exception
        public synchronized void removeExtension(String
          extensionName) throws DKException, Exception
        public synchronized String[ ] listExtensionNames( )
          throws DKException, Exception
        public DKDDO createDDO(String objectType,
           int Flags) throws DKException, Exception
        public dkCollection listSearchTemplates( )
          throws DKException, Exception
        public String[ ] listSearchTemplateNames( )
          throws DKException, Exception
        public dkSearchTemplate getSearchTemplate(String templateName)
          throws DKException, Exception
        public void destroy( ) throws DKException, Exception
        public synchronized string addRemoveCursor (dkResultSetCursor
          iCurt int action) throws DKException, Exception
        public dkDatastore datastoreByServerName (String dsType,
          String dsName) throws DKException, Exception
        public void changePassword (String serverName,
          String user Id,
          String oldPwd,
          String newPwd)
          throws DKException, Exception
        public void requestConnection (String serverName,
          String userId,
          String passwd,
          String connectString)
          throws DKException, Exception
        public void excludeServer (Sting serverName, String templateName)
          throws DKException, Exception
        public boolean isServerExcluded (String serverName, String
          templateName) throws DKException, Exception,
          java.rmi.RemoteException
        public String[ ] listExcludedServers(String templateName)
          throws DKException, Exception
        public void clearExcludedServers(String templateName)
          throws DKException, Exception
        };

          PARAMETRIC_SEARCH=([ENTITY=entity_name,]
                [MAX_RESULTS=maximum_results,]
                [COND=(conditional_expression)]
                [; ...]
              );
            [OPTION=([CONTENT=yes_no]
                )]
          [and_or
          TEXT_SEARCH=(COND=(text_search_expression)
              );
            [OPTION=([SEARCH_INDEX={search_index_name .vertline.
            (index_list) };]
                [MAX_RESULTS=maximum_results;]
                [TIME_LIMIT=time_limit]
              )]
          ]
          [and_or
          IMAGE_SEARCH=(COND=(image_search_expression)
            );
          [OPTION=([SEARCH_INDEX={search_index_name .vertline.
          (index_list) };]
                [MAX_RESULTS=maximum_results;]
                [TIME_LIMIT=time_limit]
              )]
          ]

    DKFederatedQuery.java
        package com.ibm.mm.sdk.common.DKFederatedQuery
        public Class DKFederatedQuery
          extends Object
          implements dkQuery, DKConstant, DKMessageId, Serializable
        {
        public DKFederatedQuery(dkDatastore creator,
          String queryString)
        public DKFederatedQuery(dkDatastore creator,
        public DKFederatedQuery(DKFederatedQuery fromQuery)
        public void prepare(DKNVPair params[ ]) throws DKException,
          Exception
        public void execute(DKNVPair params[ ]) throws DKException,
          Exception
        public int status( )
        public Object result( ) throws DKException, Exception
        public dkResultSetCursor resultSetCursor( ) throws DKException,
          Exception
        public short qlType( )
        public String queryString( )
        public dkDatastore getDatastore( )
        public void setDatastore(dkDatastore ds) throws DKException,
          Exception
        public String getName( )
        public void setName(String name)
        public int numberOfResults( )
        };

    DKResultSetCursorFed.java
    package com.ibm.mm.sdk.server;
    public Class DKResultSetCursorFed extends dkAbstractResultSetCursor
        implements DKConstantFed, DKMessageIdFed
    {
    public DKResultSetCursorFed (DKDatastoreFed ds,
                DKNVPair parm
              throws DKException, Exception parms[ ])
    public boolean isScrollable( ) throws DKException, Exception;
    public boolean isUpdatable( ) throws DKException, Exception;
    public boolean isValid( ) throws DKException, Exception;
    public boolean isOpen( ) throws DKException, Exception;
    public boolean isBegin( ) throws DKException, Exception;
    public boolean isEnd( ) throws DKException, Exception;
    public boolean isBetween( ) throws DKException, Exception;
    public int getPosition( ) throws DKException, Exception;
    public void setPosition(int position, Object value) throws
      DKException, Exception;
    public void setToNext( ) throws DKException, Exception;
    public DKDDO fetchObject( ) throws DKException, Exception;
    public DKDDO fetchNext( ) throws DKException, Exception;
    public boolean fetchNext(int how_many, dkCollection collection)
      throws DKException, Exception;
    public Object fetchObjectByName(String dataItemName) throws
      DKException, Exception;
    public Object fetchNextByName(String dataItemName) throws
    DKException, Exception;
    public boolean fetchNextByName(String dataItemName, int how_many,
      Object [ ] array) throws DKException, Exception;
    public DKDDO findObject(int position, String predicate) throws
      DKException, Exception;
    public void deleteObject( ) throws DKException, Exception;
    public void updateObject(DKDDO ddo) throws DKException, Exception;
    public DKDDO newObject( ) throws DKException, Exception;
    public void addObject(DKDDO ddo) throws DKException, Exception;
    public void open( ) throws DKException, Exception;
    public void open(DKNVPair parms[ ]) throws DKException, Exception;
    public void close( ) throws DKException, Exception;
    public void destroy( ) throws DKException, Exception;
    public String datastoreName( ) throws Exception;
    public String datastoreType( ) throws Exception;
    public DKHandle handle(String type) throws Exception,
    public int cardinality( ) throws Exception;
    public synchronized dkResultSetCursorfetchNextRSCursor( )
      throws DKException, Exception;
    public synchronized void addRSCursor(dkResultSetCursor rsCursor);
    }

• Inventors
  Soetarman, Basuki N.; Summers, Robert Nelson;
• Assignee
  International Business Machines Corporation (Armonk, NY)
• Published
  Sep-14-2004
• Current US Classes:
  707/1
  707/10
  707/103R
  707/3
• Application #
  400532
• International Classes
  G06F 017/30
• Field of Search
  707/1-4 707/5 707/9-10 707/100-104.1 707/200-206 709/303
• Examiner
  Alam; Shahid
• Agent
  Sughrue Mion, PLLC
• US Patent References:
  4525803
  4646061
  5202981
  5303342
  5317736
  5355493
  5596748
  5706499
  5708828
  5742806
  5745906
  5752252
  5774888
  5835904
  5864866
  5884303
  5893119
  5903894
  5987465
  6233586
  6263342
  6272488
  6343287
  6370541
  6466933
  6578046