Sap Se

Sap Ag

Daniel Ritter

Manuel Holzleitner

Christian Bensberg

Ankur Bhatt

Jan Bross

Jonas Dann

Till Westmann

Stefano Belloni

Christian Mathis

Jan Sosulski

Jürgen Denner

Norman May

Gopalkrishna Kulkarni

Hannes Jakschitsch

Roland Sedler

Gerald Franz

Markus Muenkel

Neeraj Kulkarni

Mitko Kolev

Markus Fath

Frank Oliver Hoffmann

Matthias Hauck

Umang Rawat

Gunther Rothermel

Christoph Liebig

Sumanth Kempegowda

Marco Patrick Schroeder

Joerg Ackermann

Kai Mueller

Christian Illenberger

Marc Jacob

Mathias Kemeter

Frank Tetzel

Alan Braenzel

David Thol

Nils Roerup

Philipp Stefan Womser

Royden Wagner

Egor Hinz

Andre Dossinger

Yannik Bart

Christoph Herrmann

Stephanie Rupprich

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

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 may include generating, based at least on a schema configuration of one or more document stores, a plurality of data in a JavaScript Object Notation (JSON) format for storage at the document stores. One or more queries may be generated to match the plurality of data stored at the document stores. The one or more queries may be distributed for execution at the document stores by a scalable quantity of concurrently operating worker nodes. One or more performance metrics for the execution of the one or more queries at the one or more document stores may be generated. Performance improvements at the document stores may be applied based on the performance metrics. Related systems and computer program products are also provided.

Benchmarking JSON document stores

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

According to some embodiments, a central cloud-based repository of data may contain consolidated facts about enterprise applications. A computer processor of a discovery engine may execute discovery in a local application process and, based on the executed discovery, automatically create a generic structured set of facts from locally accessible data. The discovery engine may then store the generic structured set of facts in the central cloud-based data repository using a standard format (e.g., JSON). The central cloud-based data repository may, for example, store facts from different application instances and/or facts from different applications. According to some embodiments, a user generated query is created in a query language (e.g., SQL) and executed on the central cloud-based repository of data to automatically create an answer. Moreover, an automated ML agent may, in some embodiments, evaluate information in the central cloud-based repository of data.

Creation of structured set of facts via enterprise information discovery

A method may include parsing, using a JavaScript Object Notation (JSON) parser implemented on a field programmable gate array (FPGA), a JSON document. The parsing includes dividing an input string comprising the JSON document into one or more data blocks and annotating the characters included in each data block a bitmap for each data block. String characters included in the data blocks may be identified, based on the bitmap associated with each data block, for writing to a string array. Numeric characters included in the data blocks may be transformed, based on the bitmap associated with each data block, into integers value for writing to an integer array or float values for writing to a float array. A tape including a binary representation of the JSON document may be generated based on the bitmap associated with each data block. Related systems and computer program products are also provided.

Parsing JSON on field programmable gate arrays

A method, a system, and a computer program product for providing a compression service, such as a Compression as a Service (Caas). In some implementations, there is provided a method including receiving, at a compression service, metric information regarding one or more columns of a database server; in response to receiving the metric information, processing, by the compression service, the metric information to identify at least one column as a candidate for compression by the compression service; in response to identifying the at least one column, compressing by the compression service, the at least one column, wherein the compression service uses a hardware accelerator to execution a compression algorithm that compresses the at least one column; and notifying, by the compression service, the database server of the at least one column compressed by the compression service. Related systems, methods, and articles of manufacture are also disclosed.

Compression service using FPGA compression

A method for graph processing in a scalable graph processing framework may include applying a two-dimensional partitioning scheme to partition a graph. One or more partitions of the graph may be distributed to each graph core such that each graph core executes a graph processing algorithm on one or more partitions of the graph. The executing of the graph processing algorithm may include the graph cores exchanging vertex labels via a crossbar interconnecting the plurality of graph cores. Each graph core in the scalable graph processing framework may be coupled with a single memory channel upon which the partitions of the graph are distributed. The graph cores may synthesized on a field programmable gate array (FPGA) based on one or more user defined functions (UDFs). Related systems and computer program products are also provided.

