Microsoft Technology Licensing, LLC

Linkedin Corporation

Scott M Meyer

Andrew Joseph Carter

Srinath Shankar

Andrew Rodriguez

Walaa Eldin M Moustafa

Robert W Stephenson

Siddharth Rajendra Shah

Ying Lu

Karan Rajen Parikh

Yongling Song

Joshua D Ehrlich

Huaxin Liu

Shyam Shankar

Yejuan Long

Xiaobin Ma

Yan Yu

Brent D Miller

SungJu Cho

Bogdan George Arsintescu

Ionut Constandache

Qingpeng Niu

Yiming Yang

Maverick Shu-Bun Lee

Yinyi Wang

Roman A Averbukh

Jiahong Zhu

Christopher J Mihm

Nicolas V Thompson

Emily P Timm

Andrew J Carter

The disclosed embodiments provide a system for processing queries of a graph database. During operation, the system stores intermediate results of the query in a structure comprising rows in a set of tables and links between pairs of rows in different tables in the set of tables. Next, the system tracks, in the structure, representations of data, relationships, and path consistency in the query. The system then applies one or more operations to existing rows in the structure to generate a final result of the query. Finally, the system provides the final result in a response to the query.

Enforcing path consistency in graph database path query evaluation

The disclosed embodiments provide a system for processing queries of a graph database storing a graph, wherein the graph comprises a set of edges defined by a first linkage, a second linkage, and a third linkage. During operation, the system maintains the base version of an index of the graph database. Upon branching a version of the graph database from a first offset representing a virtual time in the base version of the graph database, the system creates a branched version of the index from a second offset corresponding to the virtual time in the base version of the index. The system then processes queries of the graph database based on the offsets and references from the branched version of the index to the base version of the index.

Branch threading in graph databases

The disclosed embodiments provide a system for processing queries of a graph database. During operation, the system stores intermediate results of a query in a structure comprising rows in a set of tables. Next, the system applies one or more operations to existing rows in the structure to generate additional rows in additional tables of the structure. The system also tracks inputs and outputs associated with the one or more operations in a set of relationships between rows of different tables in the structure. Finally, the system uses the rows and the set of relationships to generate a final result of the query and provides the final result in a response to the query.

Path query evaluation in graph databases

The disclosed embodiments provide a system for performing unified error monitoring, alerting, and debugging of distributed systems. During operation, the system receives logs of activity within a distributed system over event streams in a distributed streaming platform. Upon identifying an error in the received logs, the system collects, from the event streams, log entries generated within a time window of the error into a contextual log associated with the error. The system then outputs an alert containing metadata for accessing the contextual log.

Unified error monitoring, alerting, and debugging of distributed systems

The disclosed embodiments provide a system that searches a graph database. During operation, the system obtains a log-based representation of a graph database storing a graph, wherein the graph comprises a set of nodes, a set of edges between pairs of nodes in the set of nodes, and a set of predicates. Next, the system obtains a first query containing a first search pattern for searching the log-based representation. The system then matches the first search pattern to one or more records in the log-based representation. Finally, the system outputs, as a first result of the first query, the one or more records in a subgraph of the graph.

Pattern-based searching of log-based representations of graph databases

During operation, a system for processing queries of a graph database executes a set of processes for processing queries of a graph database storing a graph, wherein the graph comprises a set of nodes, a set of edges between pairs of nodes in the set of nodes, and a set of predicates. When a query of the graph database is received, the system obtains, from the query, a compound comprising a compound type and a set of identity-giving nodes. Next, the system uses the compound to access a tuple for storage in a log-based representation of the graph database, wherein the tuple includes the compound type and the identity-giving nodes. The system then uses the tuple to generate a result of the query and provides the result in a response to the query.

Supporting tuples in log-based representations of graph databases

