This paper studies the problem of dynamic group nearest neighbor group query (DGNNQ for short) over streaming data, an important problem in the domain of streaming data management. Let 𝒮 be the set of streaming data. A DGNNQ, denoted as q(n, s, k, 𝒬) , monitors objects within the window that contains q(n) objects. Whenever q(s) objects pass, q returns q(k) objects with the smallest distance sum to the query point set 𝒬 . Although some efforts can support this kind of queries, they incur highly running cost, especially when query points are allowed to be inserted into, or remove from 𝒬 . In this paper, we propose a novel framework named Q2WP (short for Query points and Window-based Partition) over streaming data. We group nearby query points into k subsets, and form a group of k virtual points based on these subsets. We then propose a novel index named PM-Tree to organize these virtual points, as well as evaluate which objects have chance to become query result objects based on PM-Tree. We further propose a group of novel algorithms to support incremental maintenance when 𝒬 updates. Extensive performance studies on large real-world and synthetic datasets demonstrate that the proposed framework can efficiently support DGNNQ over streaming data.

Efficiently managing and querying large bipartite graphs necessitates powerful indexing structures. A fundamental challenge lies in supporting (α,β)-component (bi-component) search, a task that encompasses retrieving all bi-components (bi-core search) or identifying the specific bi-component containing a query vertex (bi-community search). Existing index-based solutions face a time-space trade-off: single-dimensional approaches incur significant storage redundancy, while holistic approaches suffer from repeated vertex retrievals, hindering their scalability. To overcome these limitations, in this paper, we address this trade-off by introducing a novel, finer-grained cohesive unit, the (α,β,γ)- cluster ( bi-cluster ). This unit inherently captures the nested and overlapping relationships among bi-components, enabling vertex deduplication at the index level. Building on this, we propose the SGL ( Summary Graph + Location ) index, which achieves zero-redundancy in vertex retrieval during query processing. It organizes bi-components into a compact Summary Graph (SG) of interconnected SNodes. This structure, coupled with a precise Location mapping, allows our search algorithm to retrieve results without redundant vertex accesses, effectively decoupling query cost from the graph's global scale. Furthermore, we provide efficient construction and maintenance algorithms for dynamic bipartite graphs. Extensive experiments on ten real and synthetic large bipartite graphs demonstrate that our method outperforms the state-of-the-art by up to two orders of magnitude in query speed for bi-component search, while maintaining low storage, thus bridging the gap between fast but space-inefficient and compact but slower existing approaches.

Community detection in temporal networks has emerged as a significant research topic in complex network management, which seeks to identify communities based on a given subgraph model. While previous studies primarily focus on detecting communities solely based on structural properties, they often ignore essential factors, such as member engagement, connection strength, and cohesion continuity, which are critical for assessing the reliability of communities in temporal networks. Motivated by these limitations, we investigate the problem of top-r reliable community detection based on the (θ, k)-core model in temporal networks, aiming to identify top-r reliable communities ranked by their reliability scores. Due to the high computational complexity, we first propose a baseline algorithm, DpBCRC, leveraging the WCF-Index and dynamic programming. We further optimize the WCF-Index and propose a novel detection algorithm, IBTCD. To enhance efficiency, we design pruning strategie based on valid edge boundaries, leading to the optimized algorithm IBTCD-OPT. Experimental results on eight real-world datasets demonstrate the effectiveness and efficiency of our methods.

Community search in heterogeneous information networks (HINs) is a fundamental task in graph management and analysis. Existing relational community search models, which rely on simple connection requirements between vertices, often fall short of capturing users’ complex needs. To address this limitation, we introduce the concept of complex relational constraints based on meta-paths. These constraints enable users to specify refined connection requirements by limiting the number of meta-paths between vertex pairs, thereby capturing higher-order semantic relationships. Based on this, we formally define the complex relational community and formulate the problem of Minimum Complex Relational Community Search (MCRCS), which identifies the minimal such community containing a given query vertex, and prove its NP-hardness. To solve the MCRCS problem, we propose both exact and approximate algorithms. We first develop two exact algorithms: a global vertex-removal method (Global) and a local search method (Ls). Given the problem’s complexity, we then introduce two efficient approximation algorithms, Greedy and LsApp, which employ vertex prioritization strategies to find high-quality communities with significantly reduced computational cost. Comprehensive experiments on four real-world HIN datasets demonstrate the effectiveness and efficiency of our proposed algorithms.

