JP2002505483A - Method and system for changing inside a database - Google Patents

Abstract

(57) Abstract: In a database system in which one or more entry databases store a plurality of entries, it is possible to change an entry or a set of entries in the database without extracting the entry from the database. A search engine is employed that allows queries to be made for entries in a database. The query includes a read operation, a retrieval operation, and a notification operation. Each query request includes a command indicating the type of operation, a first template, and a second template. The search engine searches for the entry to be manipulated by comparing it with the first template, and changes, adds or deletes the fields of the matching entry within the database according to the fields of the second template. The database may store a set of entries to be compared using the set of entries.

Description

DETAILED DESCRIPTION OF THE INVENTION

(Related Application) This application is a continuation-in-part of US Patent Application No. 08/971529, filed on November 17, 1997, and the description of the following US Patent Application It is a reference for the matters described in the application and forms part of the content of this patent application. Provisional Patent Application No. 60 / 076,048 filed on Feb. 26, 1998, entitled "Distributed Computer Processing System". U.S. patent application Ser. No. 09 / 044,923, filed on the same date, entitled "Methods and Systems for Use of Storage Devices" (Attorney Docket No. 06502.0011-01000). U.S. patent application Ser. No. 09 / 044,838, filed on the same date, entitled "Methods, Apparatus and Products for Use of Delegation Certificates in Distributed Systems" (Attorney Docket No. 06502.001)
1-02000). U.S. patent application Ser. No. 09 / 044,834, filed on the same day, entitled "Method, Apparatus and Product for Use of Group Membership in a Distributed System" (Attorney Docket No. 0
6502.0011-03000,). U.S. Patent Application No. 09 / 044,916, filed on the same date, Title of Invention, "Assignment for Failure Detection" (Attorney Docket No. 06502.0011-04000).

[0002] US Patent Application No. 09 / 044,933, filed on the same date, titled "Method of Transfer Operation in Event-Based System" (Attorney Docket No. 06502.0054-00000). U.S. patent application Ser. No. 09 / 044,919, filed on the same date, titled "Remote Loading and Deferred Reconstruction of Objects for Event Notification in Distributed Systems" (Attorney Docket No. 06502.0062-01000). US Patent Application No. 09 / 044,938, filed on the same date, titled "Method and Apparatus for Remote Method Call" (Attorney Docket No. 06502.0102-00000). US Patent Application No. 09 / 045,652, filed on the same date, entitled "Method and Apparatus for Deterministic Hash to Identify Remote Methods" (Attorney Docket No. 06502.0103-00)
000). United States Patent Application No. 09 / 044,790, filed on the same date, entitled "Method and Apparatus for Determining Status of Remote Objects in a Distributed System" (Attorney Docket No. 06502.0104-00000).

[0003] US patent application Ser. No. 09 / 044,930, filed on the same date, entitled “Downloadable Smart Proxy for Performing Processes Related to Remote Procedure Calls in Distributed Systems” (Attorney Docket Number) no.06502.0105-00000). U.S. Patent Application No. 09 / 044,917, filed on the same date, titled "Suspension and Continuation of Remote Method" (Attorney Docket No. 06502.0106-00000). U.S. Patent Application No. 09 / 044,835, filed on the same date, titled "Method and System for Multi-Entry and Multi-Template Comparison in Databases" (Attorney Docket No. 06502.0107-00000). U.S. patent application Ser.
00000). U.S. Patent Application No. 09 / 044,931, filed on the same day, entitled "Dynamic Search Service in Distributed Systems" (Attorney Docket No. 06502.0110-00000).

[0004] US patent application Ser. No. 09 / 044,939, filed on the same day, entitled “Apparatus and Method for Supplying Downloadable Code for Communication with Devices in a Distributed System” (Attorney Docket No. .06502.0112-00000). U.S. Patent Application No. 09 / 044,826, filed on the same date, entitled "Method and System for Facilitating Access to Search Services" (Attorney Docket No. 06502.0113-00)
000). U.S. patent application Ser. No. 09 / 044,932, filed on the same date, entitled "Apparatus and method for dynamic certification of information in a distributed system" (Attorney Docket No.
0). U.S. Patent Application No. 09 / 030,840, filed February 26, 1998, entitled "Method and Apparatus for Dynamic Distributed Computer Processing Across Networks". US Patent Application No. 09 / 044,936, filed on the same date, titled "Interactive Design Tool for Persistent Shared Memory Space" (Attorney Docket no. 06502)
.0116-00000).

[0005] US patent application Ser. No. 09 / 044,934, filed on the same day, entitled “Diverse Token-Based Control” (Attorney Docket No. 06502.0117-00000). U.S. Patent Application No. 09 / 044,915, filed on the same date, titled "Stack-Based Access Control" (Attorney Docket No. 06502.0118-00000). U.S. Patent Application No. 09 / 044,944, filed on the same date, titled "Stack Based Security Requirement" (Attorney Docket No. 06502.0119-00000). U.S. Patent Application No. 09 / 044,837, filed on the same date, entitled "Specification of Security Requirements for Each Method" (Attorney Docket No. 06502.0120-00000).

BACKGROUND OF THE INVENTION 1. Field of the Invention The present invention relates to a database system, and more particularly, to storage of entries in a database system. The invention further relates to the query contrast method principles used in database systems.

(Description of Related Art) A database system plays an increasingly important role in today's society. The amount of data that can be stored in a typical database system is growing rapidly, and convenient and flexible data access is critical. However, designing a database system that works in an optimal way is difficult.

A particularly important problem in database design is storing data for use in a wide variety of applications, so that the manner in which the database is used can be easily changed in a short time. That is. Further, it is often required to be able to add additional data types or additional categories without significantly affecting other parts of the database.

Unfortunately, changing the manner in which data is used and organized in multiple database systems, and allowing for additional data types and categories,
Extremely difficult. Changes are very costly to implement as they force chain changes to the programs and other elements of the database system. Therefore,
Data processing tends to be tied to old data structures. Furthermore, database designers tend to make many complex choices between one design example and another, and never attempt to produce a design that produces optimal results.

More specifically, storing information in a database system is typically performed in a precise manner. That is, records stored in a database system have certain numerical values and field types, such as sets in a relational database relationship. Each field is, for example, string data,
It is defined to store a particular type of data, such as integer data, Boolean data, or other data types as desired. When a user wants to search information in a database, the user must search for the correct record type (ie, different types of records are generally searched independently). Thus, if the data of interest to the searcher is in a record of any of a number of different types, the searcher must know the pre-existing record type and You need to have a clear strategy to look at. The searcher must also explicitly look through all possible record types to find the particular record of interest.
Therefore, the software associated with a search engine is complex and effectively limits the number of record types that can be included.

In addition, the fields of a record included in a database generally do not refer to other records. As a result, the amount and type of information generally included in one record is reduced. Thus, databases are limited by their ability to store and process records, which are collections of records.

In addition, general database records are not usually associated with different characteristics than the actual data itself. For example, when data is found, no action can be associated with a record that changes with the record type. Thus, the program can obtain record typing results using the various records returned by the control in one way.

With respect to other aspects of the database system, the usual way of specifying attributes or properties in a database is by a simple set of pairs <name, value>. Here, the value is restricted to a string, otherwise it is of any type (type “
any ”). In these pairs <name, value>, the type cannot be restricted, and therefore it cannot be enforced that a particular name always has a value of a particular type. In a temporary printer, the attribute "speed" must be limited to an integer type and must not be set by the user to another type, for example "about 8" or "8 to 9". . Speed represents the number of pages per minute that the printer can print. A similar problem exists if the value can be any type of object. In this case, the user can set the attribute to an integer object rather than a string object, but still cannot prevent other users from accidentally storing the string object in the attribute to be set to an integer. .

