Oracle International Corporation

Oracle International Coporation

Eric Sedlar

Nipun Agarwal

Ravi Murthy

Sivasankaran Chandrasekar

Sam Idicula

Namit Jain

Ashish Thusoo

Hassan Chafi

Asha Tarachandani

Syam Sundar Pannala

Vikram Kapoor

Thomas Baby

Sreedhar Mukkamalla

Abhyudaya Agrawal

Bhushan Khaladkar

Vikram Reddy Pesati

Fei Ge

Anh-Tuan Tran

Neema Jalali

Sungpack Hong

Muralidhar Krishnaprasad

Thomas F Keefe

Thuvan Hoang

Min-Hank Ho

Aman Naimat

Janaki Narasinghanallur

Mason Chang

James W Warner

Chon Hei Lei

Sabina Petride

Anand Manikutty

Visar Nimani

Michael Roberts

Alexander Ulrich

Man-Hay Tam

Sivasankaran Chandrasekaran

Subramanian Muralidhar

Nitin Kumar Gupta

Laurent Daynes

Benjamin Schlegel

Pit Fender

Matthias Brantner

Viswanathan Krishnamurthy

Tanvir Ahmed

Harshad Kasture

Olga Peschansky

Anantha Kiran Kandukuri

K Karun

Vijay Medi

Chi Ching Chui

Kevin Moore

Brian Gold

Bastian Hossbach

Dmitry Lenkov

Kwok Lun Alex Yiu

Sanket Malde

Altin Alickaj

Reema Koo

Sivansankaran Chandrasekar

Anjana Manian

Nicolas Montoya

Juergen Christ

Lucas Braun

Doug McMahon

Doug Mc Mahon

Michael J Roberts

Thomas Keefee

Arkady Rabinov

Syam Pannala

Nitin Gupta

Herein, a guest language is a programing language that is not the native data access language (e.g. structured query language, SQL) of a database server. When instantiated in the database server, a guest language runtime environment provides any mechanisms needed to execute the guest language. In an embodiment contained entirely within the database server, multiple guest language runtime environments for same or different guest languages use respective database sessions to share a key-value store in RAM that stores rows from a persistent relational table. Consumption of computer resources such as time and memory space is decreased because the persistent relational table's operation by the key-value store does not generate a database statement, does not parse a database statement, does not query plan, and does not execute a database statement.

Shared cross-session dictionary using direct data access in a DBMS

Herein are computerized techniques for deploying JavaScript and TypeScript stored procedures and user-defined functions into a database management system (DBMS). In an embodiment, a computer generates a SQL call specification for each subroutine of one or more subroutines encoded in a scripting language. The generating is based on a signature declaration of the subroutine. Each subroutine comprises a definition of a stored procedure or a user-defined function. The computer packages the definition and the SQL call specification of each subroutine into a single bundle file. The definition and the SQL call specification of each subroutine are deployed into a DBMS from the single bundle file. Eventually, the SQL call specification of at least one subroutine is invoked to execute the definition of the subroutine in the DBMS.

Deployment of javascript and typescript stored procedures and user-defined functions into database management systems

Techniques are provided for performing a flush operation in a non-coherent cache. In response to determining to perform a flush operation, a cache unit flushes certain data items. The flush operation may be performed in response to a lapse of a particular amount of time, such as a number of cycles, or an explicit flush instruction that does not indicate any cache entry or data item. The cache unit may store change data that indicates which entry stores a data item that has been modified but not yet been flushed. The change data may be used to identify the entries that need to be flushed. In one technique, a dirty cache entry that is associated with one or more relatively recent changes is not flushed during a flush operation.

Flushing entries in a cache by first checking an overflow indicator to determine whether to check a dirty bit of each cache entry

Flushing by copying entries in a non-coherent cache to main memory

A method and apparatus for processing path-based database operations is provided. According to one aspect, a path cache is maintained. For each hierarchical node that is traversed during a path-determining operation, it is determined whether a cache entry corresponding to that node is already contained in the path cache. If such a cache entry is already contained in the path cache, then the path indicated in that cache entry is used to complete the pathname for the node for which the operation is being performed. As a result, hierarchically higher nodes do not need to be traversed to complete the operation. Alternatively, if such a cache entry is not already contained in the path cache, then a cache entry for the node currently being traversed is generated and inserted into the path cache for use in subsequent path-determining operations.

Path-caching mechanism to improve performance of path-related operations in a repository