Radius-bounded $k$-core queries (RB-$k$-core queries) in geo-social networks aim to identify all $k$-cores containing a given query vertex $q$, where all vertices in each $k$-core fall within a circle defined by a specified query radius $r$. These queries are widely used in applications such as team formation and event organization. However, specifying query parameters $k$ and $r$ can be challenging for users without domain expertise, often resulting in misaligned query results. Specifically, some expected vertices may be missing, while unexpected vertices may appear in the results. To address this issue, we investigate the problem of exploring optimal refined parameters for expected (EOPE) and unexpected (EOPU) results in RB-$k$-core queries. The goal is to explore optimal parameters that ensure the expected vertex $\omega$ (or unexpected vertex $\psi$) and query vertex $q$ appear (or do not appear) in the same RB-$k$-core. For the EOPE problem, we first propose two baseline algorithms: PriorityR and HybridR. To improve efficiency, we develop two more advanced algorithms: PriorityK and HybridK. Additionally, we introduce a novel index called HCR-Tree, based on hierarchical coreness of vertices and R-Tree, to enhance exploration efficiency. For the EOPU problem, we begin with a basic solution (BS) and then design the segmentation algorithm SA, which incorporates effective pruning and termination strategies. We conduct extensive experiments on five real-world geo-social network datasets. The results demonstrate that our proposed algorithms effectively explore optimal parameters. Among them, HybridK proves most effective for EOPE, while SA performs best for EOPU. Furthermore, HCR-Tree outperforms R-Tree for both EOPE and EOPU problems.

Approximate functional dependencies (AFDs) are essential for schema design, data integration, and data quality assessment. However, existing discovery methods often suffer from cardinality bias, producing spurious and semantically meaningless dependencies, and their exhaustive search approach limits practicality for high-dimensional or large-scale datasets. This paper presents CAFD, a Correlation-based AFD Discovery framework that identifies statistically robust AFDs in real-world scenarios. CAFD utilizes a normalized mean-square contingency coefficient to quantify dependency strength and infer directionality, distinguishing true dependencies from symmetric correlations while mitigating cardinality bias. It employs a correlation-preserving category merging strategy to reduce dimensionality without distorting inter-attribute dependencies and integrates sampling and correlation-driven pruning to efficiently minimize search space. Extensive experiments on real-world and synthetic datasets demonstrate that CAFD consistently outperforms existing methods in accuracy and scalability, particularly in noisy, high-dimensional, and large-scale contexts.

Matching complex events in out-of-order event streams has gained significant attention due to its inherent challenges. Existing methods generally fall into two main categories. One approach restores the order of out-of-order events to ensure correct matching, but this comes with high reordering costs. The other approach processes out-of-order events directly, avoiding reordering costs by adjusting the results with late-arriving events, though it cannot guarantee correctness. In this paper, we propose an efficient method that sorts only parts of the event stream while still ensuring correctness. The key observation is that sorting is necessary only for out-of-order events that could affect the complex event results. To achieve this, we use bucket sorting to organize out-of-order events into ordered event buckets and then perform the matching over these buckets. We further design a hash structure-based bucket to ensure accurate matching within each bucket. Experimental evaluations on various datasets demonstrate that our method significantly improves matching efficiency compared to existing approaches.

Complex Event Processing (CEP) is a powerful technique for detecting event patterns within event streams. Traditional CEP matching methods rely on rigid selection policies that focus on the continuity of events in queries. However, real-world applications often generate event streams with varying time granularities. In such cases, rigid selection policies tend to produce either too many redundant matches or too few meaningful matches, lacking the flexibility required for fine-tuning according to specific application needs. To address this challenge, this paper introduces a novel complex event query that integrates a parameter-driven selection policy. This policy allows users to specify a parameter for an event instance e, which constrains the maximum number of matches that e can generate. Additionally, we propose a matching algorithm that supports this parameter-driven selection policy by leveraging potential domination relationships among complex event matches. Finally, we conduct experiments on both synthetic and real-world datasets to demonstrate the effectiveness and efficiency of the proposed methods.

