Sap Se

Sap Ag

Other

Sap Global IP Group, Sap Ag

Christian Bensberg

Steffen Geissinger

Lars Fricke

Kai Stammerjohann

Frederik Transier

Johannes Beigel

Juchang Lee

Martin Heidel

Hans-Joerg Leu

Jochen Becker

Carsten Mueller

Mihnea Andrei

Daniel Ritter

Thorsten Glebe

Alexander Boehm

Markus Fath

Norman May

Stefan A Baeuerle

Till Merker

Kyu Hwan Kim

Daniel Baeumges

Jonathan Dees

Andreas Tonder

Franz Faerber

Chang Gyoo Park

Anisoara Nica

Reza Sherkat

Ki Hong Kim

Wolfgang Stephan

Michael Muehle

Thomas Peh

Sung Heun Wi

Edward-Robert Tyercha

Deok Koo Kim

Roland Sedler

Joern Schmidt

Nico Bohnsack

Adrian Dragusanu

Christian Mathis

Holger Bischoff

Christoph Zakwieja

Stefano Belloni

Christian Kraus

Dirk Thomsen

Di Wu

Andreas Kemmler

Yong Sik Kwon

Xun Cheng

Meinolf Block

Rolando Blanco

Chul Won Lee

Jaeyun Noh

Sascha Zorn

Torsten Strahl

Axel Herbst

Taehyung Lee

Frank Renkes

Beomsoo Kim

Hannes Jakschitsch

Holger Schwedes

Gerald Franz

Myung Sun Park

Neeraj Kulkarni

Martin Schindewolf

Kai Morich

Sang Il Song

Heiko Gerwens

Christoph Hohner

Patrick Voelker

Stefan Elfner

Andreas Thumfart

Matthias Hauck

Martin Kittel

Umang Rawat

Martin Richtarsky

Holger Mack

Jeong Ae Han

Jin Uk Bae

Fabian Garagnon

Emanuel Ziegler

Long Zhang

Hans-Jörg Leu

Marc Jacob

Mathias Kemeter

Frank Tetzel

Alan Braenzel

Xun Chen

Andreas Hartel

Sergej Hardock

Christoph Glania

Armin Risch

Christian Bartholomä

Michael Mühle

Volker Diesel

Embodiments are described for a database management system comprising a memory and at least one processor coupled to the memory. The at least one processor is configured to receive a query that corresponds to a data slice and determine a bloom filter based on the query. The at least one processor is further configured to determine that the data slice includes data requested by the query based on the bloom filter and in response to determining that the data slice includes the data requested by the query, load the data slice to the memory.

Bloom filter for avoiding partition loading

Various embodiments for a triple integration and querying system with dictionary compression are described herein. An embodiment operates by identifying a table of a database with four or more columns with triple formatted data including one subject column, one predicate column, and two or more object columns. It is determined that a master dictionary is to be generated for the both the subject column and the predicate column based on an identical datatype being used for both columns. A master dictionary including both the unique values from the subject data dictionary and the predicate data dictionary is generated. Values in the subject column and the predicate column are replaced based on the unique values from the master dictionary.

Storing and querying knowledge graphs in column stores using a global dictionary

Various embodiments for a data compression store and search system are described herein. An embodiment operates by receiving a query to search a plurality of documents. It is determined that the plurality of documents are stored in a compressed format comprising a plurality of shells and a plurality of snippets. A first snippet that includes the query identifier is identified, and a first shell including a reference to the first snippet is identified. A readable version of a first document of the plurality of documents is assembled from the first shell. The assembled readable version of the first document is provided responsive to the query.

Data compression, store, and search system

System, method, and various embodiments for a data storage management system are described herein. An embodiment operates by receiving a request to create an index based on a portion of a database, the portion comprising one or more entries that correspond to one or more ongoing transactions. The index is generated based on the portion of the database, and a subset of entries that correspond to one or more ongoing transactions are auto-committed prior to a completion of the one or more ongoing transactions. A command to rollback the request to create the index is detected. The index is scheduled for asynchronous garbage collection, that remove information associated with the generated index from both memory and disk based upon a completion of one or more parallel transactions. The information associated with the generated index is removed from both the memory and disk in accordance with the asynchronous garbage collection.

Data storage management system

The present invention relates to an improved database system architecture designed for generating and managing heterogeneous graphs. The system utilizes a document store in conjunction with a persistent adjacency index to enhance flexibility, adaptability, and transactional visibility during the generation and modification of complex graph structures. Data stored in the document store utilizes a flexible schema for storing data which improves the efficiency in both storing and retrieving data from the document store during graph-related processing tasks.

Graph processing using a document store

Disclosed herein are system, method, and computer program product embodiments for providing data aggregation based on hash map data structures. An embodiment operates by receiving a query specifying an input table and an aggregate function. The embodiment then generates a first thread-local hash map and a second thread-local hash map for the input table and performs a probing function associated with the first thread-local hash map. The embodiment then determines, based on the first thread-local hash map, an index cardinality associated with the input table. The embodiment then, in response to the determination that the index cardinality exceeds the threshold, performs a duplicate function associated with the second thread-local hash map and generates a second thread-local copy map. The embodiment then merges the first thread-local hash map and the second thread-local copy map, thereby generating a merged hash map.

