Abstract: Techniques for implementing fast loading of binary XML into a binary XML database repository are provided. A client application reduces the processing burden on the repository by doing pre-processing of the binary XML data prior to loading.

Abstract: A method and apparatus for loading an XML document into memory is provided. A client loads one or more array elements into a first partition of an array that is maintained in memory. Each array element represents an XML element of an XML document. Upon determining that an amount of data maintained in the first partition exceeds a first threshold, the client subsequently loads array elements into a new partition of the array. Upon determining that an amount of data maintained in the memory of the client exceeds a second threshold, the array elements of the least recently used partition are persistently stored in a database without persistently storing the entire XML document. When the last XML element of the XML document is loaded into a partition of the array, that partition is persistently stored in the database, thereby causing the entire XML document to be stored in the database.

Abstract: A method is provided to efficiently evaluate an expression to determine the partition key for an XML document stored in a database without the entire XML document first being stored in temporary memory storage. The partition key is determined using streaming evaluation or incrementally using a DOM node tree as a portion of the document is read and stored in the buffer. The XML document is stored in the partition using the read portion of the document stored in the buffer and the remaining portion from the original source.

Abstract: Cost-based optimizer functionality for an XML database repository provides means for optimizing the execution of database queries that access XML resources in the database repository. Statistics about XML resources that are stored in the database repository are gathered, stored and utilized by a query optimizer to compute computational costs associated with each of multiple methods of accessing particular XML resources requested in a database query. Hence, the optimizer is able to select the most efficient query execution plan based on the costs of possible access paths. In one embodiment, specific statistics about the hierarchical structure of XML resources stored in the XML database repository are gathered, stored in a relational table in the database management system, and used to compute the selectivity of query predicates and the index cost associated with traversing one or more indexes to access requested XML resources.

Abstract: A method and system are provided for maintaining an XML index in response to piece-wise modifications on indexed XML documents. The database server that manages the XML index determines which nodes are involved in the piece-wise modifications, and updates the XML index based on only those nodes. Index entries for nodes not involved in the piece-wise modifications remain unchanged.

Abstract: A method and apparatus for performing an action in response to a file system event is provided. According to one aspect, sets of “event listeners” are associated with a file hierarchy and/or the nodes thereof. Each event listener contains a set of “event handlers.” Each event handler corresponds to a separate type of event that may occur relative to the file hierarchy's nodes. When an event is going to occur relative to the hierarchy or a node thereof, all event listeners that are associated with that hierarchy/node are inspected to determine whether those event listeners contain any event handlers that correspond to the event's type. Those event handlers that correspond to the event's type are placed in an ordered list of event handlers to be invoked. As the event handlers in the list are invoked, programmatic mechanisms that correspond to those event handlers are executed to perform customized user-specified actions.

Abstract: A modular repository is described, where operational features may be implemented without the need to scan every resource included in the modular repository. A modular repository includes a dedicated set of database objects containing all information needed to access the resources in the repository. For example, the database objects of a modular repository may include those user identifier mappings and ACL mappings, etc., to which metadata in the modular repository refers. A database system may also include a mechanism through which a modular repository may be mounted under a subdirectory of a common directory in the database system. The resources of a modular repository that are mounted under the common directory may be accessed through the common directory. Further, a client may query the resources of any modular repository mounted under the common directory by making the federated repository, represented by the common directory, the context of the query.

Abstract: When an XML-annotated document is saved, a process automatically stores the document's data in the tables of a database. The database server validates the document's data against a user-specified XML schema. Queries can be executed against a set of documents in order to find documents in which a specified XML element contains specified content. Query results can be customized to return only the contents of specified XML elements. The document data can be linked with other data in the database such that the document data is updated based on the other data every time that the document is opened, thereby producing a “live” and dynamic document. Different file formats can be generated based on the document data, thus separating the presentation of the document data from the data itself. Contents of different elements may be obscured based on users' privileges, thereby maintaining the privacy of the document's information.

Abstract: Techniques are provided for indexing XML documents using path subsetting. According to one embodiment, a PATH table created for storing one row for each indexed node of the XML documents using user-defined criteria. The user-defined criteria are used to determine which nodes of XML documents to included in The PATH TABLE. The PATH table row for a node includes (1) information for locating the XML document that contains the node, (2) information that identifies the path of the node, and (3) information that identifies the position of the node within the hierarchical structure of the XML document that contains the node. Use of the user defined criteria is transparent to any query improves DML indexes overhead costs.

Abstract: In-place XML schema evolution occurs by evaluating an existing XML schema in a database system to see if it is compatible with a new XML schema. To determine if the old schema is compatible with the new schema, a lock-step traversal is performed on the two schemas. Each instruction in the old schema is compared to instructions in the new schema. Detected differences between the two schemas are evaluated to determine if existing XML documents are still compatible with the new schema. If they are, then an in-place schema evolution operation can take place. The in-place schema operation basically, involves appending the updated object information to the underlying object type and preserving the order of elements in a document by storing element mapping information on disk.

Abstract: A method and apparatus are described for summarizing a document. For each node in the document that satisfies a marking criteria, a start and end mark pair is stored in a summary in document order. The start mark specifies a location in the document where the node starts, and the end mark specifies a location in the document where the node ends. When evaluating a query for a hierarchical path, the document is streamed into memory until the mark of a tag matches a start mark in the summary. If that tag does not fit within the path, then streaming of the document may resume at the end mark, thereby skipping the node during streaming evaluation. Translation information may be used to indicate a logical position relative to the marks in the summary when the document is modified.