The advent of Single Instruction Multiple Data (SIMD) instructions in modern processors has revolutionized data processing by enabling simultaneous computation across multiple data elements. While database systems have extensively adopted SIMD for traditional operations, its potential for complex event pattern matching remains largely unexplored. This paper presents a novel approach that bridges this gap through bit-parallel processing enhanced with AVX-512 vectorization. Our approach encodes event streams into compact bit sequences, where each bit corresponds to a time slice, and an event's presence is marked by a 1-bit when its timestamp falls within the respective slice. This representation enables the formulation of bit-parallel operations that natively enforce complex event constraints, including temporal window requirements and event ordering relationships. We develop a family of bit-parallel algorithms that leverage this representation for continuous event matching, and further optimize their performance through SIMD vectorization (AVX-512 instructions) to exploit modern hardware parallelism. Experimental evaluations on both real-world and synthetic datasets demonstrate the superiority of our method, achieving at least 35.7x improvement in query efficiency compared to state-of-the-art alternatives.

Complex event processing faces significant challenges in real-world scenarios where noisy event streams containing missing events, misordered sequences, and erroneous attribute values are prevalent. Existing approaches address only specific aspects of this problem, with approximate matching techniques handling missing events and out-of-order processing methods addressing sequence misalignment, but none provide a comprehensive solution. This paper introduces K-NFA, a novel fault-tolerant automaton that systematically handles all major error types in complex event matching. Our approach features a compact automaton structure with specialized transitions for event deletion and swap operations, coupled with a dynamic matching algorithm that efficiently processes noisy streams while respecting temporal and attribute constraints. Experimental results show our method improves fault-tolerant matching capacity by 32.91

Recently, community search in directed graphs has garnered significant attention, particularly with the introduction of the D-truss, also known as the (k_c, k_f) -truss, which serves as a robust subgraph structure in directed graphs. In this structure, each edge must form cycle (flow) triangles with at least k_c ( k_f ) vertices. The goal of maximal D-truss community search is to identify the largest D-truss for a given query vertex in a directed graph. However, existing methods often lack both efficiency and effectiveness when applied to large-scale and dynamic directed graphs. To overcome these limitations, we investigate the problem of maximal triangle-connected D-truss community search (MDTCS) in dynamic directed graphs in this paper. First, we introduce the concept of triangle connectivity. Then, we explore an efficient index, named PartialTruss, which effectively captures the partial correlation of edges within a D-truss community based on triangle connectivity. Next, an effective search algorithm that utilizes the PartialTruss index is proposed. Furthermore, we propose a novel method for efficiently maintaining the index in response to dynamic updates in directed graphs. Finally, we conduct extensive experiments on real-world networks, which demonstrate that our community search method, leveraging the PartialTruss index, achieves an improvement in efficiency by 1–2 orders of magnitude compared to state-of-the-art methods.

Regular expression (regex) matching is widely used in many applications, such as code searching, entity extraction, and intrusion detection, which requires efficient matching efficiency. The traditional approaches utilize the finite state automaton to match the regex query from a text, even though they can employ some filtering strategies to avoid irrelevant characters that cannot be the matching results, there are still large numbers of contents that need to be verified by the automaton. Recent methods use the positional inverted index based on q-gram (q-length substring) to match all results for the regex query, which avoids the time-consuming automaton-based verification. However, using the fixed length of substrings (i.e., q-grams) to index the positions of the text could result in the high frequently occurred q-grams being used for the regex matching, finally limiting the matching efficiency. To this end, we employ a variable-length gram technique to boost the index-based regex matching efficiency. At first, we build the positional inverted index based on the variable-length grams so that a better balance is obtained between the number of grams and the number of gram occurrences on the text. Then, we design a data structure (VG-graph) based on variable-length grams to represent the regex query and propose the VGgraph-based matching algorithm using the variable-length-gram inverted index. Although computing the optimal VGgraph with the minimal matching cost is NP-hard, we propose a greedy algorithm to construct the VGgraph which obtains a ln n approximation to the optimal VGgraph. Extensive experiments on real-world datasets demonstrate that the variable-length gram technique can significantly improve the efficiency of index-based regex matching.

Complex event processing is crucial for temporal pattern recognition in streaming systems, especially in industrial IoT applications like equipment monitoring and safety surveillance. Traditional event-driven architectures rely on finegrained per-event matching, but high-frequency sampling (e.g., vibration sensors monitoring equipment status at 1 kHz) generates temporally-dense event sequences with state-space redundancy. This temporal correlation increases computational redundancy, particularly when handling bursty sensor data streams with varying sampling rates. To address the inherent limitations of the event-level processing paradigm, we propose ClusterCEP, a novel cluster-centric processing framework that enables cluster-aware complex event detection through two-phase processing. The first phase transforms raw event streams into density-adaptive cluster sequences, where cluster granularity is dynamically controlled based on multidimensional attribute similarity thresholds and temporal cohesion constraints. In the second phase, we extend traditional NFAs to create a cluster-driven NFA, which is then used to match clusters that potentially contain complex events. Additionally, we propose an efficient algorithm to accurately identify complex events within the detected clusters. Experimental results show that ClusterCEP improves matching efficiency by $6.39-7.32 x$ compared to methods like SASE, OpenCEP, and T-Rex on both real-world and synthetic datasets.

