Oracle International Corporation

Zhen Hua Liu

Vikas Arora

Muralidhar Krishnaprasad

Beda Christoph Hammerschmidt

James W Warner

Hui Joe Chang

Douglas James McMahon

Ying Lu

Thomas Baby

Anand Manikutty

Dieter Gawlick

Susan M Kotsovolos

Kenny C Gross

Sriram Krishnamurthy

Ravi Murthy

Geeta Arora

Hui Zhang

Rohan Angrish

Laurent Daynes

Vlad Ioan Haprian

Hugo Kapp

Marco Arnaboldi

Joshua Jeffrey Spiegel

Sundeep Abraham

Anguel Novoselsky

Hassan Chafi

Sungpack Hong

Andrew Witkowski

Jean-Pierre Lozi

Aurosish Mishra

Shasank Kisan Chavan

Guang Chao Wang

Kenneth P Baclawski

Tirthankar Lahiri

Adel Ghoneimy

Lei Sheng

Srividya Tata

Srikrishnan Suresh

Alfonso Colunga Sosa

Richard Paul Sonderegger

Anna Chystiakova

Eric S Chan

Wesley Lin

Qin Yu

Sukhendu Chakraborty

Karuna Muthiah

Amit Ganesh

Juan R Loaiza

Vineet Marwah

Sivasankaran Chandrasekar

Jesse Kamp

Ying Hu

Ananth Raghavan

Nimar Singh Arora

Sabina Petride

Ajit Mylavarapu

Sukhada Pendse

Edward R Wetherbee

Kongyi Zhou

Mengying Li

Shubha Bose

Aleksandra Czarlinska

Junyan Ding

Jose Omar Alvizo Flores

Francisco Alonso Alavez Sosa

Nipun Agarwal

Subramanian Muralidhar

Lik Wong

Siva Ravada

Niloy Mukherjee

Thomas Chang

Allison Holloway

Teck Hua Lee

Ramesh Kumar

Balasubramanyam Sthanikam

Matthew T Gerdes

Edwina Lu

Chandrasekharan Iyer

Kirk A Bradley

Abhyudaya Agrawal

Ying Li

Denis B Mukhin

James Rohrkemper

Rahul Manohar Kadwe

Shubhro Jyoti Roy

Saurabh Naresh Netravalkar

Beethoven Cheng

Sneha Chandrababu

Adrian Daniel Popescu

Sunitha Subramanyam

Danica Porobic

Siddharth Patel

Uma Durairajan

Kenway Tam

Andrea Segalini

Shashank Gugnani

Prakashkumar Thiagarajan

Anna Morav

Tixtla Iñaqui Medina Julia

Techniques for identifying a root cause of an operational result of a deterministic machine learning model are disclosed. A system applies a deterministic machine learning model to a set of data to generate an operational result, such as a prediction of a 'fault' or “no-fault” in the system. The set of data includes signals from multiple different data sources, such as sensors. The system applies an abductive model, generated based on the deterministic machine learning model, to the operational result. The abductive model identifies a particular set of data sources that is associated with the root cause of the operational result. The system generates a human-understandable explanation for the operational result based on the identified root cause.

Root cause analysis for deterministic machine learning model

A structured document storage format is provided in which tokens used for encoding and decoding are contained within the encoded document in an inline dictionary. Each document is encoded independently, and there is no central dependency or any dependency on other documents during DML and query execution. Each encoded document has all information with it on disk so that the document can be independently shared, decoded, or distributed. A mechanism is provided for quickly determining a mapping between tags and tokens without having to scan the entire inline token dictionary for each document. This allows the database system to process multiple documents, each having its own inline token dictionary, without having to fully scan the inline dictionary of every document for each tag that referenced in an operation.

Scalable, transportable, and self-contained binary storage format for extensible markup language

Herein are fine grained updates to pieces of JavaScript object notation (JSON) documents by database statements that can update, delete, and insert parts of JSON documents. In an embodiment, a computer receives a request that specifies a modification of a JSON document that is stored in a compressed format in persistent storage. The modification adds additional content to the JSON document, and/or replaces an old value in the JSON document with a new value that is not a same size as the old value. The modification is recorded in a change log. The change log is eventually applied to the compressed format of the JSON document in the persistent storage without entirely rewriting the compressed format of the JSON document in the persistent storage.

Supporting piecewise update of JSON document efficiently

Systems, methods, and other embodiments associated with auditing the results of a machine learning model are described. In one embodiment, a method accesses original time series data and machine learning estimates of the original time series data. The method generates reconstituted time series data from the machine learning estimates by reversing operations of a machine learning model trained for generating the machine learning estimates from the original time series data. The method detects tampering (or corruption) in the original time series data based on a difference between the original time series data and reconstituted time series data. And, the method generates an electronic verification report that indicates whether the tampering (or corruption) is detected in the original time series data.

