Abstract: A method and apparatus are provided for converting a non-versioned schema to a version-enabled schema. The method includes reading a first set of table definitions that belong to the non-versioned schema. A second set of table definitions is generated for the version-enabled schema such that each table definition in the second set of table definitions corresponds to a table definition in the first set of table. Each table definition in the second set of table definitions includes columns that correspond to the columns of the corresponding table definition in the first set of table definitions and one or more additional columns for storing version information. Multiple versions of a particular object are stored within the table. In response to a request from a user to retrieve the particular object, a version of the particular object to present to the user is determined based on a workspace associated with the user.

Abstract: One embodiment of the present invention provides a resource scheduler for allocating a computer system resource, such as execution time within a processor, to database management system (DBMS) processes. The resource scheduler operates according to scheduling plans and policies. One or more plans may be configured and loaded with the DBMS. Each plan allocates the resource according to an associated policy but only one plan is active at a time. During operation of the DBMS, either or both of the active plan and policy may be exchanged for an alternate plan or policy without halting operation of the DBMS or the computer system.

Abstract: A method and apparatus for transforming queries is described. According to an aspect of the present invention, a select-project-join query Q that specifies at least one semijoin is rewritten into another query that references the materialized view M. A common section shared by the select-project-join query and the materialized view includes the tables being semijoined.

Abstract: A method and apparatus for transforming queries is provided. A select-project-join query Q that specifies an antijoin is rewritten into another query that references the materialized view M. The common section includes the tables being antijoined, and may be one-to-many lossless with respect to the join with the materialized view delta.

Abstract: A method and apparatus for transforming queries is provided. A select-project-join query Q is rewritten into another query that joins a materialized view M and a subset of the tables from Q not in the common section portion of Q. The common section may be one-to-many lossless with respect to the join with the materialized view delta. As compared to one-to-one rewrites, the one-to-many rewrites described herein provide a more general class of rewrites.

Abstract: A highly scalable, flexible, and extensible mechanism is provided for authenticating a request from a client. In a preferred embodiment, the invention comprises an authentication engine, an authentication host, a plurality of providers coupled to the host which implement selected authentication schemes, and a machine independent communication mechanism which enables the various components to communicate with each other irregardless of the machine each component resides on. The communication mechanism enables the invention to be distributed, which in turn, makes the invention highly scalable. In operation, the authentication engine receives a request having associated therewith a protect string. The protect string specifies the authentication scheme or schemes that need to be implemented for that request. The authentication engine parses the protect string into one or more provider requests, and sends the requests to the authentication host.

Abstract: A computerized query optimizer for use with a database system having an ordered set of records. The optimizer employs a scanner and an evaluator. A query is composed as ranges of record values related by logical operators. The query is converted to a Boolean tree in canonical form. The tree is optimized to express the ranges as a set of disjoint semi-open ranges. The scanner reads a next record from the database. The evaluator, using the query, delivers a logical true or false condition for the record. In addition, the evaluator also delivers an interval of values having the same logical condition as the logical condition of the record. If this logical condition is false, the scanner skips over records having values of the interval, otherwise, if the logical condition is true, records having values of the interval are selected.

Abstract: A method, system and product for coordinating a parallel update for a global index of an indexed table involves a coordinator process and slave processes. The coordinator process receives index maintenance records from data manipulation slaves for an indexed table. Each index maintenance record includes a value for an index key of a global index of the table. The coordinator process computes index key value ranges and sends each range to an index update slave. Each slave updates the global index using just the index maintenance records with key values in its respective range, thus avoiding contention among the slaves and increasing clustering so that scaleable parallelism may be more closely attained. Techniques are also described for deferring the maintenance of global indexes relative to the time when the table on which they are built is changed.

Abstract: A dynamic tree control system includes a scripted program sent from a server, to be interpreted by a client browser. The program uses dynamic HTML and includes program code for displaying, under the control of the browser, a tree structure having one or more tree nodes in which at least a portion of data retrieved from the server is represented. The program also includes program code for dynamically altering, in response to some event, the tree structure without further accessing the server. The program also includes an event manager that registers with the browser to be notified upon the occurrence one or more events. The event manager receives notification of the event from the browser, and notifies the layer in which the event originated or took place. A notified layer response to the event, for example, by dynamically altering the tree structure.

Abstract: Techniques are provided for executing distinct aggregation operations in a manner that is more scalable and efficient than prior techniques. A three-stage technique is provided to parallelize aggregation operations that involve both grouping and multiple distinct-key columns. Such queries are handled by splitting rows into as many pieces as there are distinct aggregates in the query, and processing the row pieces. During the first-stage, a set of slave processes scans the rows of the base tables and performs partial duplicate elimination. During the second-stage, a set of slave processes completes the duplicate elimination and performs partial set function aggregation. During the third-stage, a third set of slave processes completes the set aggregation to produce the results of the distinct aggregation operation.