Recently, community search in directed graphs has received significant attention, and the D-truss model is recognized as a fundamental community structure. However, existing research has yet to thoroughly investigate the top-k query problem in directed graphs. In response, we introduces the triangle-connected top-k D-truss community search problem. First, following an in-depth analysis of the D-truss community structure, we develops the Hierarchical Equivalent Index HEI. Based on this index, we introduce an efficient triangle-connected top-k D-truss community search algorithm, Which enables the efficient retrieval of triangle-connected top-k D-truss community. Finally, we perform experiments using four real-world datasets. Experimental results indicate that, compared to state-of-the-art methods, the proposed algorithm enhances community search efficiency by one to two orders of magnitude.

With the rapid growing volume of spatial data, answering why-not questions on spatial keyword top-k queries, aiming at refining spatial keyword queries to include the missing objects in query results with minimal costs, has attracted much attention in the field of spatial databases. To alleviate the burden of local storage and computation, when service providers outsource the why-not query services to public cloud, it may raise privacy concerns. To address these issues, in this paper we first present a basic secure why-not spatial keyword top-k query (BSWoSKQ) scheme, featuring a secure weight vector generation method to obtain the best approximate refined query with minimal costs. Furthermore, to improve the query efficiency, we propose an optimized scheme named SWoSKQ that employs a new secure index structure, i.e., SSR-tree, and efficient pruning methods based on such secure index. Comprehensive analysis demonstrates the security and computational complexity of our approach, and extensive experiments on real and synthetic datasets validate the query performance of the proposed methods.

The pSCAN algorithm is widely acknowledged for its efficiency in structural graph clustering across diverse graph applications, frequently utilized to detect significant clusters within graphs. The results of pSCAN are constrained by two parameters: (1) the structural similarity constraint ϵ; (2) the density constraint μ. Nevertheless, determining appropriate values for these parameters proves challenging as users often lack the requisite professional knowledge. Consequently, users may inquire about the inclusion of unexpected vertices in specified clusters, posing why questions. In this paper, we aim to address these inquiries by investigating the challenge of answering why questions on structural graph clustering. The objective is to refine the initialized clustering parameters to exclude unexpected vertices from specified clusters. Initially, we introduce the crucial concept of label-vertices and delve into a unified explanation framework designed for addressing why questions on structural graph clustering. Subsequently, we propose two effective refining algorithms, namely FReEPS and FReMU, specifically tailored to modify the similarity constraint ϵ and the density constraint μ independently. Moreover, in our approach to enhancing efficiency, we introduce two baseline explanation algorithms, ReParFirstMUand ReParFirstEPS, simultaneously refining the parameters ϵ and μ to exclude unexpected vertices from specified clusters. Additionally, we explore two improved algorithms, FReParFirstMUand FReParFirstEPS, incorporating a process of pruning unnecessary parameter combinations and computations. This enhancement aims to improve the efficiency of simultaneously refining the two parameters for addressing these questions. Finally, we conducted comprehensive experiments on real social network datasets. The results illustrate that the explanation efficiency of FReEPS and FReMU surpasses that of the state-of-the-art explanation algorithms by 1-2 orders of magnitude. Moreover, FReMu exhibits faster performance than FReEPS. Furthermore, simultaneous refinement of the parameters ϵ and μ yields better-refined parameters. Additionally, FReParFirstMU and FReParFirstEPS outperform ReParFirstMU and ReParFirstEPS, respectively.