Abstract: The approaches described herein provide an efficient way for a database server to process certain kinds of queries over XML data stored in an object-relational database that require the evaluation of a predicate expression with one or more path-based operands. A predicate expression part of a XQuery or SQL WHERE clause that returns a boolean value. A database server first determines whether the query qualifies for this particular kind of optimization, then rewrites the query using an enhanced query operator syntax for specifying the predicate expression to be evaluated. The enhanced query operator subsumes the work of a second path-based query operator, resulting in the suppression of the WHERE EXISTS subquery. The rewritten query operator is used to generate a query execution plan that provides for several query execution optimizations.

Abstract: A method and apparatus for facilitating the management of metadata is disclosed, specifically by associating metadata with an XML schema. The database system provides a method that allows end users to maintain additional information describing resources. User-defined metadata attributes are associated as an XML schema which in turn is mapped to a table, referred to as the user metadata table. The XML schema contains user-defined information specifying the metadata that the end-user wants the system to store and maintain. Additionally, a reference is created between an entry in the user metadata table and its corresponding resource entry in the resource table. The resources are accessed directly or by issuing queries against the user metadata table. The querying of the user metadata table gains the benefit of fast and efficient query results and access time.

Abstract: The approaches described herein provide an efficient way for a database server to process certain kinds of queries that require the evaluation of an aggregation function over XML data stored in an object-relational database. An aggregation function takes multiple inputs and generates a single output. A database server first determines whether the query qualifies for this particular kind of optimization, then creates a query execution plan that specifies the use of an enhanced path-based row source, eliminating the need for a second path-based row source for computing the aggregation function. The enhanced path-based row source specified in the query execution plan computes an aggregation function and stores the result of that function computation in a column of each row. The XPath evaluation results that are the individual inputs to the aggregation function are only stored temporarily until they are used to compute the aggregation function.

Abstract: The approaches described herein provide an efficient way to process certain kinds of queries that retrieve XML data stored in an object-relational database. An XML query may include a predicate condition that joins two row sources. One or both of the row sources required for predicate evaluation may be path-based; that is, consume and produce rows of XMLType data. Such a path-based row source may be modified to use the predicate condition to filter the rows it generates so that only rows satisfying the predicate condition need to be further processed. A small cache structure introduced into the path-based row source may be used to optimize the evaluation of the predicate row. Once populated with row data, the cache structure may be reorganized to optimize the performance of predicate evaluation.

Abstract: Techniques for efficiently processing a query are provided. A query may specify a location path and a content path. The location path identifies the hierarchical location of a set of documents within a resource repository. The content path identifies hierarchical location of one or more nodes within the content of the set of documents. Computing the query includes using a repository index, based on the location path and the content path, to generate first results corresponding to the set of documents and second results corresponding to the one or more nodes. Final results of the query are based on the first results and second results. Another technique is provided for formatting a locator value in the repository index to support data that is stored object-relationally. Another technique is provided for storing index information about virtual content.

Abstract: A method and apparatus are provided for using sibling-counts in XML indices to optimize single-path queries. Using a b-tree XML index with a SQL query logarithmically reduces the number of disk accesses by passing over index entries where it is determined that a match will not be found. However, because certain index entries are passed over, it is impossible to ascertain if a path expression occurs more than once in the XML index, as certain queries sometimes require. This hurdle can be overcome by maintaining a sibling count with each node entry in the XML index. Because the sibling count is stored with the index entry, the index will reveal whether the matching node is single or has other siblings. In additional to re-writing the original query for optimization by use of an XML index, it will be re-written to check for a single-path condition in the index.

Abstract: The approaches described herein provide an efficient way to process certain kinds of queries that retrieve XML data stored in an object-relational database. A technique determines whether a query comprises a plurality of iteration expressions that exhibit a particular relationship to one another, and if so, re-writes the query and produces an optimized query execution plan. The query execution plan specifies an XPath-based row source with caching enabled. A very small cache structure is used, and reference locators are stored in the cache that point into binary-encoded data rather than copying XMLType data into the cache. Row data may be cached on the first use of the path-based row source and re-used in subsequent requests for rows. Once there is a subsequent request for rows from the optimized path-based row source, the cache may be reorganized to efficiently produce the rows of the row source.

Abstract: A method and apparatus for accelerating value-based lookups of XML documents in XQuery is provided. XML indices can help to optimize SQL queries of XML documents stored in object-relational databases. Certain SQL/XML functions such as XMLTABLE( ) use XQuery expressions to query XML documents. Previously, such queries could not use the XML index because the PATH table of the XML index was not defined for XQuery semantics. Techniques described herein extend the XML index for use with queries that require evaluation of XQuery expressions. Consequently, techniques described herein accelerate value-based lookups of XML documents in XQuery by introducing the possibility of an index-assisted evaluation of XQuery expressions.

Abstract: Various techniques are described hereafter for improving the efficiency of updating XML documents in a content repository, such as a database system. Specifically, techniques are described for updating an XML document by dynamically merging a stream of XML data from the document with update information. Techniques are also described for efficient validation of XML documents. Because of the manner of the updates, specifically because the XML data being updated is in the form of a stream, the database system validates only those portions of the stream of XML data that have been updated. In the alternative, the database system validates that portion of the XML data that is associated with the parent node of the portion of XML data that has been updated.