US 6,792,416 B2Grant
Managing results of federated searches across heterogeneous datastores with a federated result set cursor object
Issue Date:2004-09-14
•18 Claims
•10 Drawing Sheets
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.
Metadata
Assignee
- International Business Machines Corporation
Inventors
- Basuki N. Soetarman
- Robert Nelson Summers
Application Information
Application Number:US 09/400,532
Filing Date:1999-09-21
Priority Date:1999-09-21
Art Unit:7
Classifications
IPC:
G06F 1730
Field of Search:
707 5709303
Patent Drawings (10 sheets)
Description
CROSS-REFERENCE TO RELATED APPLICATIONS
[0002] This application is related to the following co-pending and commonly-assigned patent applications:
[0003] application Ser. No. 09/399,696, entitled “THE ARCHITECTURE AND IMPLEMENTATION OF A DYNAMIC RMI SERVER CONFIGURATION HIERARCHY TO SUPPORT FEDERATED SEARCH AND UPDATE ACROSS HETEROGENEOUS DATASTORES,” filed on same date herewith, by Kehsing J. Chou et al.,;
[0004] application Ser. No. 09/400,638,U.S. Pat. No. 6,370,541, titled “THE DESIGN AND IMPLEMENTATION OF A CLIENT/SERVER FRAMEWORK FOR FEDERATED MULTI-SEARCH AND UPDATE ACROSS HETEROGENEOUS DATASTORES,” filed on same date herewith, by Kehsing J. Chou et al.,;
[0005] application Ser. No. 09/399,682, entitled “ARCHITECTURE TO ENABLE SEARCH GATEWAYS AS PART OF FEDERATED SEARCH,” filed on same date herewith, by Kehsing J. Chou et al.,
[0006] application Ser. No. 09/399,697, entitled “DELAYED DELIVERY OF QUERY RESULTS OR OTHER DATA FROM A FEDERATED SERVER TO A FEDERATED CLIENT UNTIL SUCH INFORMATION IS NEEDED,” filed on same date herewith, by M. W. Huang et al.,;
[0007] application Ser. No. 09/399,695, entitled “IMPROVED EXTENDED DATA OBJECT ARCHITECTURE FOR HANDLING MULTI-STREAMING AND COMPLEX MULTI-DIMENSIONAL FILES,” filed on same date herewith, by Kehsing J. Chou et al.,;
[0008] application Ser. No. 08/852,062, U.S. Pat. No. 5,960,438, entitled “CLASS HIERARCHY FOR OBJECT AGGREGATION REPRESENTATION OF RELATIONAL DATABASE ROWS WITH CELLS HAVING NONTRADITIONAL DATATYPES,” filed on May 6, 1997, by Daniel T. Chang et al.,;
[0009] application Ser No. 08/852,055, U.S. Pat. No. 5,924,100, entitled “FLEXIBLE OBJECT REPRESENTATION OF RELATIONAL DATABASE CELLS HAVING NONTRADITIONAL DATATYPES,” filed on May 6, 1997, by Daniel T. Chang et al.,
[0010] application Ser. No. 09/052,678, U.S. Pat. No. 6,272,488, entitled “MANAGING RESULTS OF FEDERATED SEARCHES ACROSS HETEROGENEOUS DATASTORES WITH A FEDERATED COLLECTION OBJECT,” filed on Apr. 1, 1998, by Daniel T. Chang et al.,;
[0011] application Ser. No. 09/052,680, U.S. Pat. No. 6,263,342, entitled “FEDERATED SEARCHING OF HETEROGENEOUS DATASTORES USING A FEDERATED DATASTORE OBJECT,” filed on Apr. 1, 1998, by Daniel T. Chang et al.,; and
[0012] application Ser. No. 09/052,679, U.S. Pat. No. 6,233,586, entitled “FEDERATED SEARCHING OF HETEROGENEOUS DATASTORES USING A FEDERATED QUERY OBJECT,” filed on Apr. 1, 1998, by Daniel T. Chang et al.,;
[0013] each of which is incorporated by reference herein.
BACKGROUND OF THE INVENTION
[0014] 1. Field of the Invention
[0015] 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.
[0016] 2. Description of Related Art
[0017] 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).
[0018] 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.
[0019] 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.”
[0020] 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.
[0021] 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.
[0022] 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.
[0023] 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.
[0024] 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.
[0025] 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.
[0026] 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.
[0027] 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.
[0028] 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.
[0029] 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.
[0030] 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.
[0031] 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
[0032] 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.
[0033] 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
[0034] Referring now to the drawings in which like reference numbers represent corresponding parts throughout:
[0035] FIG. 1 is a diagram illustrating a computer architecture that could be used in accordance with the present invention;
[0036] FIG. 2 is a diagram illustrating a class hierarchy for Data Object classes;
[0037] FIG. 3 is a diagram illustrating a class hierarchy for Datastore classes;
[0038] FIG. 4 is a diagram illustrating a conceptual view of a federated result set cursor object;
[0039] FIG. 5 is a diagram of an extended Grand Portal architecture;
[0040] FIG. 6 is a diagram illustrating individual datastores and federated compositions;
[0041] FIG. 7 is a diagram illustrating a conceptual view of a federated result set cursor object
[0042] FIG. 8 is a diagram illustrating one use of the present invention;
[0043] FIG. 9 is a flow diagram illustrating steps performed by a federated datastore to process a query; and
[0044] FIG. 10 is a flow diagram illustrating steps performed by a federated datastore to process a fetch.
DETAILED DESCRIPTION OF THE PREFERRED EMBODIMENT
[0045] 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
[0046] 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).
[0047] 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.
[0048] The Java APIs provide multi-search capabilities such as:
[0049] 1. Searching within a given datastore using one or a combination of supported query types, i.e.
[0050] Parametric query—Queries requiring an exact match on the condition specified in the query predicate and the data values stored in the datastore.
[0051] 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.
[0052] 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.
[0053] 2. Each search type is supported by one or more search-engines.
[0054] 3. Searching on the results of a previous search.
[0055] 4. Searching involving heterogeneous datastores.
[0056] 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.
[0057] 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.
[0058] 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.
[0059] 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.
[0060] 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.
[0061] 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.
[0062] 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.
[0063] 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.
[0064] 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.
[0065] 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.
[0066] 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.
[0067] 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.
[0068] 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.
[0069] 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.
[0070] The federated datastore 100 can combine the participating native datastores in two ways:
[0071] 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.
[0072] 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.
[0073] 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.
[0074] 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.
[0075] 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
[0076] 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.
[0077] 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.
[0078] 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 |
[0079] The following methods are part of the federated datastore class:
[0080] public DKDatastoreFed( ) throws DKException, Exception
[0081] Constructs default Federated Datastore.
[0082] public DKDatastoreFed(String configuration) throws DKException, Exception
[0083] Constructs default Federated Datastore.
[0084] public void connect(String datastore_name,
[0085] String user_name,
[0086] String authentication,
[0087] String connect_string) throws DKException, Exception
[0088] Establishes a connection to a federated datastore.
[0089] Parameters:
[0090] datastore_name—federated datastore name
[0091] user_name—userid to logon to this federated datastore
[0092] authentication—password for this user_name
[0093] connect_string—additional information string
[0094] Throws: DKException
[0095] if either:
[0096] datastore_name, user_name, or authentication is null or if error occurs in the federated datastore
[0097] Overrides:
[0098] connect in class dkAbstractDatastore
[0099] public void disconnect( ) throws DKException, Exception
[0100] Disconnects from the federated datastore.
[0101] Throws: DKException
[0102] if unable to disconnect from server.
[0103] Overrides:
[0104] disconnect in class dkAbstractDatastore
[0105] public Object getOption(int option) throws DKException
[0106] Gets defined datastore option
[0107] Parameters:
[0108] option—an option id
[0109] Returns:
[0110] the value for the given option
[0111] Throws: DKException
[0112] if option is not set
[0113] Overrides:
[0114] getOption in class dkAbstractDatastore
[0115] public void setOption(int option, Object value) throws DKException
[0116] Sets the given “option” with a specific “value”.
[0117] Parameters:
[0118] option—an option id
[0119] value—the value for the “option”
[0120] Throws: DKException
[0121] if option/value is invalid
[0122] Overrides:
[0123] setOption in class dkAbstractDatastore
[0124] public Object evaluate(String command,
[0125] short commandLangType,
[0126] DKNVPair params[]) throws DKException, Exception
[0127] Evaluates a query and returns the result as a dkQueryableCollection object.
[0128] Parameters:
[0129] command—a query string that represent the query criteria
[0130] commandLangType—a query language type, for Federated, it will be
[0131] DK_FEDERATED_QL_TYPE
[0132] params—a name/value pairs list
[0133] Returns:
[0134] a query result collection
[0135] Throws: DKException
[0136] if “command” argument is null
[0137] Overrides:
[0138] evaluate in class dkAbstractDatastore
[0139] public Object evaluate(dkQuery query) throws DKException, Exception
[0140] Evaluates a query and returns the result as a dkQueryableCollection.
[0141] Parameters:
[0142] query—a given query object
[0143] Returns:
[0144] a query result collection
[0145] Throws: DKException
[0146] if the “query” input is null or not of federated query type.
[0147] Overrides:
[0148] evaluate in class dkAbstractDatastore
[0149] public Object evaluate(DKCQExpr qe) throws DKException, Exception
[0150] Evaluates a query.
[0151] Parameters:
[0152] qe—a common query expression object
[0153] Returns:
[0154] a collection of the results
[0155] Throws: DKException
[0156] if common query expression object is invalid
[0157] Overrides:
[0158] evaluate in class dkAbstractDatastore
[0159] public dkResultSetCursor execute(String command,
[0160] short commandLangType,
[0161] DKNVPair params[]) throws DKException, Exception
[0162] Executes a command query of the federated datastore and returns a result set cursor.
[0163] Parameters:
[0164] command—a query string that represents the query criteria.
[0165] commandLangType—a query language type, for Federated, it will be
[0166] DK_FEDERATED_QL_TYPE.
[0167] params[]—a name/value pairs list.
[0168] Returns:
[0169] a dkResultSetCursor object.
[0170] Throws: DKException
[0171] if “command” is null or invalid, or “commandLangType” is not Federated
[0172] Query type.
[0173] Overrides:
[0174] execute in class dkAbstractDatastore
[0175] public dkResultSetCursor execute(dkQuery query) throws DKException, Exception
[0176] Executes a command query of the federated datastore and returns a result set cursor. This method takes a Federated query object as an argument.
[0177] Parameters:
[0178] query—a federated dkQuery object
[0179] Returns:
[0180] a dkResultSetCursor object
[0181] Throws: DKException
[0182] if “query” object is null or query.qlType( ) is not
[0183] DK_FEDERATED_QL_TYPE
[0184] Overrides:
[0185] execute in class dkAbstractDatastore
[0186] public dkResultSetCursor execute(DKCQExpr cqe) throws DKException, Exception
[0187] Executes a query expression.
[0188] Parameters:
[0189] cqe—a common query expression object
[0190] Returns:
[0191] resultSetCursor which represents a federated datastore cursor.
[0192] Throws: DKException
[0193] if “cqe” object is invalid
[0194] Overrides:
[0195] execute in class dkAbstractDatastore
[0196] public void execute WithCallback(dkQuery query,
[0197] dkCallback callbackObj) throws DKException, Exception
[0198] Executes a query with callback function.
[0199] Parameters:
[0200] query—a query object
[0201] callbackObj—a dkCallback object
[0202] Overrides:
[0203] executeWithCallback in class dkAbstractDatastore
[0204] public void execute WithCallback(String command,
[0205] short commandLangType,
[0206] DKNVPair params[],
[0207] dkCallback callbackObj) throws DKException, Exception
[0208] Execute the query with callback function.
[0209] Parameters:
[0210] command—a query string
[0211] commandLang—a query type
[0212] params—additional query option in name/value pair
[0213] callbackObj—a dkCallback object
[0214] Overrides:
[0215] executeWithCallback in class dkAbstractDatastore
[0216] public void executeWithCallback(DKCQExpr cqe,
[0217] dkCallback callbackObj) throws DKException, Exception
[0218] Execute a query expression with callback function.
[0219] Parameters:
[0220] cqe—a common query expression object
[0221] callbackObj—a dkCallback object
[0222] Overrides:
[0223] executeWithCallback in class dkAbstractDatastore
[0224] public dkQuery createQuery(String command,
[0225] short commandLangType,
[0226] DKNVPairparamsf[]) throws DKException
[0227] Creates a federated query object.
[0228] Parameters:
[0229] command—a query string that represents the query criteria
[0230] commandLangType—a query language type, it will be one of the following:
[0231] DK_CM_TEMPLATE_QL_TYPE
[0232] DK_CM_TEXT_QL_TYPE
[0233] DK_CM_IMAGE_QL_TYPE
[0234] DK_CM_PARAMETRIC_QL_TYPE
[0235] DK_CM_COMBINED_QL_TYPE
[0236] params[]—a name/value pairs list
[0237] Returns:
[0238] a federated dkQuery object
[0239] Throws: DKException
[0240] if “command” is null
[0241] Overrides:
[0242] createQuery in class dkAbstractDatastore
[0243] public dkQuery createQuery(DKCQExpr qe) throws DKException
[0244] Creates a query object.
[0245] Parameters:
[0246] cqe—a common query expression object
[0247] Throws: DKException
[0248] if “cqe” object is invalid
[0249] Overrides:
[0250] createQuery in class dkAbstractDatastore
[0251] public dkCollection listDataSources( ) throws DKException
[0252] List the available datastore sources that a user can connect to.
[0253] Returns:
[0254] a collection of ServerDef objects describing the servers
[0255] Throws: DKException
[0256] if internal error occurs from server
[0257] Overrides:
[0258] listDataSources in class dkAbstractDatastore
[0259] public String[] listDataSourceNames( ) throws DKException
[0260] Gets a list of datasource names.
[0261] Returns:
[0262] an array of datasource names
[0263] Throws: DKException
[0264] if error occurs when retrieving datasource names
[0265] Overrides:
[0266] listDataSourceNames in class dkAbstractDatastore
[0267] public void addObject(dkDataObject dataobj) throws DKException, Exception
[0268] Adds a DDO object.
[0269] Parameters:
[0270] ddo—a Federated object to be added.
[0271] Throws: DKException
[0272] if error occurs during add.
[0273] Overrides:
[0274] addObject in class dkAbstractDatastore
[0275] public void deleteObject(dkDataObject dataobj) throws DKException, Exception
[0276] Deletes a data object.
[0277] Parameters:
[0278] ddo—a federated DDO object to be deleted
[0279] Throws: DKException
[0280] if error occurs during delete.
[0281] Overrides:
[0282] deleteObject in class AbstractDatastore
[0283] public void retrieveObject(dkDataObject dataobj) throws DKException, Exception
[0284] Retrieves a data-object.
[0285] Parameters:
[0286] ddo—document object to be retrieved.
[0287] Throws: DKException
[0288] when retrieve failed.
[0289] Overrides:
[0290] retrieveObject in class dkAbstractDatastore
[0291] public void updateObject(dkDataObject dataobj) throws DKException, Exception
[0292] Updates a data-object.
[0293] Parameters:
[0294] ddo—the data-object to be updated.
[0295] Throws: DKException
[0296] if error occurs in the datastore
[0297] Overrides:
[0298] updateObject in class dkAbstractDatastore
[0299] public void commit( ) throws DKException
[0300] Commits all activities since the last commit.
[0301] Throws: DKException
[0302] is thrown since federated datastore does not support transaction scope for now.
[0303] Overrides:
[0304] commit in class dkAbstractDatastore
[0305] public void rollback( ) throws DKException
[0306] Rolls back all activities since the last commit.
[0307] Throws: DKException
[0308] is thrown since Federated does not support transaction scope for now.
[0309] Overrides:
[0310] rollback in class dkAbstractDatastore
[0311] public boolean isConnected( )
[0312] Checks to see if the datastore is connected
[0313] Returns:
[0314] true if connected, false otherwise
[0315] Overrides:
[0316] isConnected in class dkAbstractDatastore
[0317] public DKHandle connections throws Exception
[0318] Gets the connection handle for the datastore.
[0319] Returns:
[0320] the connection handle
[0321] Overrides:
[0322] connection in class dkAbstractDatastore
[0323] public DKHandle handle(String type) throws Exception
[0324] Gets a datastore handle.
[0325] Parameters:
[0326] type—type of datastore handle wanted
[0327] Returns:
[0328] a datastore handle
[0329] Overrides:
[0330] handle in class dkAbstractDatastore
[0331] public String userName( )
[0332] Gets the user name that user used to logon to the datastore.
[0333] Returns:
[0334] the userid that user used to logon
[0335] Overrides:
[0336] userName in class dkAbstractDatastore
[0337] public String datastoreName( ) throws Exception
[0338] Gets the name of this datastore object. Usually it represents a datastore source's server name.
[0339] Returns:
[0340] datastore name
[0341] Overrides:
[0342] datastoreName in class dkAbstractDatastore
[0343] public String datastore( ) throws Exception
[0344] Gets the datastore type for this datastore object.
[0345] Returns:
[0346] datastore type
[0347] Overrides:
[0348] datastoreType in class dkAbstractDatastore
[0349] public dkDatastoreDef datastoreDef( ) throws DKException, Exception
[0350] Gets datastore definition.
[0351] Returns:
[0352] the meta-data (dkDatastoreDef) of this datastore
[0353] Overrides:
[0354] datastoreDef in class dkAbstractDatastore
[0355] public dkCollection listEntities( ) throws DKException, Exception
[0356] Gets a list of federated entities from Federated server.
[0357] Returns:
[0358] a collection of dkEntityDef
[0359] Throws: DKException
[0360] if error occurs
[0361] Overrides:
[0362] listEntities in class dkAbstractDatastore
[0363] public String[] listEntityNames( ) throws DKException, Exception
[0364] Gets a list of federated entities names from Federated server.
[0365] Returns:
[0366] an array of names
[0367] Throws: DKException
[0368] if error occurs
[0369] Overrides:
[0370] listEntityNames in class dkAbstractDatastore
[0371] public String[] listTextEntityNames( ) throws DKException, Exception
[0372] Gets a list of federated text search entities names from Federated server.
[0373] Returns:
[0374] an array of names
[0375] Throws: DKException
[0376] if error occurs
[0377] public String[] listParmEntityNames() throws DKException, Exception
[0378] Gets a list of federated parametric search entities names from Federated server.
[0379] Returns:
[0380] an array of names
[0381] Throws: DKException
[0382] if error occurs
[0383] Overrides:
[0384] listEntityAttrs
[0385] public dkCollection listEntityAttrs(String entityName) throws DKException, Exception
[0386] Gets a list of attributes for a given entity name.
[0387] Parameters:
[0388] entityName—name of entity to retrieve attributes for
[0389] Returns:
[0390] a dkCollection of dkAttrDef objects
[0391] Throws: DKException
[0392] if the entity name does not exist
[0393] Overrides:
[0394] listEntityAttrs in class dkAbstractDatastore
[0395] public String[] listEntityAttrNames(String entityName) throws DKException, Exception
[0396] Gets a list of attribute names for a given entity name.
[0397] Parameters:
[0398] entityName—name of entity to retrieve attribute names for
[0399] Returns:
[0400] an array of attribute names
[0401] Throws: DKException
[0402] if the entity name does not exist
[0403] Overrides:
[0404] listEntityAttrNames in class dkAbstractDatastore
[0405] public String registerMapping(DKNVPair sourceMap) throws DKException, Exception
[0406] Registers a mapping definition to this datastore. Mapping is done by entities.
[0407] Parameters:
[0408] sourceMap—source name and mapping, a DKNVPair class with the following possible values:
[0409] (“BUFFER”,):buffer_ref is a reference to a string in memory
[0410] (“FILE”,):file_name is the name of the file containing the mapping
[0411] (“URL”,):URL-address location of the mapping
[0412] (“LDAP”,): LDAP file-name
[0413] (“SCHEMA”,): a reference to a dkSchemaMapping object
[0414] defining the
[0415] mapping. Currently, only “SCHEMA” option is supported, others
[0416] may be
[0417] added later.
[0418] Returns:
[0419] the name of the mapping definition.
[0420] Overrides:
[0421] registerMapping in class dkAbstractDatastore
[0422] See Also:
[0423] unRegisterMapping
[0424] public void unRegisterMapping(String mappingName) throws DKException, Exception
[0425] Unregisters mapping information from this datastore.
[0426] Parameters:
[0427] mappingName—name of the mapping information
[0428] Overrides:
[0429] unRegisterMapping in class dkAbstractDatastore
[0430] See Also:
[0431] registerMapping
[0432] public String[] listMappingNames( ) throws DKException, Exception
[0433] Gets the list of the registered mappings for this datastore.
[0434] Returns:
[0435] an array of registered mapping objects' names. The array length would be zero if there is no mapping registered.
[0436] Overrides:
[0437] listMappingNames in class dkAbstractDatastore
[0438] See Also:
[0439] registerMapping
[0440] public dkSchemaMapping getMapping(String mappingName) throws DKException, Exception
[0441] Gets mapping information from this datastore.
[0442] Parameters:
[0443] mappingName—name of the mapping information
[0444] Returns:
[0445] the schema mapping object
[0446] Overrides:
[0447] getMapping in class dkAbstractDatastore
[0448] See Also:
[0449] registerMapping
[0450] public synchronized dkExtension getExtension(String extensionName) throws DKException, Exception
[0451] Gets the extension object from a given extension name.
[0452] Parameters:
[0453] extensionName—name of the extension object.
[0454] Returns:
[0455] extension object.
[0456] Overrides:
[0457] getextension in class dkAbstractDatastore
[0458] public synchronized void addExtension(String extensionName, dkExtension extensionObj) throws DKException, Exception
[0459] Adds a new extension object.
[0460] Parameters:
[0461] extensionName—name of new extension object
[0462] extensionObj—the extension object to be set
[0463] Overrides:
[0464] addExtension in class dkAbstractDatastore
[0465] public synchronized void removeExtension(String extensionName) throws DKException, Exception
[0466] Removes an existing extension object.
[0467] Parameters:
[0468] extensionName—name of extension object to be removed
[0469] Overrides:
[0470] removeExtension in class dkAbstractDatastore
[0471] public synchronized String[] listExtensionNames( ) throws DKException, Exception
[0472] Gets the list of extension objects' names.
[0473] Returns:
[0474] an array of extension objects' names
[0475] Overrides:
[0476] listExtensionNames in class dkAbstractDatastore
[0477] public DKDDO createDDO(String objectType, int Flags) throws DKException, Exception
[0478] Creates a new DDO with object type, properties and attributes set for a given back-end server.
[0479] Parameters:
[0480] objectType—the object type
[0481] Flags—to indicate various options and to specify more detailed characteristics of the DDO to create. For example, it may be a directive to create a document DDO, a folder, etc.
[0482] Returns:
[0483] a new DDO of the given object type with all the properties and attributes set, so that the user only needs to set the attribute values
[0484] Overrides:
[0485] createDDO in class dkAbstractDatastore
[0486] public dkCollection listSearchTemplates( ) throws DKException, Exception
[0487] Gets a list search templates from a federated server.
[0488] Returns:
[0489] a DKSequentialCollection of search templates
[0490] Throws: DKException
[0491] if internal datastore error occurs
[0492] public String[] listSearchTemplateNames( ) throws DKException, Exception
[0493] Gets a list search templates' names from a federated server.
[0494] Returns:
[0495] an array of search template names
[0496] Throws: DKException
[0497] if internal datastore error occurs
[0498] public dkSearchTemplate getSearchTemplate(String templateName) throws DKException, Exception
[0499] Gets a search template information from a given template name.
[0500] Returns:
[0501] dkSearchTemplate object.
[0502] Throws: DKException
[0503] if internal datastore error occurs
[0504] public void destroy( ) throws DKException, Exception
[0505] datastore destroy—datastore cleanup if needed
[0506] Overrides:
[0507] destroy in class dkAbstractDatastore
[0508] public synchronized string addRemoveCursor (dkResultSetCursor iCurt int action) throws DKException, Exception
[0509] public dkDatastore datastoreByServerName (String dsType, String dsName) throws DKException, Exception
[0510] Gets a reference to the specified datastore. The datastore must be connected, otherwise it will return null even if one is found. First, it will look in the free connection pool. If none found, it will look under the connection pool held by active cursors.
[0511] public void changePassword (String serverName,
[0512] String user Id,
[0513] String oldPwd,
[0514] String newPwd)
[0515] throws DKException, Exception
[0516] Changes the password of a given user Id for a specified server. Administrator only function.
[0517] Parameters:
[0518] userId—the user-id
[0519] oldPwd—the old password
[0520] newPwd—the new password
[0521] public void requestConnection (String serverName,
[0522] String userId,
[0523] String passwd,
[0524] String connectString) throws DKException, Exception
[0525] Requests a connection to a particular server with the given userid, password & connectString.
[0526] Parameters:
[0527] userId—the user Id
[0528] passwd—the password
[0529] connectstring—the connect string to logon
[0530] public void excludeServer (Sting serverName, String templateName) throws DKException, Exception
[0531] Requests the named server to be skipped for the named search template.
[0532] Parameters:
[0533] serverName—a back end server name
[0534] templateName—a search template name
[0535] public boolean isServerExcluded (String serverName, String templateName) throws DKException, Exception, java.rmi.RemoteException
[0536] Checks if the given server is in the excluded list for the named search template.
[0537] Parameters:
[0538] serverName—a back end server name
[0539] templateName—a search template name
[0540] Returns:
[0541] true or false
[0542] public String[] listExcludedServers(String templateName) throws DKException, Exception
[0543] Lists all the excluded servers for the named search template
[0544] Parameters:
[0545] s—templateName—a search template name
[0546] Returns:
[0547] an array of server names that were excluded during search
[0548] public void clearExcludedServers(String templateName) throws DKException, Exception
[0549] Clears all the excluded servers for the named search template
[0550] Parameters:
[0551] s—templateName—a search template name
[0552] The following is sample syntax of a federated query string. However, it is to be understood that other syntax, including other parameters, may be used for the federated query string without departing from the scope of the invention.
| PARAMETRIC_SEARCH=([ENTITY=entity_name,] |
[0553] There are several mechanisms for users to submit federated queries for execution. For example, users can create a federated query string and pass it to a federated query object and then invoke an execute or evaluate method on that object to trigger the query processing. Alternatively, a user can pass the federated query string to the execute or evaluate method in the federated datastore to process the query directly. The query string will be parsed into a federated query canonical form (query expression), which is essentially a datastore neutral representation of the query. In case the input query comes from a graphical user interface (GUI) based application, the query does not need to be parsed and the corresponding canonical form can be directly constructed.
[0554] The query canonical form is the input for the federated query processor module. This module will perform the following tasks:
[0555] Query translation. Translates the query canonical form into several native queries that corresponds to each native datastore associated to this federated datastore. The translation information is obtained from the schema mapping.
[0556] Data conversion. Converts data in the query into a native data type for each of the associated native datastores. This process uses the mapping and conversion mechanisms described in the schema mapping.
[0557] Data filtering. Filters only the relevant data during the construction of native queries.
[0558] Each native query is submitted to the corresponding native datastore for execution. Initially, the results returned are cursors to the data in each datastore.
[0559] The end-result of an initial query is a federated result set cursor object, which is a virtual collection (i.e., at this time, data has not actually been retrieved) of cursors to objects in each of the native datastores.
[0560] The user can retrieve the actual data using a fetch. When a fetch is issued for data, the data is returned by the native datastores to the federated query results processor module, which will do the following:
[0561] Data conversion. Converts data from the native type into a federated type according to the mapping information.
[0562] Datafiltering. Filters the results to include only the requested data.
[0563] Result merging. Merges the results from several native datastores into a federated collection.
[0564] The federated result set cursor object provides the facility to separate query results according to the source native datastores. To do such a processing, the user/application may either use the federated cursor to fetch data or a native datastore cursor to fetch data from a particular datastore.
[0565] A FederatedQuery represents and executes queries across heterogeneous datastores. This query can be a combination of a DL parametric query, OnDemand query, and other query types involving supported datastores. To retrieve data from each datastore, the federated datastore delegates the query processing task to each of the native datastores.
| DKFederatedQuery.java |
[0566] The following methods are part of the federated query class:
[0567] public DKFederatedQuery(dkDatastore creator, String queryString)
[0568] Constructs a Federated query.
[0569] Parameters:
[0570] creator—datastore
[0571] querystring—a query string
[0572] public DKFederatedQuery(dkDatastore creator,
[0573] DKCQExpr queryExpr)
[0574] Constructs a Federated query
[0575] Parameters:
[0576] creator—datastore
[0577] queryExpr—a query expression
[0578] public DKFederatedQuery(DKFederatedQuery fromQuery)
[0579] Constructs a Federated query from a Federated query object.
[0580] Parameters:
[0581] fromQuery—Federated query
[0582] public void prepare(DKNVPair params[]) throws DKException, Exception
[0583] Prepares a query.
[0584] Parameters:
[0585] params—additional prepare query option in name/value pair
[0586] public void execute(DKNVPair params[]) throws DKException, Exception
[0587] Executes a query.
[0588] Parameters:
[0589] params—additional query option in name/value pair
[0590] public int status( )
[0591] Gets query status.
[0592] Returns:
[0593] query status
[0594] public Object results throws DKException, Exception
[0595] Gets query result.
[0596] Returns:
[0597] query result in a DKResults object
[0598] public dkResultSetCursor resultSetCursor) throws DKException, Exception
[0599] Gets query result.
[0600] Returns:
[0601] query result in a dkResultSetCursor object
[0602] public short qlType( )
[0603] Gets query type.
[0604] Returns:
[0605] query type
[0606] public String queryString( )
[0607] Gets query string
[0608] Returns:
[0609] query string
[0610] public dkdatastore getDatastore( )
[0611] Gets the reference to the owner datastore object.
[0612] Returns:
[0613] the dkdatastore object
[0614] public void setDatastore(dkDatastore ds) throws DKException, Exception
[0615] Sets the reference to the owner datastore object.
[0616] Parameters:
[0617] ds—a datastore
[0618] public String getName( )
[0619] Gets query name.
[0620] Returns:
[0621] name of this query
[0622] public void setName(String name)
[0623] Sets query name.
[0624] Parameters:
[0625] name—new name to be set to this query object
[0626] public int numberOfResults( )
[0627] Gets the number of query results.
[0628] Returns:
[0629] number of query results
Schema Mapping
[0630] A schema mapping represents a mapping between the schema in a datastore with the structure of the data-object that the user wants to process in memory. Schema mapping has been generally described in U.S. patent application Ser. Nos. 08/276,382 and 08/276,747, also assigned to IBM.
[0631] A federated schema is the conceptual schema of a federated datastore 100, which defines a mapping between the concepts in the federated datastore 100 to concepts expressed in each participating datastore schema. In general, a schema mapping handles the difference between how the data are stored in the datastore (as expressed by the datastore's conceptual schema) and how the user wants to process them in the application program. This mapping can also be extended to incorporate relationship associations among entities in a federated datastore, e.g., associating an employee's name with the appropriate department name. Since the mapping process can be a bit tedious, it is usually done with the help of a typical GUI-oriented schema mapping program.
[0632] In addition to schema-mapping information involving the mapping of entities and attributes, a federated datastore 100 must also have access to the following information:
[0633] User-id and password mapping. To support single sign-on features, each user-id in the federated datastore 100 needs to be mapped to its corresponding user-ids in the native datastores.
[0634] Datastore registration. Each native datastore needs to be registered so it can be located and logged-on to by the federated datastore 100 processes on behalf of its users.
Extended Grand Portal Architecture
[0635] In one embodiment, the invention is used within an extended Grand Portal Architecture. FIG. 5 is a diagram of an extended Grand Portal architecture. A Grand Portal client for a federated client datastore 500 is connected to a Grand Portal server for a federated server datastore 502. Another federated client/server system 504 may be connected to the federated server 502. A Grand Portal client/server system for an OnDemand (OD) datastore 506 may be part of the federation. Additionally, a Grand Portal client/server system for a Digital Library/VisualInfo (DL/VI) datastore 508 may be part of the federation. As with any of the datastores discussed herein, a user may access the client or the server directly. Therefore, user applications may reside at either the client or the server.
[0636] A Grand Portal client for a DES datastore 510 or a Grand Portal server for a DES datastore 512 may each be connected to the federation. While the DL/VI datastore enables searching a DL/VI Library server and the OD datastore enables searching of an OnDemand datastore, the DES datastore enables searching of multiple other datastores. In particular, the DES datastore enables searching of a Lotus Notes server 514, a Web 516, a file system 518, and a relational database 520.
[0637] FIG. 6 is a diagram illustrating individual datastores and federated compositions. In particular, a datastore can be configured as a stand-alone or as part of a federation. Additionally, a federated datastore can be composed of any number of datastores, including other federated datastores. Stand-alone datastores may be accessed directly by a user. The following are example stand-alone datastores in FIG. 6: a Digital Library (DL) datastore 600, an OnDemand datastore 602, a VisualInfo/400 datastore 604, a Domino.Doc datastore 606, or a ImagePlus/390 datastore 608. Additionally, a DES datastore 610 maybe a stand alone in that it is not part of a federated composition. A federated composition 612 may include individual datastores 614 and 616, another federated datastore 618, and a search gateway to a DES datastore 620. In turn, the DES datastore 620 enables searching a Lotus Notes database 622, searching the Web 624, searching a file system 626, or searching a relational database 628 (e.g., DB2, Oracle, or ODBC).
Managing Results of Federated Searches Across Heterogeneous Datastores with a Federated Result Set Cursor Object
[0638] An embodiment of the invention provides a federated result set cursor object. In particular, when a search is performed in a federated datastore, each “heterogeneous” or “native” datastore is searched. Then, a federated result set cursor object is returned, which points to the data. A cursor is an indicator that indicates the beginning of a set of data (e.g., records, files, etc.). A federated result set cursor object comprises a federated cursor that may be used to fetch data sequentially from each datastore and a native cursor for each native datastore that may be used to fetch data from a particular native datastore. For example, if the federated cursor initially points to data in a first datastore, serial fetches may be used to retrieve each piece of data in the first datastore, then the cursor is moved to another datastore, and fetches are used to retrieve data in this datastore. If a native datastore cursor is used to fetch data, the data is retrieved from the specified native datastore starting at the cursor position.
[0639] FIG. 7 is a diagram illustrating a conceptual view of a federated result set cursor object. The federated result set cursor object 700 contains several individual cursors. The individual cursors include native cursors 704, 706, 708, and 710. A user or application may use any one of these cursors to fetch data.
[0640] When searching is performed in a federated datastore, the federated engine searches each heterogeneous datastore connected to the federated datastore. The federated engine may retrieve data from each separate datastore. Thus, the federated engine needs a technique for providing the data retrieved from multiple datastores in a single result set.
[0641] 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.
[0642] In an object-oriented application, a result set cursor class is defined as a virtual collection in which the elements of the collection can be fetched one by one using fetch methods. One embodiment of the invention provides a data structure and methods to group data objects resulting from a query in a special result set cursor object.
[0643] FIG. 8 is a diagram illustrating one use of the present invention. A federated datastore client 800 is connected to a federated datastore server 802. The federated datastore server 802 is connected to several native datastores. The native datastores include a DL (Digital Library) datastore 804, a VisualInfo datastore 806, and an OnDemand datastore 808. Initially, if a user or application program would like to retrieve data from the native datastores, the user or application program initiates a query 810 at the federated datastore client 800. Although not shown, a user or application program may also initiate a query directly at the federated datastore server 802.
[0644] The federated datastore client 800 passes the query to the federated datastore server 802. Note that the federated datastore server 802 is able to determine the type of data to be retrieved (i.e., image or text) and recognizes which type of query each native datastore 804, 806, and 808 is able to process. Therefore, the federated datastore server 802 determines which native datastores are to receive the query. In this example, the federated datastore server 802 requests each native datastore 804, 806, and 808 to process the query.
[0645] Each native datastore 804, 806, and 808 performs a search for the requested data and sets a cursor to the data found in that native datastore 804, 806, and 808. The cursors are returned to the federated datastore client 800 in a federated result set cursor object 812. The federated result set cursor object 812 contains three circles that represent the three native datastore cursors. Additionally, the federated datastore server 802 selects one of the native datastore cursors as a beginning point for iterating through the found data. This selected native datastore cursor will be referred to in this example as a federated cursor.
[0646] At this time, a user or application program can submit a fetch request to actually retrieve desired data. For example, a user or application program may submit a fetch 814 specifying one of the cursors (i.e., a federated cursor or a native cursor). Then, the federated datastore client 800 passes the fetch 814 to the federated datastore server 802. The federated datastore server 802 obtains the data at the specified cursor location. In particular, the federated datastore server 802 requests the data from a particular native datastore. The native datastore returns the data at the cursor location. The federated datastore server 802 processes the data, including converting the data using a schema mapping to place the data in a form desired by a user or application program.
[0647] The data is returned to a user or application program from the federated datastore server 802 via the federated datastore client 800. The user or application program may submit additional fetch requests to obtain additional data. In particular, the user or application program may specify different cursors for each fetch request. Additionally, a user or application program may fetch the next piece of data using a fetch next command.
[0648] The results in the result set may be accessed with multiple techniques. For example, several result set cursors of data objects maybe aggregated while preserving each individual datastore result set cursor information. That is, the federated result set cursor object contains a federated cursor as well as native cursors. Each native datastore has a cursor indicating a position for reading the data in that datastore, and the federated cursor indicates a position for reading data from one of the datastores. Each result set cursor may be treated as one whole unit of a federated cursor, while the ability to access each individual result set cursor is preserved.
[0649] This structure is provided via a federated result set cursor object. The result set cursor object contains methods that allow a user or application program to fetch elements from the virtual collection.
[0650] An example class definition for a federated result set cursor (DKResultSetCursorFed.java) is set forth below.
| DKResultSetCursorFed.java |
| package com.ibm.mm.sdk.server; |
| public Class DKResultSetCursorFed extends dkAbstractResultSetCursor |
[0651] The following methods are part of the federated result set cursor class:
[0652] public boolean isScrollable( ) throws DKException, Exception;
[0653] Scrollable indicator that returns true if cursor can be scrolled forward and backward.
[0654] public boolean isUpdatable( ) throws DKException, Exception;
[0655] Updatable indicator that returns true if cursor is updatable.
[0656] public boolean isvalid( ) throws DKException, Exception;
[0657] Valid indicator that returns true if cursor is valid.
[0658] public boolean isOpen( ) throws DKException, Exception;
[0659] Open indicator that returns true if cursor is in an opened state.
[0660] public boolean isBegin( ) throws DKException, Exception;
[0661] Begin indicator that returns true if cursor is positioned at the beginning.
[0662] public boolean isEnd( ) throws DKException, Exception;
[0663] End indicator that returns true if cursor is positioned at the end.
[0664] public boolean isBetween( ) throws DKException, Exception;
[0665] Between data objects in cursor indicator that returns true if cursor is in between data objects in the cursor.
[0666] public int getPosition( ) throws DKException, Exception;
[0667] Gets the current cursor position and returns the current cursor position.
[0668] public void setPosition(int position, Object value) throws DKException, Exception;
[0669] Sets the cursor to the given position, with the parameter position providing a cursor position option and the parameter value providing a cursor position value.
[0670] public void setToNext( ) throws DKException, Exception;
[0671] Sets cursor to point to the position of the next data object in the cursor.
[0672] public DKDDOfetchObject( ) throws DKException, Exception;
[0673] Fetches the element in the cursor at the current position and returns a DDO.
[0674] public DKDDOfetchNext( ) throws DKException, Exception;
[0675] Sets cursor to point to the position of the next data object and fetches the element in the cursor at that position and returns a DDO.
[0676] public boolean fetchNext(int how_many, dkCollection collection) throws DKException, Exception;
[0677] Fetches the next N elements of the cursor and inserts them into the given collection, with the parameter how_many indicating how many elements the user or application program wants to be returned in the collection and the parameter collection indicating the collection where elements that are fetched are stored. Returns true if there is at least one data object returned.
[0678] public ObjectfetchObjectByName(String dataItemName) throws DKException, Exception;
[0679] Fetches the data item value in the cursor at the current position by data item name, with the parameter dataItemName indicating a data item name, and returns an Object.
[0680] public Object fetchNextByName(String dataItemName) throws DKException, Exception;
[0681] Sets cursor to point to the position of the next data object and fetches the data item value in the cursor at that position by data item name, with the parameter dataItemName indicating a data item name, and returns an Object.
[0682] public boolean fetchNextByName(String dataItemName, int how_many, Object [] array) throws DKException, Exception;
[0683] Fetches the next N data item values of the cursor and inserts them into the given array, with the parameter dataItemName indicating a data item name, the parameter how_many indicating how many data item values the user or application program wants to be returned in the collection, and with the parameter array indicating an array where the data item values that are fetched are stored. Returns true if there is at least one data item value returned.
[0684] public DKDDOfindObject(int position, String predicate) throws DKException, Exception;
[0685] Finds the data object which satisfies the given predicate, moves the cursor to that position, fetches the data object, and returns a DDO.
[0686] public void deleteObject( ) throws DKException, Exception;
[0687] Deletes element at the current cursor position from the datastore.
[0688] public void updateObject(DKDDO ddo) throws DKException, Exception;
[0689] Updates element at the current cursor position from the datastore.
[0690] public DKDDO newObject( ) throws DKException, Exception;
[0691] Constructs a new DDO of the same type as the items in the result and returns a DDO.
[0692] public void addObject(DKDDO ddo) throws DKException, Exception;
[0693] Adds an element to the datastore.
[0694] public void open( ) throws DKException, Exception;
[0695] Opens the cursor. This re-executes the query and repositions the cursor to the beginning.
[0696] public void open(DKNVPair parms[]) throws DKException, Exception;
[0697] Opens the cursor. This re-executes the query and repositions the cursor to the beginning. The parameter parms allows for parameters to be passed in for the reexecution of the query.
[0698] public void close( ) throws DKException, Exception
[0699] Closes the cursor and invalidates the result set.
[0700] public void destroy( ) throws DKException, Exception;
[0701] Destroys the cursor. This method allows for cleanup, before garbage-collection is done on this class.
[0702] public String datastoreName( ) throws Exception;
[0703] Gets the datastore name and returns the datastore name.
[0704] public String datastoreType( ) throws Exception;
[0705] Gets the datastore type and returns the datastore type.
[0706] public DKHandle handle(String type) throws Exception;
[0707] Gets a cursor handle with the parameter type indicating a type of cursor handle desired and returns a cursor handle.
[0708] public int cardinality( ) throws Exception;
[0709] Gets the number of query results and returns the number of query results.
[0710] public synchronized dkResultSetCursorfetchNextRSCursor( ) throws DKException, Exception;
[0711] Fetches the next result set cursor.
[0712] public synchronized void addRSCursor(dkResultSetCursor rsCursor);
[0713] Adds a resultSet cursor to this federated cursor.
[0714] The client application program may create and use a federated result set cursor object and fetch elements from the whole result set cursor across native datastore cursor (i.e., individual cursor) boundaries. Alternatively, the client application program may access each individual result set cursor and fetch elements from each group of results originated from a particular datastore.
[0715] One practical use of a federated collection object is to represent results of a query against several heterogeneous datastores. The embodiment of the invention allows an object oriented application program to manipulate data objects resulting from a multi-search query to heterogeneous datastores in a federated result set cursor that embodies result set cursors from each heterogeneous datastore. The federated result set cursor also preserves the sub-grouping relationships of data objects contained in the result set cursors from each heterogeneous datastore.
[0716] Such a result set cursor is very useful to represent the results of a query against heterogeneous datastores. The combined results of the multi-search query is a result set cursor that contains a result set cursor from each datastore. The client application program has a choice of fetching from the whole combined results with a flat result set cursor or to fetch from each datastore result set cursor individually while preserving the sub-grouping information and relationships.
[0717] This federated result set cursor would be created by the federated datastore to represent the results of a federated multi-search query.
[0718] A result set cursor is a feature supported by modern data base management systems, such as relational databases (e.g., DB2, Oracle, Sybase, Informix, etc.). All conventional result set cursors are flat in that they provide a single cursor to the retrieved data.
[0719] On the other hand, the embodiment of the invention provides a nested result set cursor, which can have any amount of depth, with each result set cursor containing data objects resulting from a query against a specific datastore. The nested or federated result set cursor aggregates the query results from a set of heterogeneous datastores. The nested or federated result set cursor may be used with a federated datastore and a federated query object to store the results of a query against heterogeneous datastores.
[0720] FIG. 9 is a flow diagram illustrating steps performed by a federated datastore to process a query. In block 900, the federated datastore receives a query requesting data from the federated datastore. In block 902, the federated datastore identifies which heterogeneous datastores connected to the federated datastore should process the query. In block, 904, the federated datastore forwards the query to each identified heterogeneous datastore. In block 906, the federated datastore receives a native cursor from each heterogeneous datastore that located data, with the native cursor indicating a beginning of the located data. In block 908, the federated datastore selects one of the native cursors as a beginning point for iterating through the located data. In block 910, the federated datastore generates a federated result set cursor object with each native cursor. In block 912, the federated datastore returns a federated result set cursor object in response to the query.
[0721] FIG. 10 is a flow diagram illustrating steps performed by a federated datastore to process a fetch. In block 1000, the federated datastore receives a fetch requesting physical data be retrieved from the federated datastore. Note that the fetch can be for more than one piece of data and can indicate that a next piece of data is to be retrieved. In block 1002, the federated datastore determines whether the fetch references a federated cursor. If the fetch references a federated cursor, the federated datastore continues to block 1004, otherwise, the federated datastore continues to block 1006. In block 1004, the federated datastore submits a request for physical data from the heterogeneous datastore in which the federated cursor identifies data. In block 1006, the federated datastore submits a request for physical data from the heterogeneous datastore in which the native cursor identifies data. In block 1008, the federated datastore receives data from the heterogeneous datastore. In block 1010, the federated datastore processes the received data, including performing conversion via schema mapping, if necessary. In block 1012, the federated datastore returns the physical data in response to the fetch.
Conclusion
[0722] This concludes the description of the preferred embodiment of the invention. The following describes some alternative embodiments for accomplishing the present invention. For example, any type of computer, such as a mainframe, minicomputer, personal computer, mobile device, or embedded system, or computer configuration, such as a timesharing mainframe, local area network, or standalone personal computer, could be used with the techniques of the present invention.
[0723] The foregoing description of the preferred embodiment of the invention has been presented for the purposes of illustration and description. It is not intended to be exhaustive or to limit the invention to the precise form disclosed. Many modifications and variations are possible in light of the above teaching. It is intended that the scope of the invention be limited not by this detailed description, but rather by the claims appended hereto.
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.
Patent Citations (43)
| Patent | Date | Inventor | Cited By |
|---|---|---|---|
| US4525803(A) | 1985-07-01 | Vidalin et al. | Applicant |
| US4646061(A) | 1987-02-01 | Bledsoe | Applicant |
| US5202981(A) | 1993-04-01 | Shackelford | Applicant |
| US5303342(A) | 1994-04-01 | Edge | Applicant |
| US5317736(A) | 1994-05-01 | Bowen | Applicant |
| US5355493(A) | 1994-10-01 | Silberbauer et al. | Applicant |
| US5596748(A) | 1997-01-01 | Kleewein et al. | Examiner |
| US5706499(A) | 1998-01-01 | Kleewein et al. | Examiner |
| US5708828(A) | 1998-01-01 | Coleman | Applicant |
| US5742806(A) | 1998-04-01 | Reiner et al. | Applicant |
| US5745906(A) | 1998-04-01 | Squibb | Applicant |
| US5752252(A) | 1998-05-01 | Zbikowski et al. | Applicant |
| US5774888(A) | 1998-06-01 | Light | Applicant |
| US5835904(A) | 1998-11-01 | Vicik et al. | Examiner |
| US5864866(A) | 1999-01-01 | Henckel et al. | Applicant |
| US5884303(A) | 1999-03-01 | Brown | Applicant |
| US5893119(A) | 1999-04-01 | Squibb | Applicant |
| US5903894(A) | 1999-05-01 | Reneris | Applicant |
| US5987465(A) | 1999-11-01 | Kleewein et al. | Examiner |
| US6233586(B1) | 2001-05-01 | Chang et al. | Examiner |
| US6263342(B1) | 2001-07-01 | Chang et al. | Examiner |
| US6272488(B1) | 2001-08-01 | Chang et al. | Examiner |
| US6343287(B1) | 2002-01-01 | Kumar et al. | Examiner |
| US6370541(B1) | 2002-04-01 | Chou et al. | Examiner |
| US6466933(B1) | 2002-10-01 | Huang et al. | Examiner |
| US6578046(B2) | 2003-06-01 | Chang et al. | Examiner |
| EP169389(A) | 1986-01-01 | Applicant | |
| EP228213(A) | 1987-07-01 | Applicant | |
| EP532004(A) | 1993-03-01 | Applicant | |
| EP632364(A) | 1995-01-01 | Applicant | |
| EP632366(A) | 1995-01-01 | Applicant | |
| EP678986(A) | 1995-10-01 | Applicant | |
| EP711083(A) | 1996-05-01 | Applicant | |
| EP712257(A) | 1996-05-01 | Applicant | |
| EP755161(A) | 1997-01-01 | Applicant | |
| EP757333(A) | 1997-02-01 | Applicant | |
| EP838771(A) | 1998-04-01 | Applicant | |
| EP838771(A2) | 1998-04-01 | Applicant | |
| JP11122116(A) | 1998-04-01 | Applicant | |
| JP11075160(A) | 1999-03-01 | Applicant | |
| WO8802888(A) | 1988-04-01 | Applicant | |
| WO9617306(A) | 1995-11-01 | Applicant | |
| WO9835480(A) | 1998-08-01 | Applicant |
Non-Patent Literature (12)
- Amit P. Sheth et al; Federated Database Systems for Managing Distributed, Heterogeneous, and Autonomous Databases; Sep. 1990; ACM; pp. 183-236.Applicant
- Sheth et al., Federated Database Systems for Managing Distributed Hetogeneous and Autonomous Databases, ACM Computing Surveys, vol. 22, No. 3, Sep. 1990.Applicant
- “DB2 Universal Database Server for OS/390, version 6, DB2 Universal database Extenders”, International Business Machines Corporation, pp. 1-8, May 1998.Applicant
- “Information Intergration with IBM DB2 DataJoinder Version 2”, White Paper, Data Management Solutions, International Business Corporation, First Edition Sep. 1997.Applicant
- “Informix Datablade Technology”, http://www.informix.com/informix/products/options/udo/datablade/dbtech/overview.Applicant
- “Informix Datablade Technology—To get to the top and stay there, your business must work smarter; you must think ahead and continuously adapt to new market conditions and take advantage of new opportunities as they arise”, http://www.informix.com/informix/products/options/udo/datablade/dbtech/ov.../db intro.ht.Applicant
- “Informix Datablade Technology—Informix Dynamic Server-Univeral Data Option fast, Intergrated-and Extensible”, http://www.informix.com/informix/products/options/udo/datablade/dbtech/overview/body.htm.Applicant
- “Informix Datablade Technology—Transforming Data into Smart Data ”, http://www. informix.com/informix/products/integration/datablade/datablade ds.htm.Applicant
- “Jini—Technology Executive Overview”, Sun Microsystems, Inc. Jan. 1999 http://ww.sun.com/jini/overview/overview.pdf.Applicant
- Oracle8i Data Cartridge Developer's Guide Release 8.1.5 A68002-01, Oracle Corporation, 1999.Applicant
- “Jini—Connection Technology”, Sun Microsystems, Inc. 1999 http://www.sun.com/jini.Applicant
- Shatz, B. et al., “Federating diverse collections of scientific literature”, Computer, vol. 29, No. 5, pp. 28-36, May 1996 (abstract).Applicant