The disclosed embodiments provide a system for processing queries of a graph database. During operation, the system executes a set of processes for maintaining the graph database storing a graph, wherein the graph includes a set of nodes, a set of edges between pairs of nodes in the set of nodes, and a set of predicates. When a write query of the graph database is received, the system uses one or more of the processes to process the write query by using a schema of the graph database to validate the write query. Next, the system transmits the validated write query to a set of shards containing the graph database. Finally, the system processes the write query at each shard when a shard identifier representing the shard is matched to one or more attributes in the write query.

Distributed graph database writes

The disclosed embodiments provide a system for processing queries of a graph database. During operation, the system executes a set of processes for processing queries of a graph database storing a graph, wherein the graph comprises a set of nodes, a set of edges between pairs of nodes in the set of nodes, and a set of predicates. When a query of the graph database is received, the system performs a lookup of a hash map to obtain one or more offsets into a compound store for the graph database, which includes identity-giving nodes for a set of tuples in the graph database. Next, the system accesses the offset(s) in the compound store to obtain a subset of tuples matching the query. The system then uses the subset of tuples to generate a result of the query and provides the result in a response to the query.

Compound indexes for graph databases

The disclosed embodiments provide a system for processing queries of a graph database. During operation, the system executes one or more processes for providing the graph database storing a graph, wherein the graph includes a set of nodes, a set of edges between pairs of nodes in the set of nodes, and a set of predicates. Next, the system receives a query containing a missing value parameter, wherein the missing value parameter designates an attribute in the graph database with a nonexistent value. The system then produces, from the query, a transformed query comprising one or more parameters that do not include the missing value parameter. Finally, the system uses the transformed query and the graph database to generate a result of the query and provides the result in a response to the query.

Transforming and evaluating missing values in graph databases

The disclosed embodiments provide a system for updating an index structure of a graph database storing a graph. During operation, the system includes, in the index structure, a first compressed edge store containing a first compact representation of edges in the graph at a first virtual time and a first series of updates to the edges after the first virtual time. At a second virtual time, the system creates a second compact representation of the edges from the first compact representation and the first series of updates. The system then appends, to the second compact representation, a second series of updates to the edges after the second virtual time to produce a second compressed edge store. Finally, the system updates the index structure by atomically replacing, in the index structure, a reference to the first compressed edge store with a reference to the second compressed edge store.

Atomic updating of graph database index structures

A system executes a query associated with an application against a graph database by providing, to a first shard of the graph database, the query and a first query header that specifies the first shard. The query includes a subject, a predicate and an object, and the graph database stores a graph that includes nodes, edges between the nodes, and predicates to represent and store data. In response to the query, the system receives results and associated result headers from the first shard and a second shard, where the result headers specify that the results are partial results that are particular fractions of a total result. Furthermore, a combination of the partial results provides the total result to the query that includes a subset of the graph. Note that the subset of the graph may include desired information expressed within an associated structure of the graph.

Message passing in a distributed graph database

In order to facilitate the requesting of desired information from a graph database that stores a graph, a system may translate an initial query into a query that can be executed against the graph database. In particular, using primitives, the system may translate a query associated with a type of database (such as a relational database) into the query. The graph may include nodes, edges between the nodes, and predicates to represent and store data with index-free adjacency. Moreover, the primitives may include: a rule based on edges in the graph that expresses a relational schema in the type of database, and information associated with a compound key that specifies a relationship between nodes, edges and predicates in the graph corresponding to a table in the type of database. Then, the system may execute the query against the graph database, and may receive a result that includes a subset of the graph.

Translating queries into graph queries using primitives

In order to request desired information from a graph database, a system executes a query against the graph database. The graph database may store a graph that includes nodes, edges between the nodes, and predicates to represent and store data with index-free adjacency. Moreover, the query may identify a first edge associated with a predicate that specifies one or more of the nodes in the graph. In response to the query, the system receives a result that includes a subset of the graph. In particular, the subset of the graph may include the desired information expressed within an associated structure of the graph.

Growing community of inventors

Berkeley, CA, United States of America

Scott M Meyer