Further, the above systems do not restrict the relationship between different attributes (eg, one attribute should only be present when another is present). For example, three exemplary printer attributes, resolution (dots per inch)
, Speed (pages per minute), color (or black and white)
Many printers perform various combinations of these attributes. For example, a typical color printer is described as follows.

5 pages per minute, 600 dots per inch, black and white 7 pages per minute, 300 dots per inch, black and white 1 page per minute, 300 dots per inch, color

However, this attribute has a plurality of values, and some conventional systems allow the attribute to have a plurality of values, and these systems display the attributes as follows. Speed = {1,5,7} Resolution = {300,600} Color = {True, False} However, this does not represent an association between sets of attributes, and obviously three associations Not expressed and not specified.

{Speed: 1, resolution: 300, color: true}; {speed: 7, resolution: 300, color: false}; {speed: 5, resolution: 600, color: false};

Thus, providing a variety of entries, including a set of entries, entry control and entry manipulation, and allowing a large number of efficient searches and allowing simplified software in which many types exist. It is requested to do. It is further desirable to provide a system in which entries define their behavior according to type. In addition, there is a need for enabling type-safe attribute contrasts in databases and enabling restrictions on the relationships between attributes.

SUMMARY OF THE INVENTION The problem described above is solved by a method and system for storing and retrieving entries in a database according to the present invention. In one embodiment, the computer system implements a database system where one or more entry databases store multiple entries. Each entry is of a given type that defines the fields of the entry. Each of the fields contains or defines an object with associated attributes or data. The type of each entry is
Defines the behavior of the form of the method that the entry is configured to execute.
An entry type, which is a subtype of another, inherits all fields and behaviors of its supertype, includes additional fields, and / or defines new or modified behaviors. The entry may be expressed in Java ^™ . Similarly, in one embodiment, each field is represented by a defined class.

The database system further employs a search engine that allows queries to be made for entries in the database. In one embodiment, the query includes a read operation, a retrieval operation, and a notification operation. Each query request includes a command that indicates the type of operation and a template that is an entry object with some or all of its fields set to specific values that are accurately matched. Other fields in the template entry may be specified as wildcards, in which case its value may be anything. The versatile entry-to-entry control technique is advantageous in that it allows queries to match entries of the same type as the template entry, or a subtype of the template entry. As a result, the search can be efficiently executed, and the search engine can be easily implemented. Further, the search engine does not need to know all the possible subtypes. After all, since each entry has an associated class, the entry defines its own behavior by supporting one or more methods. Specific entry methods are invoked to perform various functions, such as identity checks.

The search engine is further configured to index for entries having characteristics normally specified by the query. That is, the search engine detects the usage pattern and creates an index pointing to the entry having the attributes normally specified by the received template. In this way,
A suitable entry search is performed.

In addition, the search engine may be further configured to store the set of entries in a single record. This set of entries is contrasted using a set of templates. In one embodiment, the search engine may further perform operations to modify an entry or set of entries within the database without retrieving the entry or set of entries from the database.

DETAILED DESCRIPTION OF THE INVENTION While specific embodiments are illustrated and described in detail by showing embodiments with the aid of the accompanying drawings, the invention is susceptible to various modifications and other forms. That is, the drawings and detailed description are not intended to limit the invention to the particular forms disclosed, and are not intended to include all modifications, equivalents and alternatives as defined by the appended claims. It should be understood that objects fall within the spirit and scope of the present invention.

A method and system according to the present invention stores and retrieves entries in a database. Each entry has a given type that defines a field of that type,
Each field contains and defines an object of a given type. These entries are represented by Java ^™ classes in the Java ^™ programming language. In addition, the method and system according to the present invention stores and retrieves a set of entries in a database. Generally, these searches are performed using a set of templates. In one embodiment, operations can be performed on entries or sets of entries within the database without transferring entries or sets of entries from the database.

Referring to the drawings, FIG. 1 is a diagram illustrating a distributed system 100 in which various entries, entry controls, and entry operations are used in accordance with the present invention. FIG. 1 shows a plurality of computer systems 101 to 103 interconnected by a network 105. Here, network 105 is represented, for example, by a local area network (LAN), a wide area network (WAN), or the Internet, although there are many other possible communication channels. Each computer system includes a memory and a microprocessor, such as the memory 120 and CPU 122 of the computer system 101. Memory 120 is an example of various types of applicable memory, such as hard disk storage, floppy storage, dynamic random access memory (DRAM). A mounting medium 126 exemplifying one or more CD-ROMs or floppy disks (or other storage media) is further shown in connection with the computer system 101. Generally, the mounting medium 126
Is used to store code and / or data implementing the search engine implementation and other examples of database systems described below, and to enter that code and / or data into the computer system. It should be noted that in another embodiment, the database system according to the invention is also used on a single computer, i.e. a computer system that is not networked.

As described in further detail below, computer system 100 employs a program database system that stores entries of applicable or partial types using object-oriented techniques. This database may also store a collection of entries called a multi-entry. The database entry may be stored alone in the memory 122 of the computer system 101,
It may be distributed in the memories of a plurality of different systems, for example, in similar memories of the computer systems 102 and 103. Each entry has a given type that defines the fields of that entry. Each of the fields contains an object associated with the attribute or data or defines that object (identifi
es) Each of the fields further defines an action in the form of a method in which the entry is configured to be performed. The entry type, which is a subtype of the others, inherits all fields and behaviors of the supertype, includes additional fields, and / or defines new and / or modified behaviors.

The database system further employs a search engine executed by software that allows queries to be made based on entries (or multiple entries, described below) in the database. In one embodiment, each query includes a template that specifies the value (or attribute) of a key field of a given entry that must match the corresponding field of the template for a correct match. Other fields in the template entry may be specified as wildcards (indicating any value). The various entries and entry control techniques used in computer system 100 advantageously allow queries that may result in matching entries that are the same type of template entry or a subtype of the template entry. Is generated. In addition, a detailed description of various entry and example entry control techniques is provided below in accordance with FIGS.

FIG. 2 shows an example of a communication flow between a set of clients (or users) and a plurality of entry databases 206-208. Entry database 2
Each of 06 to 208 is distributed across one or more memory subsystems of the distributed system 100. Each client 202 and 204 is configured to generate a query that is provided to one or more entry databases 206-208. Clients 202 and 204 are further configured to store (write) entries in entry databases 206-208, as described below. FIG. 2 shows an event receiving unit 2 having a function described in detail below.
10 is shown.

(Entry Control and Operation) FIG. 3 shows a plurality of entries stored in any of the entry databases 206 to 208.
Here is an example entry. In one example, each entry is a Java^TMProgramming language
Java^TMA typed group of objects represented by a class. Java ^TM The programming language is "Java," written by Ken Arnold and James Goslin.^TMProfessional
Gram Language ", Addison-Wesley, 1996.
The contents described in are referred to and are part of the contents of this specification.
You. Java^TMIs a registered trademark of Sun Microsystems, Inc. in the United States and other countries.
It is. However, in other embodiments, the entry may be in another programming language.
It may be understood that the class may be defined by

As shown in FIG. 3, entry 1 includes a set of four fields (field A, field B, field C, and field D), and is defined by class type entry 1. Entry 2 includes a set of five fields (field A, field B, field C, field D, and field E), and is defined by class type entry 2. It should be noted that entry 2 is a subtype of the type of entry 1 because it contains the same field types as entry 1 in addition to other types.

Entry 3 includes a set of four fields (field W, field X, field Y, and field Z), and is defined by class type entry 1. Note that entry 1 and entry 3 each include four fields, but are of different types because they do not match. Many other types and subtypes may also be associated with the database system, depending on the needs of the particular application or database.
In addition, it should be noted that entries that are subtypes of subtypes can also be used. To illustrate, the following code is shown as a specific example entry defined in the Java ^™ programming language.