Abstract: A method and mechanism are provided for creating, maintaining, and using a hierarchical index to efficiently access information in a relational system based on a pathnames, thus emulating a hierarchically organized system. Each item that has any children in the emulated hierarchical system has an index entry in the index. The index entries in the index are linked together in a way that reflects the hierarchical relationship between the items associated with the index entries. Pathname resolution is performed by following direct links between the index entries associated with the items in a pathname, according to the sequence of the filenames within the pathname. By using an index whose index entries are linked in this manner, the process of accessing the items based on their pathnames is significantly accelerated, and the number of disk accesses performed during that process is significantly reduced.

Abstract: Techniques are provided for managing caches in a system with multiple caches that may contain different copies of the same data item. Specifically, techniques are provided for coordinating the write-to-disk operations performed on such data items to ensure that older versions of the data item are not written over newer versions, and to reduce the amount of processing required to recover after a failure. Various approaches are provided in which a master is used to coordinate with the multiple caches to cause a data item to be written to persistent storage. Techniques are also provided for managing checkpoints associated with the caches, where the checkpoints are used to determine the position at which to begin processing recovery logs in the event of a failure.

Abstract: Editing query conditions, calculations, formulas and equations, or any other parts of a form includes providing a hyperlink for an element in the form to indicate to a user that a control is available for the element. Upon a selection of the hyperlink by the user, the control is presented for user interaction. Upon completion of user interaction with the control, the element is replaced with a new element responsive to user action. The control can be a list of choices, such as a pull-down menu, a dialog box, or a text entry field. The hyperlink can be color coded and underlined.

Abstract: A method and apparatus are provided for retrieving data from a table in a database. According to the method one or more indexes arc generated for use in processing a query by selecting values as unique key values from one or more columns in a table in a relational database system. Each unique key corresponds to a row in the table. The condition of whether a row in a table satisfies a search criterion, is represented by a bit in a bitstring or, in cases where the bitstring is segmented, in a segment of bitstring. The unique keys and corresponding segment of bitstring are then stored in an index.

Abstract: A method and apparatus allows a client or other device separate from a server to retrieve from the server more data than is requested by an application program on the client. The additional data is maintained by the client or other device and provided to the application program in response to a subsequent request, reducing the number of times data is requested from the server, and also the processing and overhead required by the server to supply the data. If the server releases memory pointing to the data on the server at the time or after all data specified by the application program has been retrieved, because the data is potentially retrieved from the server in amounts larger than requested by the application program, the server may release memory pointing to the data on the server sooner than it would by processing requests for the data from the application program alone.

Abstract: A method and apparatus for copying garbage collection is described. A set of ambiguously referenced objects is identified in a from-space. Live objects in the from-space which are not ambiguously referenced are moved to the to-space, and the ambiguously referenced are transfixed (i.e. left behind to reside in the from-space). The boundaries of the ambiguously referenced are determined. When moving objects to the to-space, the objects are moved into regions between boundaries of objects transfixed in the to-space.

Abstract: A method and apparatus are provided for accessing ancillary data, and for generating and accessing ancillary data more efficiently. Ancillary data is generated during execution of the operator routine of a primary operator. The ancillary data is stored in a shared content and may be accessed through ancillary operators associated with the primary operator. Metadata is used to define a primary operator and ancillary operators associated with the primary operator. A DBMS, for example, receives a statement that includes a primary and at least one of its ancillary operators, and executes routines that implement the primary operator and the ancillary operator. During execution of the routine the implements the primary operator, ancillary data is generated and stored in shared content. During the execution of the routine that implements the ancillary operator, the ancillary data is retrieved from the shared content and is used.

Abstract: Disclosed is a method and mechanism for duration-based management of temporary large objects (“LOBs”) in a database system. According to one aspect, temporary LOBs are associated with a duration having a lifespan that corresponds to the lifespan of the temporary LOBs. When the duration ends, the associated temporary LOBs, and any resources allocated to the temporary LOBs, are automatically released. According to another aspect multiple durations of varying, and possibly overlapping lifespans, can exist in the database system. According to yet another aspect, a tree of durations can be created having multiple ancestor and descendant durations.

Abstract: According to a transaction-based locking approach, a request for a first lock on a particular resource is received from a first process, wherein the first process is associated with a first transaction. A first lock on the particular resource is granted to the first process. A request for a second lock on the particular resource is received from a second process. A determination is made whether the second process is associated with the first transaction. If the second process is associated with the first transaction, then a second lock on the particular resource is granted to the second process prior to the first lock being released.

Abstract: A method and apparatus are provided for transferring a resource from the cache of one database server to the cache of another database server without first writing the resource to disk. When a database server (Requestor) desires to modify a resource, the Requestor asks for the current version of the resource. The database server that has the current version (Holder) directly ships the current version to the Requestor. Upon shipping the version, the Holder loses permission to modify the resource, but continues to retain the resource in memory. When the retained version of the resource, or a later version thereof, is written to disk, the Holder can discard the retained version of the resource. Otherwise, the Holder does not discard the retained version. Using this technique, single-server failures are recovered without having to merge the recovery logs of the various database servers that had access to the resource.