Oracle International Corporation

Tirthankar Lahiri

Juan R Loaiza

Jesse Kamp

Garret Frederick Swart

Niloy Mukherjee

Vasudha Krishnaswamy

Shasank Kisan Chavan

Ajit Mylavarapu

Kartik Kulkarni

Vineet Marwah

Vivekanandhan Raja

Sanket Hase

Sukhada Pendse

Allison Holloway

Teck Hua Lee

Yunrui Li

Hideaki Kimura

Michael J Gleeson

Kiran Badrinarain Goyal

Chih-Ping Wang

Krishna Kunchithapadam

Amit Ganesh

Aurosish Mishra

Avneesh Pant

Neil J S MacNaughton

Chi-Kim Hoang

Marie-Anne Neimat

Zhen Hua Liu

Kothanda Umamageswaran

Beda Christoph Hammerschmidt

Meichun Hsu

Boris Klots

Ananth Raghavan

Neil MacNaughton

Sujatha Muthulingam

Arvind Nithrakashyap

Kam Shergill

Hariharan Lakshmanan

Prashant Gaharwar

Benoit Dageville

Andrew Witkowski

Karl Dias

Mark L McAuliffe

Lakshminarayanan Luxi Chidambaran

Gary C Ngai

Srinath Krishnaswamy

Bipul Sinha

Douglas James McMahon

Mark Charles Ramacher

Krishnan Meiyyappan

J William Lee

Hui Joe Chang

Srinivas Vemuri

Gianfranco Putzolu

Graham Wood

Ying Lu

Andrey Gusev

Mehul Dilip Bastawala

Anindya Chandra Patthak

Atrayee Mullick

Sundeep Abraham

Xia Hua

Jiaqi Yan

Daniel ManHung Wong

Mohamed Zait

Mohamed Ziauddin

Kumar Rajamani

Wei-Ming Hu

Sumanta Kumar Chatterjee

Dieter Gawlick

Mahesh Baburao Girkar

William Havinden Bridge, Jr

Hakan Jakobsson

Michael Zoll

Dheeraj Pandey

Sabina Petride

Richard L Frank

Jia Shi

Vinay H Srihari

William Bridge

Mark Dilman

Alex Tsukerman

Jaebock Lee

Sanjay Kaluskar

Margaret Susairaj

Dmitry Mikhailovich Potapov

David Brower

Alok Pareek

Sankar Subramanian

Kant C Patel

Roger MacNicol

Ramesh Kumar

Leng Leng Tan

Paul Youn

Weiwei Gong

Bharat Chandra Baddepudi

Viral Shah

Sreedhar Mukkamalla

Chi Kim Hoang

Adam Y Lee

Techniques are provided for optimizing storage of database records in segments using sub-segments. A base segment is a container used for storing records that belong to a database object. A database management system receives a request to load, into the database object, a first set of records that are in a first state. In response to receiving the request, the system generates a new sub-segment, which is a container that is separate from the base segment. The system stores the first set of records, in their first state, within the sub-segment. The system then monitors one or more characteristics of the database system. In response to the one or more characteristics satisfying criteria, the system performs a migration of one or more records of the first set of records from the sub-segment to the base segment. During the migration, the system converts the one or more records from the first state to a second state and stores the one or more records, in their second state, in the base segment.

Automatic, online and space efficient clustering and compression of very large database objects

A Lock-Free Reservation mechanism is provided. When a transaction issues an update that affects a value in a 'reservable column' of a row, the database server does not immediately obtain a lock that covers the row. Instead, the database server adds a reservation to a reservation journal. At the time the transaction commits, a lock is obtained and the requested update is made. In one implementation, before adding the reservation to the reservation journal, the database server determines whether making the update would violate any constraints involving the reservable column. In one implementation, the constraint check not only takes into account the current value of the data item that is being updated and the amount of the update, but also pre-existing reservations in the reservation journal that affect the same data item.

System and method for increased transaction throughput and improved response time under high contention

Disclosed herein are techniques for storing, within a database system, metadata that indicates an intended usage (IU). Once created, an IU may be assigned to a column to (a) indicate how the column is intended to be used, and (b) affect how the database server behaves when database operations involve values from the column. The IU assigned to a column supplements, but does not replace, the datatype definition for the column. Each IU may have an IU-bundle. The IU-bundle of an IU indicates how the database server behaves with respect to any column that is assigned the IU. For example, the IU-bundle may indicate constraints that the database server must validate during operations on values from columns assigned to the IU. Techniques are also described for implementing multi-column IUs and flexible IUs.

Extending database data with intended usage information

JSON Duality Views are object views that return JDV objects. JDV objects are virtual because they are not stored in a database as JSON objects. Rather, JDV objects are stored in shredded form across tables and table attributes (e.g. columns) and returned by a DBMS in response to database commands that request a JDV object from a JSON Duality View. Through JSON Duality Views, changes to the state of a JDV object may be specified at the level of a JDV object. JDV objects are updated in a database using optimistic lock.

Natively supporting JSON duality view in a database management system