Data aggregation based on hash map data structures

A method may include receiving a query including at least one unnest operation to unnest a plurality of elements from one or more JavaScript Object Notation (JSON) arrays. The at least one unnest operation may unnest the plurality of elements by generating a table in which each row of the table is populated by one of the plurality of elements. An execution plan may be generated to include a pre-filter operation to filter, prior to the at least one unnest operation, the plurality of elements included in the one or more JSON arrays. For example, the pre-filter operation may be performed by iterating through the elements from the one or more JSON arrays to identify one or more elements satisfying a predicate included in a where clause of the query. The query may be executed in accordance with the execution plan. Related systems and computer program products are also provided.

Unnesting of JSON arrays

A method, a system, and a computer program product for generating a pageable hash index for a document store. A hash map index for data stored on disk using a document array is generated. The hash map index includes a plurality of hash values with each hash value identifying a document stored at a predetermined location in the document array. A transaction for executing using a first document stored in the document array is received. Using the generated hash map index, a location of the first document stored in the document array is identified. At least a portion of a first hash value of the hash map index corresponding to the first document is loaded into a memory location without loading the remaining hashes of the hash map index. Based on the loaded portion of the first hash value, the received transaction is executed.

Pageable hash index for document store

Disclosed herein are system, method, and computer program product embodiments for providing a lock-free read access to one or more data structures. An embodiment operates by allocating a first portion of a memory corresponding to a first data structure of the one or more data structures, the first data structure comprising a size. The embodiment then performs a first operation associated with the first data structure. The embodiment then receives a first request to insert second data to the first data structure, and determines whether an increase of the size is to be executed. The embodiment then, based on the determination that an increase of the size is to be executed, inserting the second data to a modified first data structure, comprising: executing garbage collection to free-up the first portion of the memory based on at least one parallel operation associated with the first data structure.

Lock-free read access to vector data structures

Various embodiments for a disk-based merge for combining merged hash maps are described herein. An embodiment operates by identifying a first hash map and a second hash map, and comparing a first hash value from the first hash map with a second hash value from the second hash map, with the lowest index values. A lowest hash value is identified based on the comparison, and an entry corresponding to the lowest hash value is stored in a combined hash map. This process is repeated until all of the hash values from both the first set of hash values and the second set of hash values are stored in the combined hash map. A query is received, and processed based on the combined hash map.

Disk-based merge for combining merged hash maps

Various embodiments for a disk-based merge for hash maps are described herein. An embodiment operates by identifying a plurality of hash maps with a plurality of disjunctions, ordering the one or more entries in each disjunction based on the hash value, and assigning an index value to each data value based on the ordering. The hash values of each of the entries may be moved to memory and compared for a particular disjunction. A data value with a lower hash value as determined based on the comparison is selected and stored in a merged hash map. The process is repeated until all the data values have been compared. A query is received, and processed based on the merged hash map.

Disk-based merge for hash maps

Disclosed herein are system, method, and computer program product embodiments for transferring data using a failsafe storage system. In some embodiments, a database receives a request to insert records of data. The records of data are to be transmitted from the source system to the target system. The database allocates a partition in the database based on a size of the plurality of records of data. The database inserts one or more records of data in each segment. The database inserts a create timestamp in each record header of the plurality of records. The create timestamp indicates a date and time when an insert of the one or more records of data is committed in a respective segment. The database inserts a delete timestamp in each segment of records of data, as each respective record of data is transmitted to the target system.

Throughput-optimized schema-flexible storage with transactional properties

A database system includes a persistent storage system, a memory storing metadata defining a tenant object and a plurality of database artifacts, a first instance of the tenant object, the first instance associated with a first plurality of the database artifacts including first data associated with the first instance of the tenant object, and a second instance of the tenant object, the second instance associated with a second plurality of the database artifacts including second data associated with the second instance of the tenant object. A processing unit is to execute program code of a database instance to cause the database system to encrypt the first data associated with the first instance of the tenant object using a first public encryption key and store the encrypted first data in the persistent storage system, and encrypt the second data associated with the second instance of the tenant object using a second public encryption key and store the encrypted second data in the persistent storage system.

Native multi-tenant encryption for database system

Various embodiments for a data management system for managing inferences are described herein. An embodiment operates by identifying a set of core data stored in a named graph and inferences generated based on the core data. A plurality of logged updates to the core data are detected. A query to execute against the named graph is received, and a signal to update the named graph is detected. At least a subset of the inferences are deleted, and the core data is modified based on the plurality of logged updates. A new plurality of inferences are generated based on the updated data. The query is executed against the named graph with the updated data and the new plurality of inferences, and a result from executing the query is returned.

Data management system for managing inferences

Lock-free read access to hash map data structures

Growing community of inventors

Heidelberg, Germany

Christian Bensberg