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: 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: A system and method for allocating join processing between and RDBMS and an assisting cluster. In one embodiment, the method estimates a cost of performing the join completely in the RDBMS and the cost of performing the join with the assistance of a cluster coupled to the RDBMS. The cost of performing the join with the assistance of the cluster includes estimating a cost of a broadcast join or a partition join depending on the sizes of the tables. Additional costs are incurred when there is a blocking operation, which prevents the cluster from being able to process portions of the join. The RDBMS also maintains transactional consistency when the cluster performs some or all of the join processing.

Abstract: A method for providing optimized data representation of relations for in-memory database query processing is disclosed. The method seeks to optimize the use of the available memory by encoding relations on which the in-memory database query processing is performed and by employing auxiliary structures to maintain performance. Relations are encoded based on data patterns in one or more attribute-columns of the relation and the encoding that is selected is suited to a particular type of data in the column. Members of a set of auxiliary structures are selected based on the benefit the structure can provide and the cost of the structure in terms of the amount of memory used. Encoding of the relations is performed in real-time while query processing occurs, using locks to eliminate conflicts between the query processing and encoding.

Abstract: A system and method for improving performance of join operations is disclosed. The method in one embodiment includes building a graph of vertices and edges, which represent the tables and join conditions for a particular database schema. The method then traverses the graph to find a set of candidate join operations. The method further includes selecting from the set of subset of join operations that makes the best use of a given amount of memory, which means finding a collection of denormalizations which when residing in memory provide the most benefit and the least cost for the given amount of memory. The method then deploys the denormalizations so that current queries in a query processing system can use them instead of actually performing the joins.

Abstract: One embodiment of the present invention provides a system that implements a security policy in a database. During operation, the system receives a request associated with a set of objects in the database. Next, the system obtains a set of access control lists (ACLs) associated with the database, wherein a respective ACL specifies one or more access privileges associated with a user or user group, and wherein a respective ACLs is not specific to a particular object in the database. The system then evaluates the ACLs to obtain a set of ACL results associated with the request and processes the request by applying the set of ACL results to the objects without evaluating the ACLs repeatedly for each of the objects.

Abstract: A method of operation of a navigation system includes: collecting a user's pattern; generating a filtered pattern by filtering the user's pattern with a current attribute; generating a mobile engagement score by calculating a weighted average from the filtered pattern and a user's current status; selecting a content based on the mobile engagement score for displaying on a device.

Abstract: A mechanism is provided for detecting and disregarding application specific nodes contained in shared XML documents. The techniques described involve determining one or more application specific nodes within XML documents and performing path expression evaluations of the XML documents as if the nodes are not present. In one embodiment, a mechanism is provided by which a user may specify the criterion that determine which subset of node in XML documents are to be ignored from path expression evaluations and evaluating a query that specifies a path operation based on a path and ignoring said identified nodes when evaluating said path operation.

Abstract: One embodiment of the present invention provides a system for efficiently evaluating a security policy. During operation, the system retrieves one or more roles associated with the user. Next, the system checks if a session-level cache exists for a set of Access Control Entries (ACEs) which is associated with the one or more roles. If this session-level cache exists, the system returns the set of ACEs from the session-level cache. Otherwise, the system generates the set of ACEs associated with the one or more roles from an Access Control List (ACL). During operation, the system can also update the one or more roles associated with the user and update the set of ACEs based on the updated one or more roles and the ACL. The system subsequently updates the session level cache with the updated set of ACEs and updated one or more roles.

Abstract: A method and apparatus for efficiently maintaining XML index structures in a database system is provided. Instead of immediately synchronizing the XML index structures for every change submitted to the database, the changes are stored in a PENDING table. The XML index structures are periodically synchronized, based on certain criteria or at a user's discretion. Between synchronizations, the XML index structures may be in stale mode or current mode. If in stale mode, a request to access indexed information will use the XML index structures to find the desired indexed information without checking the PENDING table. If in current mode, a request to access indexed information will search the XML index structures and also check the PENDING table to determine 1) whether the indexed information has been updated or deleted, and 2) whether information relevant to the request has been inserted or updated.

Abstract: A database system automatically detects a cyclic construct in a XML schema, determines a database representation for the cyclic construct, and maps the XML schema and elements involved in the cyclic construct to the database representation.

Abstract: One may increase the efficiency of an XML event-generating process by reducing the number of requests to allocate or deallocate system memory. Such reduction may occur as the result of pre-allocating a memory chunk of sufficient size to contain all of the memory buffers required by a particular event-generating process. Instead of allocating new memory chunks for new memory buffers, an application may store any required buffers within the pre-allocated memory chunk. A sufficient memory size may be estimated by performing the event-generating process on a training set of XML documents. Also, an application may re-use buffers during the process or between different iterations of the process, thus avoiding the need to deallocate and reallocate memory that is essentially being used for the same purpose.

Abstract: A mechanism is provided for detecting and disregarding application specific nodes contained in shared XML documents. The techniques described involve determining one or more application specific nodes within XML documents and performing path expression evaluations of the XML documents as if the nodes are not present. In one embodiment, a mechanism is provided by which a user may specify the criterion that determines which subset of nodes in XML documents are to be ignored from path expression evaluations. A query that specifies a path operation based on a path is evaluated ignoring said identified nodes when evaluating said path operation.

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: 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: Techniques are provided for efficiently extracting scalar values from binary-encoded XML data. Node information is stored in association with binary-encoded XML data to indicate whether one or more nodes of an XML document are simple or complex. A node is simple if the node has no child elements and no attributes. The node information of a particular node is used to determine whether a particular node, identified in a query, is simple or complex. If the particular node is simple, then the scalar value of the particular node is identified without performing any operations other than possibly converting the scalar value to a non-binary-encoded format or converting the scalar value to a value of a different data type.

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 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: In a database system, names and namespace of XML nodes are computed from path ids. The path ids are constructed from tokens, each of which represents a particular name or namespace-name pair.

Abstract: One embodiment of the present invention provides a system that facilitates performing a cost-based optimization of authorization checks in a database system. During operation, the system receives a query at the database system. Next, the system estimates a cost for executing the query, which involves estimating a cost for evaluating authorization checks, which involve functional evaluations of access rights for data accessed by the query. The system then rewrites the query to include evaluating authorization checks within the query. The system also estimates a cost for executing the rewritten query. Next, the system determines if executing the rewritten query has a lower cost than executing the query and performing the authorization checks. If so, the system executes the rewritten query. However, if not, the system executes the query.