A “bid request” object for book purchase, public class RFB implement Entry {public integer order number; // purchase tracking number for this order public String title; // book title public integer count ; // desired version number} ------------------------------------------ -a "full" request for bids, ie one containing ISBN, public class FullRFB extends a RFB {public String isbn; // ISBN field}

Referring to FIG. 3, each field of the entry is configured to store a value that points to or specifies the typed object. Each of these typed objects is similarly represented in Java ^™ . For example, field A of entry 1 contains a value specifying object 310, and field B of entry 1 specifies object 312. Similarly, field A of entry 2 specifies object 314, field B specifies object 316, and so on. With regard to the example entry of FIG. 3, since entry 2 is a partial type of entry 1, object 310 associated with field A of entry 1 is represented by the same class type as object 314, and entry 2
Should be noted. Object 31
The attributes or data associated with each of 0 and 314, however, may be different. It should further be noted that the objects specified by the fields of the various entries, as required by the defined type, include integer data, Boolean data, string data, and other data types.
Further, it should be noted that since each field is associated with a typed object, the method is supported and selectively invoked by external stimuli to perform data manipulation as required. Similarly, as described below, each entry type supports one or more methods.

Referring again to FIG. 2, as described above, each entry database 206,2
07 and 208 store many entries of various types that are subtypes. Entries are stored in a given entry database 206-208 by a write operation invoked by the client. Entries are further provided with a mounting medium (
The data is supplied to the entry database via the mounting medium 126 shown in FIG.

As shown in FIG. 4, some additional operations are further supported by the system. That is, the client or the user starts the reading operation, the extraction operation, and the notification operation in addition to the writing operation.

The read, retrieve, and notify operations are used to search a particular entry database, respectively, to determine whether an entry with any specified characteristics has been written to the entry database, and , It is determined whether or not a specific operation is to be induced if written. In particular embodiments, these queries are generated using a template that defines the type of entry associated with the operation and is included as part of the operation request. A read operation is an operation that starts reading an entry in the entry database that matches the associated template. The fetch operation is similar to the read operation, except that the fetch operation removes entries matching the template from the entry database. Finally, the notification operation is
An operation that registers interest in future incoming entries in a specified entry database that matches the associated template. When a matching entry arrives, the client or a particular event receiver is notified.
Details regarding each of these operations are provided below.

FIG. 5 shows an example of a template. Generally, a template specifies a particular entry type whose fields have either a value (a reference value to an object) or a wildcard. Assuming that a particular entry in the entry database is a possible match for the template, the attributes of the specified field of the entry (ie, those that do not correspond to the wildcarded fields of the template) are: , Exactly (or possibly within) the attributes specified by the corresponding fields in the template.
The fields of the entry that correspond to the “wildcard” fields of the template may have any attributes and do not affect the result of the control (ie, the wildcard in the template is the value of any value in the same field of the entry) Also fits). In one embodiment, the wildcard is specified by a null reference value. As described further below, the types of entries that fit the template are:
It may be a subtype of the template type. Thus, all fields of a particular entry defined by a subtype are considered to be wildcards. This allows the template to match any subtype entry. Note that entries that do not contain wildcards may be valid templates.

FIG. 6 is a flowchart illustrating an embodiment of a method for searching for an entry in a particular entry database in response to a read or retrieve request according to the present invention. As described above, a read request is initiated by a client (or user) to read an entry that matches a given template. The removal request is
Remove entries matching the given template from the entry database.

(1) (Entry Control Method) The steps shown in FIG. 6 are described in conjunction with FIG. 7, and FIG. 7 shows an operation example of a database system using the search method principle of FIG. The functional components shown in FIG. 7 are realized by a combination of software and hardware related to one or more of the computer systems 101 to 103 in FIG. In step 602,
A read or unload request is provided from the user 702 to the database manager 704. A given request includes a specified template (eg, one of which is template 706 in FIG. 7). Subsequently, in step 604, the search engine 708 of the database manager 704
A search for 0 determines whether a matching template type or template subtype exists in the entry database 710. If there is no entry of the same type as the template or its subtype in the entry database 710 (
In steps 606) and 608, the database manager 704 returns a null value to the user 702.

If the search engine 708 determines that one or more entries in the entry database 710 that match the template type or its subtype,
The fields of the selected entry (of the same type or a subtype thereof) are compared with the corresponding fields of template 706 that are not specified as wildcards (step 610). Search engine 708 ignores all fields of the selected entry that correspond to the wildcard fields of the template (step 612). In one particular embodiment, search engine 708 determines that the attribute or data associated with the non-wildcard field of the entry is exactly:
It is determined whether the attribute or data of the corresponding template entry matches. If an attribute of a field other than a wildcard does not exactly match a field of the template, it is determined that a match does not occur for that entry. It should be noted that in other embodiments, the fields of the template are specified with a range of values (which do not require an exact match) so that the data in the corresponding field will eventually match.

(2) Embodiment In the embodiment illustrated by FIG. 7, field C of template 706 is specified as a wild card. Thus, when the search engine 708 searches the entry database 710 for a matching entry, the search engine 708 first determines whether the entry that is the type of the template 706 or a subtype thereof is the entry database 710. It is determined whether or not it exists. As shown, entry 1 and entry 2 satisfy this condition. The search engine 708 selects one of these entries (eg, entry 2 as shown) and compares the fields of that entry with fields of the template that are not specified as wildcards. The search engine 708
It is determined whether each of the non-wildcard fields of the template matches each attribute of the corresponding field of the entry. Note that FIG.
Since the field C of the template 706 is designated as a wild card, the attribute of the field C of the entry 2 is ignored and does not affect the comparison operation. Similarly, those fields of all entries defined by the subtypes of the template type are ignored (even though the attributes of the wildcard field do not match, there is a match). . If a matching entry is found (all non-wildcard fields match)
The search engine 708 reads the matching entry from the entry database 710 and provides it to the user, or removes the entry from the entry database 710, depending on whether the request is a read request or a retrieval request. Search engine 708 searches entry database 710 until a match is found, or until all of the entries have been examined. If a search of all entries in the database does not find a matching entry, the database manager 704 returns a null value (step 616) to the user 702.
To return.

(3) Notification Referring now to FIG. 8, a flowchart illustrating an embodiment of a method principle implemented by a search engine 708 for processing a notification request received from a user in accordance with the present invention is shown. Have been. As described above, a notification request is issued by a user to register interest in future incoming entries that match the template. When a matching entry arrives, the database manager notifies the user or event receiver (FIG. 2). When the user issues a notification request, a registration time indicating the length of the period for registering the notification is specified. When the specified time has elapsed, the notification registration is canceled.

Thus, as shown in FIG. 8, when database manager 704 receives a new notification request (step 802), incoming entries are monitored until the registration time expires (steps 804 and step 804). 806). An entry that is a template type or a subtype thereof is stored in an entry database 7.
Once written to 10 (step 808), the fields of the entry are compared to determine if their attributes match the attributes associated with the non-wildcard fields of the template (step 810). As before,
If the field of the incoming entry is used with a wildcard or defined by a subtype of the template entry, it is ignored (step 812). If a match is found, the user or the event receiver is notified (steps 814 and 816). In addition, incoming entries are monitored as long as the registration time has not expired.

(4) Index Creation Returning to FIG. 7, the search engine 708 further includes a database manager 70
4 generates an index of entries having the properties normally specified by the query received. That is, upon detecting a predetermined usage, the search engine 708 generates an index 720 pointing to an entry having the normally specified characteristics specified by the received template. As an example, when database manager 704 receives several query requests that use a template of the same type or subtype as template 706 shown in FIG. Detect that an attribute value (eg, an integer value of 1000) is specified in each template of many requests. In one embodiment, when database manager 704 detects the normal template usage specified by many requests, it responds in response to the same type, or portion thereof, as a normally received template in entry database 710. For every entry that is of type and has the usual attributes specified by field A, create an index 720 indicating its location; Thus, when a new query is received having a similar template (ie, a template with a value of 1000 for field A), search engine 708 can use index 720 to search the entire set of entries in the database without having to search index 720. Quickly locate the subset of entries that match the template.

