Abstract: Business logic is integrated within a repository through the use of “resource configurations.” A resource configuration is a unit of business logic that is supplied by a user to the repository and associated with a particular directory and/or a resource. Each resource configuration contains one or more configuration items that each defines and/or expresses one or more business rules for managing a resource associated with the resource configuration.

Abstract: Techniques are provided for ensuring lexical fidelity when an XML document is stored in a binary format. Operations, on the XML data, that would cause the loss of lexical fidelity between the original XML document and the binary-encoded version of the XML document are not performed. Such operations include the removal of unnecessary whitespace characters, certain data type conversions, CRLF normalization, the “collapsing” of two-tag empty elements into a single tag empty element, and the replacing of entity references or numeric character references with another value. An XML schema, to which the XML document conforms, may indicate that the XML document is to be stored in a lexical fidelity mode. Additionally, or alternatively, the database statement that (when executed) causes the XML document to be stored in a binary format may so indicate.

Abstract: A technique for differencing XML documents is provided. An edit graph is generated for computing the cost of possible edits that may be applied to a first XML document in order to generate a second XML document. A hash value is assigned to nodes included in the axes of the edit graph, where one axis includes nodes in the first XML document and the other axis includes nodes in the second XML document. The hash value may be generated based on a particular node's name and attributes, and the hash value of the name and attributes of each child node of the particular node. A technique for patching an XML document is also provided. Events are generated for each node in the input document and for at least one operation specified in the edit script. The edit script is applied to the input document by performing one or more operations specified in the operation events on one or more node events.

Abstract: Systems, methods, and other embodiments associated with providing query modes for translation-enabled XML documents are described. One method embodiment includes receiving an XPath query to an XML document that may store a translation for a data element. The method embodiment may also include automatically selecting a query mode for the XPath query. The method embodiment may also include querying the XML document using the XPath query and the selected query mode. The query mode may control, at least in part, the operation of an XML database logic.

Abstract: A mechanism is provided for improving the performance of particular database queries operating on a view comprising binary-encoded XML. A determination is made about whether a XML index is available to improve the computation of XPath data before deriving an optimized execution plan for a particular query. When a XML index is not available to help expedite the computation of binary-encoded XML, then deferring the computation of the XPath data until after the view merge stage avoids unnecessary computation of XPaths that are part of the view but not needed for the particular query.

Abstract: Queries that request fields that are contained in the same XML fragments are written to execute them more efficiently.

Abstract: A method and apparatus for XXX is provided.

Abstract: Techniques for estimating the cost of processing a database statement that includes one or more path expressions are provided. One aspect of cost is I/O cost, or the cost of reading data from persistent storage into memory according to a particular streaming operator. Binary-encoded XML data is stored in association with a synopsis that summarizes the binary-encoded XML data. The synopsis includes skip length information for one or more elements and indicates, for each such element, how large (e.g., in bytes) the element is in storage. The skip length information of a particular element thus indicates how much data may be skipped during I/O if the particular element does not match the path expression that is input to the streaming operator. The skip length information of one or more elements is used to estimate the cost of processing the database statement.

Abstract: A technique and mechanism for efficiently searching across multiple versions of a resource is provided. New operators are provided that take into account the versions of a particular resource. The query engine evaluates the new operators using either an index-based approach or a functional approach. Under an index-based implementation, a hierarchical index is traversed to find a particular resource (or resources) associated with a specified path and the version history identifier associated with the particular resource(s). A version history table containing references to all versions of the particular resource(s) are then obtained. Under the functional implementation, a link table, which contains all paths in a user's workspace, is examined to determine whether the version history identifier of a particular resource matches a version history identifier of a resource specified in the link table and whether the path to the resource in the link table is related to the path specified.

Abstract: Various techniques are described hereafter for improving the efficiency of binary XML encoding and loading operations. In particular, techniques are described for incrementally encoding XML in response to amount-based requests. After encoding enough binary XML to satisfy an amount-based request, the encoder stops encoding the XML until a subsequent request is received. The incremental encoding may take place on the client-side or the server-side. Techniques are also described for reducing the character set conversion operations by having a parser convert tokens in text XML into one character set while converting non-token text in the text XML into another character set. Techniques are also described for generating self-contained binary XML documents, and for improving remap operations by providing a binary XML document on a chunk-by-chunk basis.

