FERRARI: an efficient framework for visual exploratory subgraph search in graph databases

Abstract

Exploratory search paradigm assists users who do not have a clear search intent and are unfamiliar with the underlying data space. Query formulation evolves iteratively in this paradigm as a user becomes more familiar with the content. Although exploratory search has received significant attention recently in the context of structured data, scant attention has been paid for graph-structured data. An early effort for building exploratory subgraph search framework on graph databases suffers from efficiency and scalability problems. In this paper, we present a visual exploratory subgraph search framework called ferrari, which embodies two novel index structures called vaccine and advise, to address these limitations. vaccine is an offline, feature-based index that stores rich information related to frequent and infrequent subgraphs in the underlying graph database, and how they can be transformed from one subgraph to another during visual query formulation. advise, on the other hand, is an adaptive, compact, on-the-fly index instantiated during iterative visual formulation/reformulation of a subgraph query for exploratory search and records relevant information to efficiently support its repeated evaluation. Extensive experiments and user study on real-world datasets demonstrate superiority of ferrari to a state-of-the-art visual exploratory subgraph search technique.

Appendices

A Proofs

Proof of Lemma 1(Sketch). Algorithm 2 builds a vaccine index by adding all frequent fragments one by one and connecting them together by their transformation relationships via two types of primitive transformers. So the number of vertices in a vaccine index is the total number of frequent fragments and difs (i.e., N). For a frequent fragment f, there are at most $N_{fmax}$ nodes. Hence, we can add $C_{N_{fmax}}^2$ new edges for connecting current nodes in f. In addition, there are at most $N_{fe}$ different ways to add a new frequent edge of a new labeled node to a current node in f. So it can create at most $N_{fmax}N_{fe}$ edges. Thus, there are $O(N(C_{N_{fmax}}^{2}+N_{fmax}N_{fe}))$ edges at most in a vaccine index.

Proof of Theorem 1(Sketch). In Algorithm 2, the process for creating vaccine index can be divided into three major steps. The first step (Line 1) is to mine all frequent fragment from $\mathcal {D}$, whose time complexity is denoted as $C_{ff}$. The second step (Line 5–10) is to fetch all frequent edges in $\mathcal {D}$ and store them in a matrix. Its time complexity is O(|E|). The third step (Line 11–14) is to iterate through all frequent fragments to create the index by utilizing the node and edge transformers. Assume the time complexity of the canonical labeling process is $C_{cl}$. Then the time complexities of node and edge transformers are $O(N_{fmax}|\mathcal {L}|C_{cl})$ and $N_{fmax}^{2}C_{cl})$, respectively. Hence the overall complexity is $N_{f}C_{cl}(N_{fmax}|\mathcal {L}|+N_{fmax}^{2})$. The final step (Line 15–17) is to compute data graph identifier set of difs. Its complexity is $O(N_{dif}N_{dmax})$. Thus, the time complexity for building vaccine index is $O(C_{ff} + |\mathcal {E}|+N_{f}C_{cl}(N_{fmax}|\mathcal {L}|+N_{fmax}^{2}) + N_{dif}N_{dmax})$.

Proof of Theorem 2(Sketch). First, we prove the following lemma, which we shall be using subsequently.

Lemma 2

Given a vaccine index $G_{I}=(V_{I}, E_{I})$, the time complexity of processing a new edge $e_{\ell }$ to the current query fragment $q=(V_{q},E_{q})$ is $O(|V_{I}|C_{CAM} + min(|V_{I}|, x_{f})(|V_{q}| + |E_{q}|))$, where $x_{f}$ is the number of frequent fragments and DIFs of q in $G_{I}$ that contains $e_{\ell }$ and $C_{CAM}$ is the time complexity of comparing the cam codes of a pair of graphs.

Proof of Lemma 2

When a new edge $e_\ell$ is added to the current query fragment q, Algorithm 4 first compares the cam code of $e_\ell$ with all fragments in $G_{I}$ to check whether the new edge is a frequent fragment or a dif. If it is, then we can get the corresponding matching vertex for $e_\ell$ (Line 1). The time complexity for this task is $O(|V_{I}|C_{CAM})$. Next, the algorithm finds and indexes all frequent fragments and difs that contain $e_\ell$ gradually by utilizing the primitive transformers associated with the edges of the matching vertex. For each fragment, it performs three tasks: (a) compare the transformer information with all children of the matching vertex for finding the next one via MatchingInVaccine function (Line 11), (b) update/add vertex for matched fragments (Lines 12–15) and its parental relationships (Lines 16), and (c) push itself to the queue (Line 17). The time complexities of these three tasks are O(1) (using a suitable hash function), $O(|V_{q}| +|E_{q}|)$ (there are at most $|E_{q}|-1$ parent-child relationships in $G_{I}$ for a fragment) and O(1), respectively. The upper bound of the number of frequent fragments and difs is the minimum value of $|V_{I}|$ and $x_{f}$. Thus, the complexity of processing each new edge during query formulation is $O(|V_{I}|C_{CAM} + min(|V_{I}|, x_{f}) (|V_{q}| + |E_{q}|))$. $\square$

Proof of Theorem 2

From Lemma 2, we know that the time complexity for building advise index by adding an edge $e_{\ell }$ to the current query graph $q_{c}=(V_{q_{c}}, E_{q_{c}})$ is $O(|V_{I}|C_{CAM} + min(|V_{I}|, x_{f})(|V_{q_{c}}| + |E_{q_{c}}|))$ where $x_{f}$ is the number of frequent fragments and difs of $q_{c}$ in $G_{I}$ that contains $e_{\ell }$. The whole query q is formulated gradually, thus $|E_{q_{c}}| \le |E_{q}|$ and $|V_{q_{c}}| \le |V_{q}|$. So the worst-case cost for adding a query edge is $O(|V_{I}|C_{CAM} + min(|V_{I}|, x_{fq})(|V_{q}| + |E_{q}|))$. Because there are at most $E_{q}$ different edges with distinct labels to be added during the formulation of q, the total time complexity is $O(|E_{q}|*(|V_{I}|C_{CAM} + min(|V_{I}|, x_{fq}) (|V_{q}| + |E_{q}|)))$. $\square$

The upper bound of the number of vertices in $G_{A}$ is the minimum value of $(|V_{I}|$ and $2^{|E_{q}|}-1)$. Thus, the space complexity of advise index is $m*min(|V_{I}|, 2^{|E_{q}|}-1)$.

Fig. 17

GUI of FERRARI and PICASSO

GUI of FERRARI and PICASSO

Figure 17 depicts the direct manipulation interface of picasso and ferrari. It consists of the following panels.

• An Attribute Panel (Panel 2) to display a set of labels or attributes of nodes or edges of the underlying data.

• A Pattern Panel (Panel 3) to display a set of template patterns that can aid query formulation.

• A Query Panel (Panel 4) for constructing a graph query graphically by leveraging the Attribute and Pattern Panels.

• A Results Exploration Panel (Panel 5) that displays the query results during exploration.

A typical query would be constructed using the interface by performing the following sequence of steps.

• 1. Move the mouse cursor to the Attribute or Pattern Panel.

• 2. Scan and select a label or pattern (e.g., label C, benzene ring pattern).

• 3. Drag the selected item to the Query Panel and drop it. Each such action represents formulation of a single node or a query fragment in the query graph.

• 4. Repeat, if necessary, Steps 1–3 for constructing another node or a query fragment.

• 5. Construct edges (if necessary) between relevant nodes in the constructed subgraphs by clicking on them.

• 6. Repeat Steps 4 and 5 until the query graph is executed by clicking on the Run icon.