Continuous top- $k$ query over sliding window is a fundamental challenge in the domain of streaming data management. Specifically, a continuous top-k query $q$ monitors the window $W$ , returning the $k$ objects with the highest scores to the system with each slide of the window. This paper delves into one of its important variants, referred to as multiple continuous top. $k$ queries over data stream, which holds significant applications. While various efforts have been made to support continuous top-k query, few have addressed the complexities of multiple continuous top-k queries. The prevailing approach involves selecting a minimal number of objects in the window as candidates, incrementally maintaining them, and using them to support query processing as efficiently as possible. However, these endeavors exhibit sensitivity to the query workload scale or query parameters such as $k$ , the window length $n$ , and others. Consequently, they incur high running/space cost in updating the candidate set. In this paper, we propose a novel index PH-Tree (Partition and Heap-based Binary Tree), designed to facilitate multiple continuous top-k queries. We partition the query window into a group of disjoint partitions and use PH-Tree to organize these partitions. Additionally, the PH-Tree allows for flexible candidate selection based on the size of each partition, parameter distribution of queries and score distribution of objects. We further develop a group of efficient algorithms to support candidate set incremental maintenance and query processing. The effectiveness and efficiency of the proposed algorithms are validated through extensive theoretical analysis and exneriments detailed in this paper.

Radius-bounded $k$ -core queries (RB- $k$ -core queries) in geo-social networks aim to find all $k$ -cores containing a given query vertex $q$ while all vertices in each $k$ -core fall into a circle under a given query radius $r$ , which is widely used in many applications, such as team formulation and event organization. However, the query parameters $k$ and $r$ are hard to specify by the users without any background knowledge, which means the query results often do not meet the users' requirements, i.e., some expected vertices are missed in the query results. To tackle this issue, we investigate the problem of exploring optimal refined parameters (EOP) for expected results on RB­ $k$ -core queries, which aims to explore the optimal parameters that make the expected vertex $\omega$ and query vertex $q$ appear in the same RB- $k$ -core. To address the EOP problem, we first propose two baseline algorithms, namely PriorityR and HybridR, which refine the parameters $k$ and $r$ simultaneously based on the effective bounds of the refined $r^{\prime}$ • To enhance the efficiency of exploring optimal parameters, we develop two efficient al-gorithms. The first algorithm, Priority K, simultaneously refines both parameters based on the effective bound of the refined $k$ • The second algorithm, HybridK, explores the optimal parameters using the continuous convergence bounds of the refined $k^{\prime}$ and $r$ • Furthermore, to enhance exploration efficiency, we develop a novel index, called HCR-Tree, based on the hierarchical coreness of vertices and R- Tree. This index accelerates the verification of whether the coreness of a vertex in any sub graph exceeds $k$ in the above algorithms. Finally, we conduct extensive experiments using five real geo-social network datasets, which show that the optimal parameters can be explored effectively by the algorithms, and HybridK is the most effective. Meanwhile, the HCR- Tree performs better than the R- Tree for the EOP problem.

Community search aims to identify cohesive subgraphs containing user-given query nodes in social networks. As information technology develops, user demands for community search have become increasingly sophisticated. The searched communities must not only meet the structural cohesiveness requirements but also adhere to some complex search conditions based on Boolean expressions. For example, certain desired nodes should be contained in the communities, while certain undesired nodes cannot exist in the communities, which is called conditional community search. However, existing solutions for conditional community search often introduce some undesired nodes into the identified communities and exhibit relatively low search efficiency. To overcome these drawbacks, therefore, this paper investigates the problem of conditional community search based on weight information. First, we refine the original problem definition of conditional community search and outline the need for an improved algorithm for calculating the weights of the nodes. Then, we explore two novel algorithms for searching conditional communities based on calculated weight information. Finally, we conduct extensive experiments on several real-world datasets to verify the accuracy and efficiency of our proposed searching algorithms.

Complex event matching has gained a lot of at-tention for evaluating complex queries over event streams. The events composing a complex event occur within a user-specified time window and can be nonconsecutive on the stream. Existing methods widely utilize the state automaton to match complex events. However, the state automaton is typically used for matching consecutive items satisfying a pattern, e.g., the regular expression. To support nonconsecutive event matching, it has to maintain a large number of partial matches and skip irrelevant events, which results in a huge overhead. To avoid this problem, we employ the bit parallelism technique to match complex events continuously in this paper. We utilize a set of bit sequences to represent the events, where each bit is associated with a time slice, and an event is mapped to a 1-bit of the sequence if its timestamp belongs to the time slice. Then, bit-parallel operations are designed to process the constraints defined on the complex event, e.g., the time window limitation, and sequential order of the events, etc. We further propose the bit-parallel algorithms to support continuous complex event matching using these bit operations. Our experiments on real and synthetic datasets demonstrate that our method outperforms the existing methods by up to an order of magnitude in Query efficiency.