Abstract: A method and system are provided for extracting a valid, self-contained fragment for a node in a XML document stored in a database management system. An XML index is used to identify a location in which XML fragment data corresponding to the node is located. Ancestors of the node are identified and examined for any information needed for the proper interpretation of the fragment. If an ancestor node contains such needed information, this information is patched into the XML fragment to ensure that the fragment is a valid, self-contained XML fragment.

Abstract: A method and apparatus for streaming validation of XML documents is provided. A particular event of a series of events is received. The series of events is generated as an XML document is parsed by a parser, and the received particular event indicates that the parser has encountered a particular part of the XML document. The particular part of the XML document indicated by the particular event is then received. A current validation state for the XML document is determined. The current validation state, which is one of a plurality of validation states for the XML document, indicates a validation type associated with the particular part of the XML document. Based on at least the current validation state, the particular part of the XML document is validated against an XML schema that defines the structure of the XML document.

Abstract: Techniques for processing a query that includes a path expression are provided. A query processor determines whether an XML index may be used to execute the query instead of having to scan multiple XML documents. The query is parsed and normalized, which results in multiple normalized path expressions that are based on the original path expression. If the XML index is a path-subsetted index, then the query processor generates annotated path expressions based on the normalized path expressions. The query processor determines whether each of the annotated path expressions is satisfiable by the path-subsetted XML index. If so, then the XML index is used to process the query.

Abstract: Techniques for fast and scalable generation and aggregation of XML data are described. In an example embodiment, an XML query that requests data from XML documents is received. The XML query is evaluated to determine one or more XML results. For each particular XML result, evaluating the XML query comprises: instantiating a particular data structure that represents the particular XML result, where the particular data structure is encoded in accordance with tags specified in the XML query but does not store the tags; and storing, in the particular data structure, one or more locators that respectively point to one or more fragments in the XML documents, where the particular data structure stores the one or more locators but does not store the one or more fragments. On demand, in response to a request indicating the particular XML result, a serialized representation of the particular XML result is generated based at least on the particular data structure.

Abstract: Data used and generated by the process of validating XML documents is divided into two categories: compile-time static data and runtime data. Runtime data may be specific to a particular XML document and changes when validating the XML document, while compile-time data does not change in this way. For example, compile-time data may be data that defines, according to a schema, the descendant elements and ordering between them. Runtime data is information generated to track which descendants occurred in a particular XML document being validated. Compile-time static data, once generated to validate a particular XML document, is cached within a shared volatile memory. Once the compile-time data is cached, the compile-time static data may be used to validate other XML documents without the need to regenerate the compile-time static data.

Abstract: Techniques are described herein for efficient and scalable processing of complex sets of XML schemas. The techniques described herein provide for reducing duplication of schema elements in volatile memory by building an XML schema in-memory model that stores repeating schema elements in in-memory data structures that are separate from in-memory data structures that store the parent schema elements which logically include or otherwise refer to the repeating schema elements. The techniques described herein also provide for faster generation of an in-memory model of an XML schema by pre-loading, in data structures on persistent storage, of schema elements from dependent XML schemas that are referenced and/or incorporated by the XML schema.

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: During query optimization, XML index and view merge transformations may be interleaved.

Abstract: Techniques are provided to achieve performance improvements for path-based access to hierarchical data and for utilizing an extensible indexing framework. Extensible operators may be optimized by evaluating the operators using functions native to the database system instead of using functions defined through an extensible indexing mechanism. Furthermore, the database system may resolve a resource path of a query when the query is compiled, and may store the mapping of the resource path to one or more resources in a cursor for the query execution plan to avoid resolving the resource path each time the cursor is used to run the query. The cursor may be made dependent on the one or more resources to which the resource path refers at compile time. This takes advantage of the observation that the mapping of the resource path to particular resources rarely changes between evaluations of a particular query.

Abstract: A two-level cache to facilitate resolving resource path expressions for a hierarchy of resources is described, which includes a system-wide shared cache and a session-level cache. The shared cache is organized as a hierarchy of hash tables that mirrors the structure of a repository hierarchy. A particular hash table in a shared cache includes information for the child resources of a particular resource. A database management system that manages a shared cache may control the amount of memory used by the cache by implementing a replacement policy for the cache based on one or more characteristics of the resources in the repository. The session-level cache is a single level cache in which information for target resources of resolved path expressions may be tracked. In the session-level cache, the resource information is associated with the entire path expression of the associated resource.