An embodiment of the principle of this indexing method is illustrated in FIGS. 9A and 9B. As shown in FIG. 9A, based on the request template (step 9
10) determining whether there is a pattern (eg, one (or more) specific non-wildcard field fields) associated with the template specified by the same attributes and values (step 912) Thus, an index for an entry corresponding to a specific template classification is created. This determination is made by receiving a predetermined number of queries having a similar template at a particular time, or by receiving a percentage of queries having a similar template. When the search engine 708 detects an ordinary template usage pattern, it creates an index for entries of a particular template category (step 914). Thus, for the above example, search engine 708 creates an index for all entries of the same type as template 706, or a subtype thereof, where field A has a value of 1000.

As shown in FIG. 9B, when a new request is received at step 920, a normal search is performed if no index exists for the particular template classification (steps 922, 924). When an index classification exists for a new request template, that index is used to find a subset of possible matching entries and their equivalents. With this style, highly convenient search is realized. Note that the search engine 708 may then purge the index, if desired, if normal usage is no longer detected.

As mentioned above, entry types may further define methods for performing certain operations. The method is invoked by an external stimulus (e.g., a software program associated with the database system and processing the entries). Such specific actions affect the data present in the entry. In addition, although the format of the data is different, a method is used that performs an efficient match check to determine whether a particular entry is equivalent (or equal to a template) to another. For example, an entry that stores reconstructed video data may be considered equivalent to another entry that stores the video data in a compressed form. Even though the data actually stored may be different, such an entry match determination method may be provided (e.g., whether the object references the same potential pathname in the file system associated with the video). The method to determine is called.).

It should be further noted that the entries are stored in an embodiment-specific representation including the class of the entry and the serial form of each field of the entry. The template serial form is compared to the entry serial form. Finally, note that entries may be specified by fields of other entries.

Multi-Entry and Multi-Template Contrast Another embodiment performs operations and contrasts on items in the database, where each item defines a set of entries. As used herein, "items" are referred to as "multi-entries" and "multi-templates" (or "item templates") are used to refer to a set of templates, both terms of which are items in a database. Used to control. This section further describes in detail the multi-entry and multi-template comparison process and the operations involving multi-entries and multi-templates. Many operations of multi-entry and multi-template are similar to the operation of single entry and single template described above.

FIG. 10 is a diagram showing an example of a plurality of multi-entries that may be stored in any of the entry databases 206 to 208. In the method and system according to the invention, each multi-entry is a group of entries, each entry being, for example, a typed group containing objects represented by Java ^™ classes of the Java ^™ programming language. In other words, a multi-entry is a collection of entries and has no type in itself.

Referring to FIG. 10, the multi-entry 1 includes four elements (element A, element B, element C, and element D) as shown. Since the multi-entry is of variable length, the multi-entry 2 in this example has five elements (element E, element F, element G
, Element H, element I), the multi-entry 3 of this embodiment.
Includes a set of three elements (element J, element K, and element L). Each element of the multi-entry is configured to store a typed entry. As described, each of these typed entries is represented in a Java ^™ class, and the fields of the entry store values that represent the typed object. For example, element A of multi-entry 1 contains a value representing entry 1010 and element B of multi-entry 1 represents entry 1012. Similarly, element E of multi-entry 2 represents entry 1014, element F represents entry 1016, and so on. Note that in the multi-entry example of FIG. 10, all entries have the same type, but the attributes or data associated with the entries are different.

Since multi-entries and multi-templates are just sets, they can be represented using a suitable set representation. For example, a suitable representation in many programming languages, including the Java ^™ programming language, is an array. The size of the array is given by the number of entries in the multi-entry or the number of templates in the multi-template, and each element of the array is an entry (for a multi-entry) or a template (for a multi-template). is there.

Returning to FIG. 2, as mentioned above, entry databases 206, 207 and 208 store a number of multi-entries. Multi-entries are stored in a given entry database 206-208 by a write operation invoked by the client. Further, multi-entries may be provided to the entry database by a mounting medium (eg, mounting medium 126 of FIG. 1). As with the single entry embodiment, some additional operations are supported by the system, as illustrated by FIG. That is, in addition to the write operation, the client or user can start a read operation, a write operation, or a notification operation.

The read operation, the ejection operation, and the notification operation operate a multi-entry in the same manner as the operation for a single entry. In one embodiment, these queries are generated using the multi-entries included as part of the operation request to define the multi-entries of interest for the operation. As with the single entry case, the read operation reads multiple entries in the database that match the given multi-template. Again, the fetch operation performs the same function as the read operation and removes the multi-entry read from the database. The notify operation is used to register interest in a multi-entry in advance and notifies the client or event receiver when a matching multi-entry arrives in the database.

FIG. 12 illustrates a multi-entry embodiment. In general, a multi-template specifies a particular multi-entry whose elements include the template, as described above. The multi-template 1200 shown in FIG. 12 has four elements:
Although it has W, X, Y and Z, it should be noted that the number of elements included in the multi-template may be any number. However, in the embodiment of the present invention, the multi-
Each element of the template 1200 includes one template 1202.

(1) Contrast between Multi-Entry and Multi-Template Generally, if each template of the multi-template has a matching entry in the multi-entry, the multi-template matches the multi-entry. I do. Each entry of the multi-entry may match multiple templates of the multi-template. For example, one in a multi-entry
A single entry may match all templates in the multi-template, in which case the multi-entry and the multi-template are determined to be compatible. Determining whether a multi-entry matches a multi-template involves comparing each entry of the multi-entry with an individual template of the multi-template. The comparison between individual templates in such a multi-template and the individual entries in the multi-entry is performed in the same manner as the above-described single-entry and single-entry comparison.

FIG. 13 is a flowchart illustrating one embodiment of a method for searching for a multi-entry in a particular entry database in response to a read or retrieval request.
The steps illustrated in FIG. 13 will be described with reference to FIG. 14 illustrating an operation example of a database system employing the search method principle of FIG. The functional components of FIG.
This is realized by a combination of software and hardware that cooperate with one or more computers 101 to 103. At step 1302, a read or retrieve request is provided from the user 702 to the database manager 704. A given request includes a specified multi-template (eg, one of which is template 1200 in FIG. 14). Subsequently, the search engine 708 of the database manager 704 searches the entry database 710 to determine whether a multi-entry matching the multi-template exists in the entry database 710.

To search the entry database 710, the search engine 708 selects a multi-entry in the entry database 710 and compares it with the provided multi-template (step 1304). And search engine 708
Compares each template in the multi-entry with the entries in the multi-entry to determine whether the multi-entry matches the specified multi-template (step 1306). If there is a matching entry for all templates in the multi-template, it is determined that the multi-entry matches the multi-template (step 1308). Each entry of a multi-entry may match multiple templates of a multi-template. If it is determined that all templates of the multi-template have matching entries in the multi-entry (step 1310), the multi-template is determined to be compatible with the multi-entry and the multi-entry is determined. Returned (step 1312). This process is repeated until all entries in the database have been examined.

If no match occurs between the selected multi-entry and the multi-template provided by the operation, search engine 708 searches for another multi-entry in entry database 710 (step 1314). . If no multi-entries in the database match the multi-template, a null value is returned (step 1316). When a plurality is found, one multi-entry may be returned, or the requested number of matching multi-entries may be returned. When the original request from the client arrives as a fetch request, the matching multi-entry is removed from the database.

(2) Embodiment In the embodiment shown in FIG. 14, the search engine 708 selects one of the multi-entries (eg, the multi-entry 2 shown) and multiplies the entries of the multi-entry.・ Compare with the template of the template. In this example, search engine 708 receives a request that includes multi-template 1200.