System and method for ensuring that the results of machine learning models can be audited

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

Data structures and methods are described for converting a text format data-interchange file into size efficient binary representations. A method comprises receiving a request to convert a data-interchange file, comprising a hierarchy of nodes, into a binary file. The method further comprises generating a tree representation of the nodes that reference a plurality of leaf values. The method further comprises, in response to determining that the binary file is to be compressed, embedding relative node jump offsets when generating the tree representation. The method further comprises, in response to determining that the data-interchange file is immutable, deduplicating the plurality of leaf values in a space optimized manner. The method further comprises, in response to determining that the data-interchange file is mutable, deduplicating the plurality of leaf values in a stream optimized manner. The method further comprises storing the deduplicated plurality of leaf values in the binary file.

Technique of reducing size of binary JSON with/without compression

Techniques are provided for creating a 'ubiquitous search index' which allows for full-text as well as value range-based search across all columns from multiple database tables, multiple user-defined unmaterialized views, and external sources. In one implementation, the data is indexed in a peculiarly constructed schema-based JSON format without duplicating data. The techniques maintain eventual consistency with the normalized source of truth database tables, and do not have a significant impact on the performance of transactional Data Manipulation Language (DML) operations.

Ubiquitous search on data stored in the RDBMS

Techniques support graph pattern matching queries inside a relational database management system (RDBMS) that supports SQL execution. The techniques compile a graph pattern matching query that includes a bounded recursive pattern query into a SQL query that can then be executed by the relational engine. As a result, techniques enable execution of graph pattern matching queries that include bounded recursive patterns on top of the relational engine by avoiding any change in the existing SQL engine.

Efficient compilation of bounded recursive graph queries on top of SQL based relational engine

When a coordinator of a sharded DBMS receives from a client a query that has an XML operator that references a column in a sharded table and returns an XML image having an XML image type, then the coordinator issues a remote query that uses a new operator to ensure that the shard returns a TBX BLOB having a TBX type. In response to receiving the remote query with the new operator, each shard extracts a binary large object (BLOB) out of the XML image at the shard and returns the TBX BLOB data to the coordinator. In addition, the sharded DBMS provides a make-XML operator that the coordinator uses to work with the TBX BLOB received from each shard and recreate an XML type image, which is the result that the client expects.

Heterogeneous XML document support in a sharded 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

An RDBMS specifies a graph algorithm function (GAF) that takes a graph object as input and returns a logical graph object as output. GAFs are used within graph queries to compute temporary and output properties ('GAF-computed properties'), which are live for the duration of the query cursor execution. GAF-computed output properties are accessible in the enclosing graph pattern matching query as though they were part of the input graph object of the GAF. Temporary cursor-duration tables are generated for the query cursor during compilation of a graph query that includes a GAF, and are used to store the GAF-computed properties. Each temporary table corresponds to one of the primary tables of the input graph, and includes, as a foreign key, primary key information from the corresponding primary table.

Using temporary tables to store graph algorithm results for a relational database management system

Techniques for geometric aging data reduction for machine learning applications are disclosed. In some embodiments, an artificial-intelligence powered system receives a first time-series dataset that tracks at least one metric value over time. The system then generates a second time-series dataset that includes a reduced version of a first portion of the time-series dataset and a non-reduced version of a second portion of the time-series dataset. The second portion of the time-series dataset may include metric values that are more recent than the first portion of the time-series dataset. The system further trains a machine learning model using the second time-series dataset that includes the reduced version of the first portion of the time-series dataset and the non-reduced version of the second portion of the time-series dataset. The trained model may be applied to reduced and/or non-reduced data to detect multivariate anomalies and/or provide other analytic insights.

Geometric aging data reduction for machine learning applications

Techniques support graph pattern matching queries inside a relational database management system (RDBMS) that supports SQL execution. The techniques compile a graph pattern matching query into a SQL query that can then be executed by the relational engine. As a result, techniques enable execution of graph pattern matching queries on top of the relational engine by avoiding any change in the existing SQL engine.

Efficient compilation of graph queries including complex expressions on top of sql based relational engine

In one embodiment, a method for auditing the results of a machine learning model includes: retrieving a set of state estimates for original time series data values from a database under audit; reversing the state estimation computation for each of the state estimates to produce reconstituted time series data values for each of the state estimates; retrieving the original time series data values from the database under audit; comparing the original time series data values pairwise with the reconstituted time series data values to determine whether the original time series and reconstituted time series match; and generating a signal that the database under audit (i) has not been modified where the original time series and reconstituted time series match, and (ii) has been modified where the original time series and reconstituted time series do not match.

Growing community of inventors

San Mateo, CA, United States of America

Zhen Hua Liu