An application platform examines, at runtime, various specified aspects of an application environment in which an application interacts with a user. Such examinations are made to determine a state for each of the various specified aspects. Further, the platform automatically activates particular application environment roles for the user depending on the result of the examinations. For example, an application environment role may be activated representing a particular detected mode of communication (e.g., encrypted network communications) or a particular detected manner of authentication (e.g., password authentication). Such activations are based on the detected states and specified states for the various specified aspects of the application environment. Such activations may occur in the context of an application attempting to perform an operation on an access controlled object on behalf of a user. Further, such activations may occur in the context of establishing or maintaining a user session for a user of an application.

Techniques for enforcing application environment based security policies using role based access control

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.

Optimal data representation and auxiliary structures for in-memory database query processing

A database management server manages a distributed data set at least partially stored in volatile memory of a plurality of nodes. The database management server stores transaction logs in persistent storage corresponding to one or more database transactions performed on the distributed data set. In response to a query, a join operation is performed with assistance from the cluster. A snapshot identifier identifies a particular database state that is transactionally consistent. Based on the transactional logs, updated data blocks updated after the snapshot identifier of the query are identified. The cluster is instructed to perform one or more distributed join operations on the distributed data set without processing data in the updated data blocks. The database management server performs a partial join evaluation on the updated data blocks.

Efficient pushdown of joins in a heterogeneous database system involving a large-scale low-power cluster

Techniques are provided for performing OID-to-VMA translations during runtime. Vector registers are used to implement a 'software TLB' to perform OID-to-VMA translations. Runtime dereferencing is performed using one or more vector registers to compare each OID that needs to be dereferenced against a set of cached OIDs. When a cached OID matches the OID being dereferenced, the VMA of the cached OID is retrieved from cache. Buffer cache items may be pinned during the period in which the software TLB stores entries for the items. The cache of OID translation information may be single or multi-leveled, and may be partially or completely stored in registers within a processor. When stored in registers, the translation information may be spilled out of the register, and reloaded into the register, as the register is needed for other purposes.

Software translation lookaside buffer for persistent pointer management

A method and apparatus are described for sharing a session to access a database. A database server receives, in a session, a session context identifier and a command. The session context identifier identifies a session context to use for the session. The session context is a set of information or commands that plug into a session state and specify how commands in the session are to be performed for a particular user or privilege level. In response to receiving the identifier, the database server associates the session context with the database session for the connection. The database server uses the session context to process the command. The session context may then be detached from the session, allowing another user to attach to the session via another session context.

Pluggable session context

An XML document can be represented in a compact binary form that maintains all of the features of XML data in a useable form. In response to a request for a modification (e.g., insert, delete or update a node) to an XML document that is stored in the compact binary form, a certain representation of the requested modification is computed for application directly to the binary form of the document. Thus, the requested modification is applied directly to the persistently stored binary form without constructing an object tree or materializing the XML document into a corresponding textual form. Taking into account the nature of the binary form in which the document is encoded, the bytes that actually require change are identified, including identifying where in the binary representation the corresponding actual changes need to be made.

Efficient piece-wise updates of binary encoded XML data

Techniques are described for unifying static and dynamic compiler optimizations in source code bases. In an embodiment, a first compiler compiles source code of a target function to generate ahead-of-time (AOT) compiled machine code. A second compiler compiles the source code to generate an intermediate representation (IR) of the target function. In response to determining that the target function should be just-in-time (JIT) compiled, the AOT-compiled machine code for the target function is linked to the IR of the target function. During runtime, a physical processor executes AOT-compiled machine code of an executable program. When the target function is encountered for the first time, a JIT compiler is invoked. The JIT compiler generates JIT-compiled machine code for the target function. The physical processor executes the JIT-compiled machine code in place of the AOT-compiled machine code for the target function.

Unifying static and dynamic compiler optimizations in source-code bases

A database server determines, on an element-level of granularity, what form of VARRAY storage to map collections of elements defined by a XML schema. A collection element may be mapped to an in-line VARRAY or an out-of-line VARRAY. The determination may based on a variety of factors, including the database type mapped to the collection element, database limitations that limit the form storage for certain database types, and annotations ('mapping annotations') embedded within that XML schema that specifying a database type for database representation of a collection element or a form of VARRAY storage.

Flexible storage of XML collections within an object-relational database

Growing community of inventors

San Francisco, CA, United States of America

Eric Sedlar