Scalable bandwidth efficient graph processing on field programmable gate arrays

Methods and systems may be associated with application integration in a multi-cloud computing environment. A modeling platform may determine a pattern composition for an integration process associated with a business application. A cost-aware platform may transform a decomposed version of the pattern composition, including a plurality of integration pattern contract graphs, into a multi-cloud cost problem optimization representation. An initial solution to the cost problem representation may be calculated using a modified first fit decreasing bin packing or similar algorithm to determine a configuration of multi-cloud containers and integration pattern contract graph container assignments. The system may then iteratively and locally improve the solution to by applying feasible transformations to create variant container configurations and integration pattern contract graph container assignments that are evaluated based on multi-cloud costs (keeping the user in-the-loop). When a termination criteria is satisfied, an indication of the improved solution may be output.

Cost-aware integration process modeling in multi-cloud computing environment

According to some embodiments, methods and systems may be associated with trustworthy application integration. A formalization platform may facilitate definition of pattern requirements by an integration developer. The formalization platform may also formalize singe pattern compositions and compose single patterns to template-based formalized compositions. A correctness platform may then check for structural correctness of the formalized compositions and execute a semantic transformation or binding to pattern characteristics and associated interactions. The correctness platform may also check composition semantics and generate a formal model. An implementation platform may translate the formal model generated by the correctness platform and configure implementation parameters of the translated formal model. The implementation platform may then execute the translated formal model in accordance with the configured implementation parameters.

Trustworthy application integration

According to some embodiments, methods and systems may be associated with enterprise application integration. A formalization platform may facilitate definition of Enterprise Integration Patterns ('EIP') using a formal representation and defined execution semantics. The formalization platform may also execute model checking to find errors in the formal representation. An implementation platform may receive information from the correctness platform and translate the formal model generated by the correctness platform. The implementation platform may also configure implementation parameters of the translated formal model and simulate the EIP patterns to provide experimental validation. A correctness platform may receive information from the formalization platform and evaluate correctness of the EIP patterns defined via the formalization platform.

Responsible development process and definition of integration patterns and semantics

The present disclosure describes methods, systems, and computer program products for data-centric integration modeling in an application integration system. One computer-implemented method includes receiving, by operation of an integration system, a logic integration program comprising a plurality of logic integration patterns that are defined in a data-centric logic integration language; generating a logical model graph based on the logic integration program, the logical model graph being runtime-independent; converting the logical model graph into a physical model graph, the physical model graph being runtime-specific; and generating logic integration runtime codes executable by the integration system based on the physical model graph.

Data-centric integration modeling

A client node may execute an application that communicates with a first messaging service component of a first broker node in a server segment and a second messaging service component of a second broker node in the server segment. A load balancing component is coupled to the client node, and a first virtual provider entity for the first messaging service component is coupled to the load balancing component. The first virtual provider entity may represent a first HA message broker pair, including: (i) a first leader message broker entity, and (ii) a first follower message broker entity to take control when there is a problem with the first leader message broker entity. A shared database is accessible by the first broker node, the first HA message broker pair, and the second broker node, and includes an administration registry data store.

Collaborative message broker scaling and migration

Methods, systems, and computer-readable storage media for providing a simulated graph processing accelerator representative of a hardware-based graph processing accelerator, the simulated graph processing accelerator including a controller component, a set of producer components, and a final merge component; triggering execution of the simulated graph processing accelerator as a simulation of processing of a graph for one or more of breadth-first search (BFS), single source shortest path (SSSP), weakly connected components (WCC), sparse matrix-vector multiplication (SpMV), and PageRank (PR), execution including: generating request streams from each producer component, merging request streams to provide a merged request stream, inputting the merged request stream to a memory simulator, and processing, by the memory simulator, the merged request stream to simulate handling of requests in memory.

Simulation environment for efficient assessment of memory-bound platforms

Growing community of inventors

Heidelberg, Germany

Daniel Ritter