The search engine 708 determines whether a template in the multi-template 1200 matches an entry of the selected multi-entry in the entry database 710. The search engine 708 uses the multi-template 12
The template of the element W of 00 is compared with the elements E, F, G, H, and I of the multi-entry 2 of the entry database 710, and it is determined whether any of these entries matches the template. When the search engine 708 finds a match with the template in the element W of the multi-template 1200, it tries to find a match with the template of the element X of the multi-template 1200. Next, element X of multi-template 1200 until a match is found.
Is compared with each entry of the multi-entry 2. Note that each of these entries for elements E, F, G, H, and I are compared to another template of the multi-template (ie, the template for element W) and then to this template again. Sometimes. If a match is found for the template for element X, the search engine 708 proceeds to the multi-template 1200
Are examined in the same manner. Each entry is compared to multiple templates, so for example, multi-entry 2
May be compatible with all of the W, X, Y, and Z templates of the multi-template 1200. Multi template 120
If each template of 0 has a matching entry in multi-entry 2, then multi-entry 2 is determined to be compatible with multi-template 1200.

As with the single entry operation, when a matching multi-entry is found, the search engine 708 determines a matching multi-entry from the entry database 710 depending on whether the request is a read request or a retrieval request. Read or remove the entry and supply it to the user. Search engine 708
Searches the entry database 710 until a match is found or all multi-entries have been looked up. If no matching multi-entry is found, the database manager 704 assigns a null value to the user 702
Return to

(3) Notification Referring now to FIG. 15, there is shown a flowchart illustrating one embodiment of a method principle performed by the search engine 708 to process a notification request received from a user. The notification operation is similar to the notification in the case of a single entry, and is issued by the user to register interest in a multi-entry that matches a future incoming multi-template, as described above. When a matching multi-entry arrives, the database manager 704 notifies the user or event receiver (FIG. 2). When the user calls the notification request, a registration time indicating the length of the period during which the database manager 704 registers the notification is specified. Upon expiration of the specified time, notification registration is canceled.

Thus, as shown in FIG. 15, when the database manager 704 receives a new notification request (step 1502), it monitors the incoming multiple entries until its registration time expires (step 1502). 1504, step 1506). Once the multi-entry is written to entry database 710, search engine 708 determines whether the multi-entry matches the multi-template. As described above, if each template of the multi-template has a matching multi-entry in the multi-entry (step 1508, step 1510), it will be matched and the user or the event receiver will be notified. A notification is provided (step 1512). Subsequent multi-entries are also monitored until the registered time has expired (step 1504).

(Internal Entry Change) In an alternative embodiment, the entry and multi-
Change an entry. According to the invention, this embodiment applies both to the example with entries / templates and to the example with multi-entries / multi-templates. In this embodiment, the fields of the entry can be changed inside the database, and in the case of multiple entries, the entries in the multiple entry can be added, changed and deleted. . The term "internally" means that the entry or multi-entry is changed in the database without removing it from the database.

Internal change operations according to this embodiment of the invention include “single entry change”, “multi-entry add”, “multi-entry change / delete”, and “notification”. FIG. 16 illustrates these internal changes and the information provided by the user to request the changes. This single entry change operation,
Change the value of individual fields in database entries. A multi-entry add operation adds an entry to a multi-entry existing in the database, and a multi-entry change / delete operation changes or deletes a multi-entry entry in the database. For internal changes, the notify operation signals that a match has occurred due to a change in an entry or multiple entry in the database. In general, the first parameter of the operation request represents the entry to be changed or multiple entries in the database, as shown in FIG. 16, and the second parameter represents the change to be performed.

(1) Single Entry Change FIG. 17 shows a flowchart illustrating an embodiment of a single entry change according to the present invention. Further, reference is made to FIG. 7 to illustrate the structural aspects. To invoke a single entry change to change the value of an individual field in the entry, the user 702 generates a request containing two templates (step 1700, see FIG. 16). The first template 1602 is used to represent the database entry to be changed and the second template 1604
Is used to change the entry and represents the change to be performed. With these two templates, by identifying the entry and modifying it,
Since the same entry is operated, the second template 1604 is of the same type as the first template 1602 or a higher type thereof. Further, the single entry change procedure may include a type for checking the template.

First, the search engine 708 searches for an entry in the entry database 710 that matches the first template 1602 received from the request from the user 702. When comparing database entries to the first template,
As described above, a comparison is made by comparing the single entry with the template. If there is no entry matching the first template in the entry database 710 (step 1704), the search engine 708
Return zero indicating the number of entries changed by this operation to the user (1
712). If a matching entry is found, the second template 1604 is used to modify the entry within the database, ie, the entry is not removed from the database for modification. The second template 1604 is
Of the same type as the template 1602 of the first template
Since 602 is the same type as the entry to be changed or a higher type thereof, the second template 1604 is the same type as the entry to be changed or a higher type thereof,
The second template 1604 is the same field group as the field group of the entry to be changed or a subset thereof. To change the matching entry, the value of the non-null field of the second template 1604 is used to replace the value of the corresponding field of the entry (step 1708). The value of the field of the entry corresponding to the null field or the wildcard field of the second template 1604 is not changed. After changing the entry in the database, search engine 708 continues to search for the entry to be changed. If there are other database entries that match the first template 1602 (step 1710), those entries are similarly modified (step 1708). Upon completion, search engine 708 returns a number representing the number of entries changed by the operation (step 1712).

(2) Multi-Entry Addition FIG. 18 is a flowchart illustrating the steps of a multi-entry addition operation according to the present invention. Generally, a multi-entry addition operation is to add an entry to a specified multi-entry in the database. The user 702 requesting this operation supplies two parameters, the multi-template 1606 and the multi-entry 1608, to the search engine 708 (see FIG. 16).
The first parameter, multi-template 1606, is used to specify the multi-entry of the entry database to be changed, and the second parameter, multi-entry 1608, is the entry to be added to the specified multi-entry database. Is a set of The search engine 708 performs a multi-entry / multi-template comparison as described above to search for a multi-entry in the database that matches the multi-template 1606 provided by the user 702 (step 1802). If no matching multi-entry is found (step 1804), search engine 708 returns zero to user 702 indicating the number of multi-entries to which the entry is added (step 1812).

When a matching multi-entry is found (1804), the user 70
2 are added to the matching multi-entries found in the entry database without removing the matching multi-entries from entry database 710. After adding to the multi-entry in the database, the search engine 708 continues to search for the multi-entry to change. If there is another multi-entry in the entry database 710 that conforms to the multi-template 1606 given as the first parameter of the operation request (step 1810)
), The entries of the multi-entries 1608 of the operation request are similarly added to these multi-entries (step 1808). Finally, search engine 708 returns a number representing the number of multi-entries to which the entry has been added.

(3) Multi-Entry Change / Delete FIG. 19 is a flowchart illustrating a method of performing a multi-entry change / delete operation according to the present invention. The multi-entry change / delete operation corresponds to the multi-entry of the database corresponding to the multi-entry entry included in the request.
Change the entry of the entry or delete the entry from the multiple entries in the database. When search engine 708 receives a multi-entry change / delete request, the request includes two multi-templates, multi-template 1610 and multi-template 1612, as two parameters. The multi-template 1610 can be modified or
Used to specify the multi-entry of the entry database 710 from which the entry is deleted, the multi-template 1612 supplied by the user 702 specifies the modification or deletion to be performed on the entry of the matching multi-entry. I do.

The multi-template 1612 provided by the request includes the same number of templates as the multi-template 1610. Further, each individual template is of the same type or a supertype as the corresponding template of the multi-template 1610 (ie, all templates (i) of the multi-template 1612 are the same as the templates (i) of the multi-template 1610. It is the same type as) or its higher type.) For example, the first template of the multi-template 1610 is:
The first template of the multi-template 1610 has the same type as the first template or a higher type thereof, and the second template has the same type as the corresponding second template or a higher type thereof, and so on. . Unlike normal multi-templates, the multi-template 1612 templates for request parameters may be null values, and these templates represent deletions from multi-entries, as described below. Sometimes used for:

The search engine 708 first searches for a multi-entry that matches the multi-template given as the first parameter of the operation request (step 190)
2). If no match is found, zero is returned indicating the number of multi-entries to be changed (step 1914). If a matching multi-entry is found in the entry database 710, it is modified using the multi-template 1612 from the operation request. To complete this change, for each non-null template in multi-template 1612, the entry corresponding to the matching multi-entry in entry database 710 is changed according to the non-null template in multi-template 1612 ( Step 1908). This change is performed by the aforementioned single entry change, which is made internally in the entry database 710 without removing the matching multi-entry. For example, if template (i) in multi-template 1612 has a non-null value, entry (i) in the multi-entry to be modified may be modified using single entry modification to form template (i) of multi-template 1612. ) (See step 1708 in FIG. 17; however, template (i) of multi-template 1612 is used as template 2). The value of the non-null field of template (i) is used to replace the value of the corresponding field of the existing entry to be changed.

For all null templates of a given multi-template 1612, the corresponding entry in the matching multi-entry is deleted (ie,
For all templates (i) of the multi-template 1612 that are null, the entry (i) of the multi-entry to be changed is deleted. ) (Step 1910). Multi-template of database conforming to multi-template 1610
If entries exist, these steps are performed in the entry database 71
Repeated to change the remaining matching multi-entries of zero. When search engine 708 completes the change, it returns a number representing the number of changed multi-entries (step 1914).

However, when executing the multi-entry change / delete operation, an exceptional case occurs. In multi-entry / multi-template control, multi-
Since an entry in an entry may match multiple templates of a multi-template, the multi-entry may match the multi-template and have fewer entries than the template that the multi-template contains. Such a multi-entry would conform to the multi-template 1610 and be modified by a modify / delete operation in accordance with the present invention.
Twelve templates are used to change or delete a single entry of the multi-entry to be changed. In this case, any such template in multi-template 1612 (i.e., the template corresponding to the template in multi-template 1610 that matches the entry of the multi-entry to be modified) indicates a delete operation (i.e., , Null.)
, The entry of the multi-entry being changed is deleted. Otherwise, all such templates in multi-template 1612 represent a change operation, and all templates are used for the change, but the decision on the instruction to make the change is implementation specific. Yes, it is not important for the whole change / delete operation.

(4) Change Notification With respect to internal changes, in another embodiment according to the invention, the user registers his interest in the database entry or multi-entry and returns it to the user or event receiver as described above. Be notified. In this example,
When a user registers an interest in an entry or multi-entry in the database by supplying a template or multi-template, the search engine 708 may filter the incoming entry or multi-entry, as was done above. It does not monitor. When performing internal change notification, it monitors changed or changed entries or multiple entries in the database. Monitoring changed or multiple entries in the database, rather than entries coming into the database, is the main difference between the previous notification operation and this notification operation relating to internal changes. However, many of the basic outlines of notifications are the same.

Generally, template 1614 or multi-template 1616 is used to register interest in changing entries or multi-entries. When a multi-entry or entry is changed due to an internal change, the search engine 708 may determine whether the changed entry or multi-entry matches the registered template or multi-template, or A check is made to determine whether the multi-entry or entry has transitioned from a state that conforms to the template or multi-template to a state that does not conform to the non-conforming template or multi-template. Accordingly, the notification operation searches for a conformance state transition, either a transition from conforming to non-conforming or a transition from non-conforming to conforming.

Referring now to FIG. 20, a method principle for processing a notification request received from a user to monitor a changed entry or a change in a multi-entry, as performed by the search engine 708, A flowchart illustrating an embodiment is shown. In this case, the notification request is issued by the user and, in connection with the supplied template 1614 or multi-template 1616, the designated entry or multi-template to determine if they change conformance. A request to register interest in an entry. When an entry or a multi-entry is changed, its conformance transitions and the template 1
614 or multi-template 1616 may change from conforming to non-conforming, or from non-conforming to conforming. A notification request has been made and template 1614 or multi-template 1616
, When an entry or multi-entry changes its relevance, the database manager 704 notifies either the user or the event receiver as desired (see FIG. 2). When the user issues a notification request, a registration time indicating the length of time during which the database manager 704 registers the notification is specified. Upon expiration of the specified time, notification registration is canceled.

Thus, as shown in FIG. 20, the database manager 704 receives new notification requests (step 2002) and, if entries or multi-entries are changed, keeps them until the registration time expires. Monitored (steps 2004 and 2006). If an entry or multi-entry is changed in the entry database 710, the search engine 708 determines whether the changed entry or multi-entry has been matched for the template 1614 or multi-template 1616 received in the notification request. It is determined whether it has been changed (steps 2008 and 2010). The search engine 708 determines whether the changed entry or multi-entry has transitioned from a state that conforms to the requested template or multi-template to a state that does not conform, or vice versa. When the transition of the adaptation state occurs, the user or the event receiving unit is notified (step 2012). Thereafter, internally modified entries or multiple entries are continuously monitored as long as the registration time has not expired (step 2).
004).

(Type Contrast Attribute Contrast) Another embodiment of the present invention includes attributes that represent various values of a database entry represented as an object. In this embodiment, type-safe attribute matching is achieved by associating attributes with the fields of the entry, using entries, multi-entries, and their operations. Attribute objects for type assurance include searching for various types of attributes in the database, allowing attributes to be strongly typed. Further, it can enforce relationships between attributes, allowing for efficient reference and manipulation of attributes by type.

Using type-safe attribute contrasts, strict associations are made not only between attributes and their values (pages per minute is associated with an integer), but also between attributes and names ( The “pages per minute” attribute is associated with the printer.) Type-safe attribute contrasts can also enforce relationships between attribute sets and their values.
It allows many different types of objects to be stored in the database, allowing for efficient retrieval of the objects. Further, allowing for changes that affect only specified types of objects in the database, the database may store many different types of objects.

In accordance with the present invention, type-safe attribute matching is accomplished by associating attributes with fields of an entry. The value stored in the field of the entry is the value of the associated attribute. A set of attributes (in this case, an entry) can be instantiated by a Java ^™ class, which provides strong typing of both sets and individual attributes. For example, the following example uses fields representing printer attributes (ie, pages per minute, resolution, etc.) in addition to entries representing comprehensive information such as name, product name, and physical location. 2 illustrates an entry representing a typical printer.

Public class Printer implement Entry {integer ppm; // pages per minute integer dpi; // resolution expressed in dots per inch Boolean duplex // duplex printing Boolean color // color or black and white} public class Name implements Entry {String name; // friendly name of service String description; // formal description of service String language; // language used in language (language)} public class Type implements Entry {String type; / / General type of service String vendor; // vendor of the product that performs the service (vendor) String model; // model number of the product / model name String version; // version number of the product public class Location implements Entry { Integer floor; // the floor where the service is located String building; // the building where it is located String room; // the room where it is located}

As shown in the table, not only the entries but also the fields are strongly typed, and these fields and their types are always associated with these entries and their types. For example, "ppm" or "pages per minute"
It is of type "integer".

Other descriptions of items are made using multi-entries. With multi-entry, a typical printer is described as a set of attribute sets. When describing a typical printer in this manner, additional aspects such as location, name, model, and the like may be included, with each aspect being represented by other entries in a multi-entry. The set of entries in the above example constitutes an exemplary multi-entry representing the attributes of a typical printer.

Entry and multi-entry operations are used to retrieve and manipulate these type-safe attribute sets. These operations include fetch, write, notify, read, change entry, multi-entry addition, multi-entry change / delete and change notification. Note that other known database operations may be performed in the database system according to the present invention.

For example, assume that there are two printers described by the next multi-entry stored in the database. Each printer has the characteristics described by the attributes associated with the fields of the multi-entry entry. In this hypothetical example, the first printer has the English name "quick" and the German name "schnell", both of which are associated with a description. As shown in the example, it is located on the ground floor room 1202 of the ABC building and is associated with printing properties (eg, ppm = 10, dpi = 600, etc.). Such a printer is represented by the following multi-entry.

Multi-Entry 1 = {Name [name = "quick", description = "yada1", language = "English"], Name [name = "schnell", description = "yahda1", language = "Germany"] , Location [floor = 1, building = "ABC", room = "1202"], Printer [ppm = 10, dpi = 600, duplex = true, color = false]}

The second printer has the English name “Slow”, is located in Room 101 on the second floor of the XYZ building, and is tied to the printing characteristics (for example, ppm = 3, dpi = 30).
0 etc.). The second printer is represented by the following multi-entry.

