Abstract: Systems, methods, and software described herein manage graph query response using bloom filters and edge indexes. In one implementation, a graph management system may generate indexes and delta indexes for edges in a graph. Once generated, the graph management system may receive a query to the graph and respond to the query using the index and at least one delta index of the delta indexes.

Abstract: Systems, methods, and software described herein provide operations to generate and manage a graph. In one implementation, a graph management system may identify a request to generate a graph from multiple databases. In response to the request, the graph management system may identify attributes of interest in the databases and generate vertices that correspond to the attributes of interest. As the new vertices are generated, the graph management system may determine attributes that are related to the same entity, generate entity vertices that correspond to the entities identified in the databases, and generate edges that connect the attribute vertices to the corresponding entity vertices.

Abstract: Query processing using online transactional processing (OLTP) and/or online analytical processing (OLAP) use a distributed graph. Optimizations are described including compute pushdown OLTP mode, single thread OLTP mode, and automatic transition between OLTP mode and OLAP mode. A query processing engine comprises an OLTP processing engine, an OLAP processing engine, and a storage (e.g., a computer memory or storage). The OLTP processing engine is configured to process OLTP queries, and the OLAP processing engine is configured to process OLAP queries. The query processing engine may comprise a transition determination engine configured to determine when to transition query processing between OLTP query processing mode and OLAP query processing mode.

Abstract: Systems, methods, and software described herein generate and manage a compressed database using a dictionary and a Huffman data structure. In one implementation, a method includes determining a frequency that each string of a plurality of strings in a segment of a database appears in the segment. The method further provides for identifying a first subset of strings with the highest frequency of appearance in the data structure and generating a dictionary for the first subset of strings. The method also includes generating a Huffman data structure based on the frequencies associated with the plurality of strings and generating a compressed segment based on the dictionary and the Huffman data structure.

Abstract: A schema-free static query template improves schema-free graph query performance and runtime stability. A user can customize a generated graph query while detecting a query tampering state. Schema-free query templates, which have been compile-time type/syntax/semantic checked by a dummy schema, are installed. The templates are called as if they are functions with their selected graph schema vertex types and edge types. The invocation generates a static query which uses input metadata to instantiate a static query, and goes through type/syntax/semantic checks to capture any input errors at compile time. If there is no error found during compile time, a query binary is generated only containing the metadata related to the parameters and sent to a query engine for execution. If a user later invokes the same query with the same metadata, the compiler matches the generated previous query, bypasses compilation, and goes directly to the existing binary code.

Abstract: A temporal graph model is provided that can handle all six graph updates cases: vertex created; vertex deleted; vertex property updated; edge created; edge deleted; and edge property updated. A memory efficient temporal graph storage solution stores the delta change of graph evolution at each update (e.g., instead of storing the whole graph snapshot at each time). Temporal graph querying techniques are described that can determine what the graph looks like at a given time in the past and can perform any graph query on that graph's snapshot at that time as if time traveling back to that time. Also provided are event sourcing techniques of recording and tracing temporal graph updates that make the evolution of the temporal graph explainable. Further provided is a seamless integration with a massive parallel graph processing and storage engine that fully leverages the multicore and multinode cluster computation and storage resources.

Abstract: Systems, methods, and software to manage tags in association with vertices of a graph. In one implementation, a graph management system identifies a request to tag vertices in the graph, wherein the request indicates one or more attributes to qualify for the tag as part of a conditional expression. The graph management system further identifies vertices in the graph with the one or more attributes. Once identified, the graph management system assigns the tag to the vertices wherein the tag comprises an attribute assigned to the identified vertices.

Abstract: Systems, methods, and software described herein provide operations to manage software licenses in relation to a virtualized image. In one implementation, a system may, during a first initiation of a virtualized instance, execute a process to determine and store registration information associated with the virtualized instance. Once stored, the system may delete the process and use the stored registration information during subsequent initiations of the virtualized instance to determine whether to permit software on the virtualized instance to be executed.

Abstract: A system for querying a graph model and methods for making and using same. An initial vertex set can be received for one or more query blocks. The one or more query blocks can be executed to generate respective output vertex sets. The output vertex sets and the initial vertex set can be enabled to interconnect in a vertex-set-flow graph based on the query blocks. The vertex-set-flow graph can have a Directed Acyclic Graph shape. A selected query block can generate an output vertex set based on an input vertex set with or without traversal over an edge. A selected query block can calculate a runtime attribute. Edges and/or vertices of the graph model can be updated during querying. A selected block can call a graph query as a generic function. Functions for querying the graph model are powerful and can advantageously meet various graph query needs.

Abstract: Systems and methods for enhanced detection of fraudulent electronic transactions are disclosed. In one embodiment, a system uses the ongoing stream of transactions to construct and maintain a dynamically evolving merchant relationship graph. When a proposed transaction is submitted to the system, the system computes a predicted likelihood that the given account would make a transaction with these characteristics with the given merchant. The graph is used to compute transitive relatedness between merchants which may be indirectly associated with one another, as well as to compute aggregate relatedness, when there are multiple avenues of relationship between two merchants.

Abstract: A system for updating a target schema of a graph model and methods for making and using same. A schema change job can be run to update the target schema. Loaded source data in the graph model can be updated based on the updated target schema. The schema can be changed at vertex type level, edge type level and attribute level for a pre-defined target schema after source data has been loaded. The loaded source data can be updated to be consistent with the updated target schema without a need of being reloaded. The schema change job can be defined declaratively. The target schema can be versioned and stored to maintain a history of target schema update. Advantageously, schema update can be easy to implement. The time-consuming and expensive reloading process can be avoided. Target schema updating can have high flexibility and high performance.

Abstract: A system for managing graph data and methods for making and using same. A loading plan can be generated according to a loading job. Source data can be loaded into the graph model based on the loading plan. The loading job can be defined declaratively. An interpreter can encode the loading job to generate the loading plan having a tree structure. The loading plan can instruct a loading engine to load the source data. The loading engine can be compiled independent of the loading plan. Advantageously, the loading engine can be compiled no more than once. The compiled loading engine can interpret any loading plan. The compiled loading engine can filter or transform the source data at runtime of the loading. Advantageously, time for compiling the loading engine and reading source data can be saved. Graph data loading can have high flexibility and high performance.