One or more engine instances are executed on each host to form an engine cluster. A plurality of control instances are executed on a first set of hosts to form a control cluster and comprise a control instance leader and one or more control instance followers. In response to a first host indicating a failure of a neighbor host, a pair-wise focused investigation is initiated to check peer-to-peer connections between the first host and the neighbor host. In response to one or more additional hosts indicating failures of neighbor hosts while the pair-wise focused investigation is being performed, a wide investigation is performed to check connections between the control cluster and the plurality of hosts. One or more hosts are added to an eviction list and an eviction protocol is performed to evict the one or more hosts from the engine cluster using the eviction list.

System and method for transaction continuity across failures in a scale-out database

A computer analyzes a relational schema of a database to generate a data entry schema and encodes the data entry schema as JSON. The data entry schema is sent to a database client so that the client can validate entered data before the entered data is sent for storage. From the client, entered data is received that conforms to the data entry schema because the client used the data entry schema to validate the entered data before sending the data. Into the database, the entered data is stored that conforms to the data entry schema. The data entry schema and the relational schema have corresponding constraints on a datum to be stored, such as a range limit for a database column or an express set of distinct valid values. A constraint may specify a format mask or regular expression that values in the column should conform to, or a correlation between values of multiple columns.

Framework and method for consistent cross-tier data validation

A shared-nothing database system is provided in which parallelism and workload balancing are increased by assigning the rows of each table to 'slices', and storing multiple copies (“duplicas”) of each slice across the persistent storage of multiple nodes of the shared-nothing database system. When the data for a table is distributed among the nodes of a shared-nothing system in this manner, requests to read data from a particular row of the table may be handled by any node that stores a duplica of the slice to which the row is assigned. For each slice, a single duplica of the slice is designated as the “primary duplica”. All DML operations (e.g. inserts, deletes, updates, etc.) that target a particular row of the table are performed by the node that has the primary duplica of the slice to which the particular row is assigned. The changes made by the DML operations are then propagated from the primary duplica to the other duplicas (“secondary duplicas”) of the same slice.

System and method for an ultra highly available, high performance, persistent memory optimized, scale-out database

An approach is described to provide a method, a computer program product, and a computer system to implement hole punching. The described approach provides an automated way to free up space without requiring manual intervention by a DBA to manually reorganize database objects to free up space.

Automatic reclamation of storage space for database systems

Columns of a table are stored in either row-major format or column-major format in an in-memory DBMS. For a given table, one set of columns is stored in column-major format; another set of columns for a table are stored in row-major format. This way of storing columns of a table is referred to herein as dual-major format. In addition, a row in a dual-major table is updated 'in-place', that is, updates are made directly to column-major columns without creating an interim row-major form of the column-major columns of the row. Users may submit database definition language (“DDL”) commands that declare the row-major columns and column-major columns of a table.

Combined row and columnar storage for in-memory databases for OLTP and analytics workloads

A database is stored as a plurality of database shards in a distributed database grid comprising a plurality of grid elements, each including a mid-tier database system. A first grid element receives, from an application executing in the same memory as a mid-tier database system of the first grid element, a first database transaction including at least one database operation on specific data stored in a first database shard that belongs to the first grid element. The first grid element performs and commits the first database transaction without participation of another grid element of the plurality of grid elements. The first grid element receives a second database transaction that requires access to another database shard that does not belong to the first grid element. Multiple grid elements of the plurality of grid elements perform the second database transaction and commit the second database transaction using a two-phase commit protocol.

Direct-connect functionality in a distributed database grid

Techniques are described for offloading remote direct memory operations (RDMOs) to 'execution candidates'. The execution candidates may be any hardware capable of performing the offloaded operation. Thus, the execution candidates may be network interface controllers, specialized co-processors, FPGAs, etc. The execution candidates may be on a machine that is remote from the processor that is offloading the operation, or may be on the same machine as the processor that is offloading the operation. Details for certain specific RDMOs, which are particularly useful in online transaction processing (OLTP) and hybrid transactional/analytical (HTAP) workloads, are provided.

Same-machine remote direct memory operations (RDMOS)

Techniques herein use in-memory column vectors to process data that is external to a database management system (DBMS) and logically join the external data with data that is native to the DBMS. In an embodiment, a computer maintains a data dictionary for native data that is durably stored in an DBMS and external data that is not durably stored in the DBMS. From a client through a connection to the DBMS, the computer receives a query. The computer loads the external data into an in-memory column vector that resides in random access memory of the DBMS. Based on the query and the data dictionary, the DBMS executes a data join of the in-memory column vector with the native data. To the client through said connection, the computer returns results of the query based on the data join.

Performing in-memory columnar analytic queries on externally resident data

Techniques related to query execution against an in-memory standby database are disclosed. A first database includes PF data stored on persistent storage in a persistent format. The first database is accessible to a first database server that converts the PF data to a mirror format to produce MF data that is stored within volatile memory. The first database server receives, from a second database server, one or more change records indicating one or more transactions performed against a second database. The one or more change records are applied to the PF data, and a reference timestamp is advanced from a first to a second timestamp. The first database server invalidates any MF data that is changed by a subset of the one or more transactions that committed between the first and second timestamps.

Query execution against an in-memory standby database

Growing community of inventors

Palo Alto, CA, United States of America

Tirthankar Lahiri