Multi-Entry 2 = {Name [name = "slow", description = "yada2", language = "English"], Location [floor = 2, building = "XYZ", room = "101"], Printer [ppm = 3, dpi = 300, duplex = fales, color = true]}

Now, assume a search that requires returning all printers having the attributes represented by the fields of the entry. For example, when a user searches for a printer stored in a database that is a color printer and is located in an XYZ building, the database search multi-template is represented as follows.

Multi-Template 1 = {Location [floor = null, building = "XYZ", room = null], Printer [ppm = null, dpi = null, duplex = null, color = true]}

The user invokes a read operation that supplies the multi-template 1 as a parameter. When applied to a database containing multi-templates 1 and 2, a multi-entry 2 representing the second printer from the above example is returned. This is because multi-template 1 matches multi-entry 2 as shown here. The search engine 708 searches the database and bypasses the incorrectly typed item and compares the value stored in the field of the entry with the value of the requested template. As a result, only those having the correct attribute value are returned. This type-safety contrast allows objects of different types to be stored in the same database and retrieved efficiently.

For operations performed on databases employing type-safe attribute contrasts,
Assume that a change in type-safety has been requested for all items stored in the database having particular characteristics. In this case, the entry / multi-entry change operation is used to change an entry in the database. For example, assume that all locations are configured to change a black and white printer (color = false) at a particular resolution (dpi = 100) to remove their location attributes. As mentioned earlier,
The entry change / delete operation uses two parameters, a multi-template to determine which multi-template in the database is to be changed and a multi-entry to represent the change to be made. Supplied to indicate a change in Referring back to the previous example, the first parameter of the multi-entry change / delete operation is expressed in the form of a multi-template as:

Multi-Template 2 = {Location [floor = null, building = null, room = null], Printer [ppm = null, dpi = null, duplex = null, color = false]}

This multi-template looks for all black and white printers regardless of location. Finally, a change / delete operation is initiated by the next request to change all multi-entries with this 100 dpi resolution characteristic and remove their location attributes.

Multi-entry modify / delete {Multi-Template 2, {null, Printer [ppm = null, dpi = 100, duplex = null, color = null]})

The search engine 708 locates all multi-entries in the database that match the multi-template 2 and, as described in the multi-entry change / delete operation method, performs a second operation on that operation. Change them according to the parameters. The multi-entry 1 in the previous example matches the multi-template 2 used in its operating parameters, so that multi-entry 1
It is changed according to the second parameter of the operation. This operation deletes the location attribute and replaces the value of the dpi attribute with 100, producing a modified multi-entry 1.

Multi-Entry 1 = {Name [name = "quick", description = "yada1", language = "English"], Name [name = "schnell", description = "yahda1", language = "German"] , Printer [ppm = 10, dpi = 100, duplex = true, color = false]}

Thus, the search engine performs a type-safe attribute comparison by looking for all items in the database that have the requested type of attribute and modifying them in a type-safe manner. Note that this example is shown for illustrative purposes only. Many variations and modifications will become apparent to those skilled in the art once the above description is fully understood. And it is intended that each claim of the appended claims be construed as including all such modifications and alterations.

[Brief description of the drawings]

FIG. 1 is a block diagram of a distributed computer system using a database according to the present invention.

FIG. 2 is a block diagram illustrating an example of communication between a plurality of clients and a plurality of entry databases according to the present invention.

FIG. 3 is a block diagram illustrating several entries, each containing a particular type of field, and showing entries that are subtypes of other entries, in accordance with the present invention.

FIG. 4 illustrates various operations supported by the database system according to the present invention.

FIG. 5 is a diagram showing an example of a template entry according to the present invention.

FIG. 6 illustrates an implementation of a method for searching for an entry in a particular entry database in response to either a read request or a retrieval request in accordance with the present invention.

FIG. 7 is a functional block diagram illustrating an example of a database system according to the present invention.

FIG. 8 is a flow diagram illustrating the execution of a search method principle for processing a notification request according to the present invention.

FIG. 9A illustrates the execution of the principle of an index generation method according to the present invention.

FIG. 9B illustrates the execution of the principles of the index generation method according to the present invention.

FIG. 10 is a diagram illustrating multiple entries, where each multiple entry includes a field containing the entry.

FIG. 11 illustrates various multi-entry operations supported by the database system according to the present invention.

FIG. 12 shows an example of a multi-template according to the present invention.

FIG. 13 is a flowchart illustrating a database search method for multi-entry according to the present invention.

FIG. 14 is a correlation diagram showing an example of a database system related to a multi-entry search example according to the present invention.

FIG. 15 is a flow chart illustrating an implementation according to the invention of a search method principle for processing a notification request for a multi-entry.

FIG. 16 illustrates various operations for changing entries and multi-entries within a database according to the present invention.

FIG. 17 is a flowchart showing the steps of a single entry change operation according to the present invention.

FIG. 18 is a flowchart showing steps of a multi-entry adding operation according to the present invention.

FIG. 19 is a flowchart showing the steps of a multi-entry change / delete operation according to the present invention.

FIG. 20 is a flowchart showing steps of a notification operation used for an internal change operation according to the present invention.

[Explanation of symbols]

 100 Distributed System 310, 312, 314, 316 Object 704 Database Manager 706 Template 708 Search Manager 710 Entry Database 720 Index 1010, 1012, 1014, 1016 Entry 1200 Multi Template 1202 Template

──────────────────────────────────────────────────続 き Continuation of front page (81) Designated country EP (AT, BE, CH, CY, DE, DK, ES, FI, FR, GB, GR, IE, IT, LU, MC, NL, PT, SE ), OA (BF, BJ, CF, CG, CI, CM, GA, GN, GW, ML, MR, NE, SN, TD, TG), AP (GH, GM, KE, LS, MW, SD, SL, SZ, UG, ZW), EA (AM, AZ, BY, KG, KZ, MD, RU, TJ, TM), AL, AM, AT, AU, AZ, BA, BB, BG, BR, BY , CA, CH, CN, CU, CZ, DE, DK, EE, ES, FI, GB, GD, GE, GH, GM, HR, HU, ID, IL, IN, IS, JP , KE, KG, KP, KR, KZ, LC, LK, LR, LS, LT, LU, LV, MD, MG, MK, MN, MW, MX, NO, NZ, PL, PT, RO, RU, SD, SE, SG, SI, SK, SL, TJ, TM, TR, TT, UA, UG, UZ, VN, YU, ZW (71) Applicant 2550 Garcia Avenue, MS PAL1-521, Mountain View, California 94043-1100, United States of America (72) Inventor Arnold Kenneth C. Earl Sea United States, 02173 Massachusetts, Lexington, Moon Hill Road 7 (72) Inventor Wald James H. United States, 01826 Massachusetts, Dorcut , Ruby Road 155 F Term (Reference) 5B075 KK07 KK13 KK33 KK40 ND20 ND23 ND34 NK46 NR02 NR12 PP10 PP12 PP30 PQ05 PQ40 QP10 QS20 5B082 BA09 GA08 GA14

Claims (40)

