[Paper Review] BB-Graph: A Subgraph Isomorphism Algorithm for Efficiently Querying Big Graph Databases

Merve Asiler, Adnan Yazıcı|arXiv (Cornell University)|Jun 20, 2017

Graph Theory and Algorithms4 citations

TL;DR

BB-Graph is a novel subgraph isomorphism algorithm that improves efficiency in querying big graph databases by locally searching for candidate matches within the neighborhood of the first matched database node, reducing redundant global searches. It outperforms GraphQL and Cypher across multiple real-world and synthetic datasets, especially in large-scale scenarios, without requiring large in-memory indices.

ABSTRACT

The big graph database model provides strong modeling for complex applications and efficient querying. However, it is still a big challenge to find all exact matches of a query graph in a big graph database, which is known as the subgraph isomorphism problem. The current subgraph isomorphism approaches are built on Ullmann's idea of focusing on the strategy of pruning out the irrelevant candidates. Nevertheless, the existing pruning techniques need much more improvement to efficiently handle complex queries. Moreover, many of those existing algorithms need large indices requiring extra memory consumption. Motivated by these, we introduce a new subgraph isomorphism algorithm, named as BB-Graph, for querying big graph databases efficiently without requiring a large data structure to be stored in main memory. We test and compare our proposed BB-Graph algorithm with two popular existing approaches, GraphQL and Cypher. Our experiments are done on three different data sets; (1) a very big graph database of a real-life population database, (2) a graph database of a simulated bank database, and (3) the publicly available World Cup big graph database. We show that our solution performs better than those algorithms mentioned here for most of the query types experimented on these big databases.

Motivation & Objective

• Address the scalability challenge of subgraph isomorphism in big graph databases, where existing algorithms suffer from high computational cost and memory overhead.
• Overcome the inefficiency of global candidate search in traditional branch-and-bound algorithms that leads to redundant matching attempts.
• Eliminate the need for large precomputed indices by introducing a localized search strategy that reduces memory consumption.
• Improve performance across diverse query types—especially path, tree, and complex structural queries—on real-world and synthetic big graph databases.
• Provide a scalable, memory-efficient solution that maintains exact match accuracy while significantly reducing query response time compared to state-of-the-art approaches.

Proposed method

• Initiates subgraph isomorphism by selecting initial candidates for the first query node using node properties, enabling localized search space.
• After matching the first query node, restricts candidate search for subsequent nodes to the local neighborhood of the matched database node, reducing global search scope.
• Employs a branch-and-bound strategy with backtracking to systematically explore and prune invalid match paths, ensuring correctness and completeness.
• Leverages structural and semantic features of the query and database graphs—such as relationship cardinality (1-N, N-M) and node label frequency—to guide efficient search ordering.
• Avoids pre-indexing by dynamically identifying candidates during traversal, minimizing memory footprint and enabling deployment on main-memory-constrained systems.
• Uses query-specific node matching order selection based on graph topology and label frequency to further optimize performance.

Experimental results

Research questions

• RQ1 Can a subgraph isomorphism algorithm achieve better performance than existing approaches like GraphQL and Cypher by reducing global candidate search?
• RQ2 To what extent does local neighborhood-based candidate selection improve query efficiency in large graph databases without relying on large indices?
• RQ3 How does the performance of BB-Graph vary across different query types (e.g., path, tree, cyclic) and graph structures?
• RQ4 What impact does node matching order have on the performance of BB-Graph, particularly in relation to relationship cardinality (1-N vs. N-N)?
• RQ5 Can BB-Graph maintain high performance across diverse real-world and synthetic big graph databases while minimizing memory usage?

Key findings

• BB-Graph outperforms both GraphQL and Cypher in most query types across three datasets: Population, WorldCup, and Bank databases.
• For the path query Q-18, performance improved by nearly 20x when matching the 'N' side of an N-1 relationship first, due to reduced candidate count.
• In tree queries like Q-21, performance increased significantly when the matching order followed a path-like traversal, mimicking Q-19’s efficient pattern.
• For Q-11 and Q-12, starting the match from rarer semantic node types reduced false positives and improved performance by up to 17.3 seconds.
• BB-Graph’s performance is highly sensitive to structural features such as node label frequency, relationship type (1-N, N-M), and graph topology (e.g., cycles).
• Despite superior performance in most cases, BB-Graph’s performance slightly lags behind Cypher in specific analytical queries with short-cut features, indicating room for optimization.