[Claims] 1. A method for modifying entries in a database, the database storing a plurality of entries comprising a class type and including a plurality of typed fields, the method comprising the steps of: Providing a request that includes the template of the first template and a second template; searching for the location of an entry in the database that matches the first template; and within the database according to the fields of the second template. Changing the fields of the matching entry. 2. The method of claim 1, wherein the changing comprises replacing each field of a matching entry corresponding to a non-null field in the second template with a value of a non-null field in the second template. The method of claim 1, wherein: 3. The method according to claim 1, further comprising the step of repeating the position search step and the change step until all entries in the database conforming to the first template are changed. the method of. 4. The method of claim 3, further comprising returning a number representing a number of changed entries in the database. 5. A method of modifying an item in a database, the database storing a plurality of items, each item including a plurality of typed entries,
The method includes providing a request that includes a first multi-template and a second multi-template, wherein the first multi-template has a number of templates of the second multi-template. And the type, the method further comprises: retrieving a location of an item in a database that matches the first multi-template; and according to the template of the second multi-template received in the request.
Changing the entry of the matching item within the database. 6. The method according to claim 1, wherein the changing step includes: replacing each entry in the matching item corresponding to the non-null template in the second multi-template with the second item.
6. The method according to claim 5, comprising modifying according to a non-null template in the multi-templates of. 7. The method of claim 5, wherein the step of modifying includes removing each entry corresponding to a null template in the second multi-template from the matching item. . 8. The method according to claim 5, further comprising the step of repeating the position search step and the change step until all items in the database conforming to the first multi-template are changed. The method described in. 9. The method of claim 8, further comprising the step of returning a numerical value representing the number of changed items in the database. 10. A method of adding an entry to an item within a database, the database storing a plurality of items, each item including a plurality of typed entries, the method comprising: Providing a request that includes an item; retrieving the location of the item in the database that matches the multi-template; and adding an entry for the item received in the request to the matching item in the database. And is characterized by containing. 11. The method according to claim 10, further comprising the step of repeating the position searching step and the adding step until all items in the database conforming to the multi-template are changed. Method. 12. The method of claim 11, further comprising the step of returning a number representing the number of items to which entries in the database have been added. 13. A method for notifying a change in a match between an entry and a template when an entry in the database changes, the method comprising: monitoring the database for changes in the match. Receiving a request including a template specifying an entry to be monitored, and determining if the conformance of the entry has changed with respect to the template in the request if the entry has been modified. A determining step; and returning a notification of a change in the conforming state based on the determination. 14. The method of claim 13, wherein the determining step includes determining whether the entry has changed from a state that conforms to a template to a state that does not conform to a template. 15. The method of claim 14, wherein the determining step further comprises determining whether the entry has changed from a state that does not conform to the template to a state that conforms to the template. . 16. The method according to claim 13, wherein the entry is an item and the template is a multi-template. 17. The method of claim 13, wherein said receiving step includes receiving a request including a registration time indicating a length of time that said database is to be monitored. 18. A data processing apparatus comprising a database storing a plurality of entries, said apparatus configured to supply a request including a first template and a second template of the same type. A position search unit configured to search for a position of an entry in a database that matches the first template; and changing a field of the match entry within the database according to a field of the second template. And a modification unit configured to perform the following. 19. The change unit is configured to replace each field of a matching entry corresponding to a non-null field in the second template with a value of a non-null field in the second template. 19. The device of claim 18, including a replacement. 20. A data processing apparatus comprising a database for storing a plurality of items including a plurality of typed entries, wherein the apparatus comprises: a request processing apparatus comprising: a first multi-template; A supply unit configured to supply, wherein the template of the first multi-template is adapted to the number and type of templates of the second multi-template, the apparatus further comprising: A position locator configured to retrieve the position of an item in the database that matches the multi-template, and according to the second multi-template received in the request;
And a change unit configured to change the entry of the matching item in the database. 21. The changing unit changes each entry in the matching item corresponding to a non-null template in the second multi-template to a non-null template in the second multi-template. 21. The apparatus of claim 20, comprising a change configured as such. 22. The method according to claim 20, wherein the changing unit includes a deleting unit configured to delete each entry corresponding to a null template in the second template from the matching items. The described device. 23. A data processing device comprising a database storing a plurality of items including a plurality of typed entries, wherein the device is configured to supply a request including a multi-template and an item. A position searching unit configured to search for a position of an item in a database that matches the multi-template; and adding an entry of an item received in the request to the matching item in the database. It is characterized by containing the constituted additional part and. 24. A data processing device comprising a database storing a plurality of items including a plurality of typed entries, wherein the device monitors the database for changes in matching between entries and templates. A receiver configured to receive a request that includes a template specifying an entry to be monitored; and if the entry is changed, the conformance status of the entry changes with respect to the template associated with the request. And a response unit configured to return a notification of a change in the adaptation state based on the determination. 25. The determination unit according to claim 24, wherein the determination unit includes a determination unit configured to determine whether the entry has changed from a state conforming to the template to a state not conforming to the template. An apparatus according to claim 1. 26. The determination unit according to claim 24, wherein the determination unit includes a determination unit configured to determine whether the entry has changed from a state that does not conform to the template to a state that conforms to the template. An apparatus according to claim 1. 27. The apparatus according to claim 24, wherein the entry is an item, and the template is a multi-template. 28. The receiver of claim 24, wherein the receiver includes a receiver configured to receive a request including a registration time indicating a length of time that the database is to be monitored. apparatus. 29. A computer program product comprising a computer readable medium having computer readable code for processing data in a database embodied therein, said processing comprising: a first template and a second template of the same type. Providing a request that includes a template; searching for a location of an entry in a database that matches the first template; and setting a field of the matching entry within the database according to the field of the second template. And a step of changing. 30. The step of modifying includes replacing each field of a matching entry corresponding to a non-null field in the second template with a value of a non-null field in the second template. A product according to claim 29, characterized in that: 31. A computer program product comprising a computer readable medium having computer readable code for processing data in a database embodied therein, said processing comprising: a first multi template and a second multi template. Providing a request comprising: a template, wherein the template of the first multi-template is adapted to the number and type of templates of the second multi-template, the processing further comprising: Retrieving the position of the item in the database that matches the multi-template of
Changing the entry of the matching item within the database. 32. The method of claim 31, wherein each of the entries in the matching item corresponding to a non-null template in the second multi-template is performed according to a non-null template in the second multi-template. 32. The product of claim 31, including the step of altering. 33. The product of claim 31, wherein the step of modifying includes removing each entry corresponding to a null template in the second template from the matching items. 34. A computer program product comprising a computer readable medium having computer readable code for processing data in a database embodied therein, said processing providing a request comprising a multi-template and an item. Searching for the location of an item in the database that matches the multi-template, and adding an entry for the item received in the request to the matching item in the database. And 35. A computer program product comprising a computer readable medium having computer readable code for processing data in a database embodied therein, said processing comprising: changing a match between an entry and a template. Receiving a request to monitor the database with respect to the template, the template specifying the entry to be monitored; and if the entry has been modified, the conformance status of the entry with respect to the template in the request is changed. A step of determining whether or not the state has changed; and a step of returning a notification of a change in the adaptation state based on the determination. 36. The product of claim 35, wherein the determining step includes determining whether the entry has changed from a state that conforms to a template to a state that does not conform to a template. 37. The product of claim 35, wherein the determining step includes determining whether the entry has changed from a state that does not conform to a template to a state that conforms to a template. 38. The product of claim 35, wherein the entry is an item and the template is a multi-template. 39. The product of claim 35, wherein the receiving step comprises receiving a request including a registration time indicating a length of time that the database is to be monitored. 40. A computer program product comprising a computer readable medium having computer readable code for processing data in a database embodied therein, said computer readable medium comprising a first template and a second template of the same type. Means for providing a request comprising: a second template; means for retrieving a location of an entry in a database matching the first template; and within the database according to fields of the second template. Means for changing a field of the matching entry.