While Large Language Models (LLMs) are widely adopted, their massive parameter size constrains practical deployment. A common solution is clustering-based non-uniform quantization, which effectively compresses models to as low as 3 bits per weight while preserving high accuracy. However, instead of accelerating memory-bound LLM inference, the memory reduction paradoxically often causes a significant slowdown due to dequantization overhead and GPU underutilization. To address the issue, we propose Quantix, a framework designed to convert memory savings into inference speedups. Quantix applies two key optimizations: (1) a hardware-aligned bit shuffling scheme for efficient data access, and (2) a fused dequantization-multiplication pipeline that effectively maps workloads on both CUDA and Tensor Cores. Quantix enables high-throughput batched inference, delivering average kernel-level speedups of 4.82x over FP16 cuBLAS and end-to-end speedups of up to 11.46x over state-of-the-art quantization methods on NVIDIA L40 GPUs.

In network analysis, the betweenness centrality is a fundamental metric for identifying the critical intermediary nodes. Since most real-world networks carry temporal information on edges, recent studies have proposed a variety of temporal betweenness centralities (TBCs). They require chronologically increasing timestamps along paths, making them ideal for propagation scenarios such as disease spreading. However, there are also many scenarios that involve a number of discrete sub-networks called snapshots at each timestamp. Research in this domain is still rather lacking. To bridge this gap, we propose historical betweenness centrality (HBC) for temporal networks, the first centrality metric designed to identify nodes that exhibit strong intermediation capabilities persistently within a given historical period. To compute HBC, we propose a novel temporal dependency accumulation theory and develop an efficient exact algorithm based on that. Since it is still theoretically complex for large-scale snapshots, we further design a more scalable approximate algorithm with probabilistic guaranty of deviation. Extensive experiments on real-world temporal networks demonstrate that HBC is an effective and insightful measurement which is inherently different from TBC. Meanwhile, our algorithms achieve significant improvements on efficiency and scalability.

The integration of Large Language Models (LLMs) into data analytics has unlocked powerful capabilities for reasoning over bulk structured and unstructured data. However, existing systems typically rely on either DataFrame primitives, which lack the efficient execution infrastructure of modern DBMSs, or SQL User-Defined Functions (UDFs), which isolate semantic logic from the query optimizer and burden users with implementation complexities. The LLM-powered semantic operators also bring new challenges due to the high cost and non-deterministic nature of LLM invocation, where conventional optimization rules and cost models are inapplicable for their optimization. To bridge these gaps, we present Sema, a high-performance semantic query engine built on DuckDB that treats LLM-powered semantic operators as first-class citizens. Sema introduces SemaSQL, a declarative dialect that allows users seamlessly inject natural language expressions into standard SQL clauses, enabling end-to-end optimization and execution. At the logical level, the optimizer of Sema compresses natural language expressions and deduces relational constraints from semantic operators. At runtime, Sema employs Adaptive Query Execution (AQE) to dynamically reorder operators, fuse semantic operations, and apply prompt batching. This approach seeks a Pareto-optimal execution path balancing token consumption and latency under accuracy constraints. We evaluate Sema on 20 semantic queries across classification, summarization, and extraction tasks. Experimental results demonstrate that Sema achieves 2-10 × speedup against three baseline systems while achieving competitive result quality.

Continuous subgraph matching (CSM), which finds incremental matches of a query graph for each update in a dynamic graph, has gained significant research attention. Most CSM algorithms follow a common indexing-enumeration paradigm: they first use indexes to identify candidate vertices and edges for the query graph, and then enumerate matches based on these candidates. Although there have been several comprehensive experimental analyses of CSM algorithms, they tend to evaluate CSM algorithms holistically, obscuring the distinct contributions of the indexing and enumeration methods to overall performance. In this paper, we decouple the indexing method and enumeration method of existing CSM algorithms, and focus on the comparison of indexing methods. Our experimental results offer guidance on index selection across different scenarios, serving as a reference for future research and industrial applications. They further reveal the relative importance of different index components, informing strategies to discard less essential parts when memory is limited. Additionally, we show that the commonly used candidate count metric may underestimate the filtering effectiveness of certain indexes, suggesting that future research should adopt more reliable evaluation metrics.

We address the subgraph enumeration problem: given an unlabeled pattern graph p and an unlabeled data graph G , find all subgraphs in G isomorphic to p. Unlike labeled matching, the absence of label constraints creates exponentially larger search spaces with limited pruning opportunities. To address this challenge, we follow tree decomposition (TD) approaches that break complex patterns into smaller subgraphs (bags), compute matches for each bag, and join them to obtain final results. However, existing TD approaches suffer from suboptimal decomposition selection, incomplete symmetry-breaking usage, and expensive intermediate result materialization. We present MDSE (Minimal Decomposition-based Subgraph Enumeration) with three key contributions. We introduce minimal fractional hypertree decompositions (MinFHDs) that ensure compact bags and an efficient algorithm to explore all optimal-width decompositions. We develop new symmetry-breaking integration using complete rule sets with systematic selection for maximum pruning effect. To reduce materialization costs, we design MixJoin by embedding final result assembly within bag processing and formulate an enhanced cost model for attribute orders, incorporating both intersection and materialization overhead. Evaluation across 101 pattern graphs and 8 real-world datasets shows MDSE substantially outperforms existing algorithms.

Attributed community search (ACS) aims to identify subgraphs satisfying both structural cohesiveness and attribute homogeneity in attributed graphs, given a query consisting of query nodes and query attributes. Previously, algorithmic approaches deal with ACS through a two-stage paradigm, which suffers from structural inflexibility and attribute irrelevance. To overcome these limitations, learning-based approaches have recently been proposed to learn both structures and attributes simultaneously as a one-stage paradigm. However, these approaches train a transductive model that assumes the graph used for inference on unseen queries is the same as the graph used for training. That limits the generalization and adaptation of these approaches to different heterogeneous graphs. In this paper, we propose a new framework, Inductive Attributed Community Search, ^+ , based on inductive learning, which can infer new queries for different communities and graphs. Specifically, ^+ employs an encoder-decoder neural architecture to handle one ACS task at a time, where a task consists of a graph with only a few queries and their corresponding ground-truth. We design a three-phase workflow, ‘training, adaptation, inference refinement’, that learns a shared model to absorb and induce prior effective common knowledge about ACS across different tasks. The shared model can then swiftly adapt to a new task with a small number of ground-truth labels. We conduct substantial experiments on 8 real-world datasets to verify the effectiveness of ^+ . Our approach ^+ achieves average absolute improvements of 29.96% in -score for ACS tasks.

Large language models (LLMs) are increasingly used for semantic query processing over large corpora. A set of semantic operators derived from relational algebra has been proposed to provide a unified interface for expressing such queries, among which the semantic filter operator serves as a cornerstone. Given a table T with a natural language predicate e, for each tuple in the relation, the execution of a semantic filter proceeds by constructing an input prompt that combines the predicate e with its content, querying the LLM, and obtaining the binary decision. However, this tuple-by-tuple evaluation necessitates a complete linear scan of the table, incurring prohibitive latency and token costs. Although recent work has attempted to optimize semantic filtering, it still does not break the linear LLM invocation barriers. To address this, we propose Clustering-Sampling-Voting (CSV), a new framework that reduces LLM invocations to sublinear complexity while providing error guarantees. CSV embeds tuples into semantic clusters, samples a small subset for LLM evaluation, and infers cluster-level labels via two proposed voting strategies: UniVote, which aggregates labels uniformly, and SimVote, which weights votes by semantic similarity. Moreover, CSV triggers re-clustering on ambiguous clusters to ensure robustness across diverse datasets. The results conducted on real-world datasets demonstrate that CSV reduces the number of LLM calls by 1.28-355x compared to the state-of-the-art approaches, while maintaining comparable effectiveness in terms of Accuracy and F1 score.

A great number of graph analysis algorithms involve iterative computations, which dominate the runtime. Accelerating iterative graph computations has become the key to improving the performance of graph algorithms. While numerous studies have focused on reducing the runtime of each iteration to improve efficiency, the optimization of the number of iterations is often overlooked. In this work, we first establish a correlation between vertex processing order and the number of iterations, providing an opportunity to reduce the number of iterations. We propose a metric function to evaluate the effectiveness of vertex processing order in accelerating iterative computations. Leveraging this metric, we propose a novel graph reordering method, GoGraph, which constructs an efficient vertex processing order. Additionally, for evolving graphs, we further propose a metric function designed to evaluate the effectiveness of vertex processing orders in response to graph changes and provide three optional methods for dynamically adjusting the vertex processing order. Our experimental results illustrate that GoGraph surpasses current state-of-the-art reordering algorithms, improving runtime by an average of 1.83x (up to 3.34x). Compared to traditional synchronous computation methods, our approach enhances the speed of iterative computations by up to 4.46x. In dynamic scenarios, incremental GoGraph can reduce end-to-end time by 43% on average (up to 48%).

Approximate nearest neighbor (ANN) search with range filters has recently garnered significant attention. This paper delves into a generalized form of this problem, i.e., ANN search with exact range-range (RR) predicates on a range-valued attribute, named RR filtering ANN (RRANN). Specifically, given n vectors in ℝ^d, each vector v_i is associated with a numeric range [l_i, r_i], symbolizing aspects like a price range or time interval. An RRANN query (v_q, l_q, r_q) aims at finding k vectors closest to v_q within the vectors satisfying an arbitrary RR predicate defined between the query range [l_q, r_q] and the object range [l_i, r_i]. The RR predicate remains unspecified, enabling user-defined conditions. It may encompass containment ([l_i, r_i] ⊆ [l_q, r_q] or [l_q, r_q] ⊆ [l_i, r_i]), overlap (l_i ≤ l_q ≤ r_i ≤ r_q or l_q ≤ l_i ≤ r_q ≤ r_i), or a disjunction of them. RRANN has broad applications in queries related to price ranges or time intervals, and it generalizes existing variants of ANN search with range filters. However, existing dedicated approaches for these problems lack the capacity to support queries with arbitrary RR predicates. Hence, we introduce a new approach, labeled multi-segment tree graph. It efficiently handles arbitrary RR predicates by avoiding traversal through non-predicate-satisfied nodes, and keeps equivalent index size and construction time to state-of-the-art methods for RFANN. Extensive experiments on real-world data demonstrate the efficacy of our approach in RRANN queries, achieving up to 12.5x speedups with the same accuracy as the baselines. Moreover, our approach attains comparable RFANN search performance and notably superior IFANN and TSANN search performance compared to the respective state-of-the-art approaches. Our code is available at https://github.com/FanEDG/MSTG.

Betweenness centrality is one of the key centrality measures in many applications including community detections in biological networks, vulnerability detections in communication networks, misinformation filtering in social networks, etc. The top-$K$K group betweenness centrality problem is to find a group of $K$K nodes from a network so that the total fraction of shortest paths that pass through the $K$K nodes is maximized. Existing studies proposed randomized sampling algorithms for the problem. We notice that the existing studies ensured that, the maximum deviation of the estimated centrality of every group from its expectation is no greater than a small given threshold for all potential groups with no more than $K$K nodes, thereby generating too many samples, as the number of such groups is prohibitively large. In contrast, in this paper we first devise a novel algorithm that enables to estimate the centrality of a tentative group adaptively, and the algorithm immediately stops once the centrality is large enough; otherwise, the algorithm uses more samples to find a better group. We then theoretically show that, even the proposed algorithm uses much less samples, it still can find a performance-guaranteed group with high probability. Experimental results with real-world networks demonstrate that the number of samples used by the proposed algorithm is up to 36 times smaller than the state-of-the-art, while the centrality of the group found by the algorithm is no more than 4.5% smaller than the latter.

Query-driven learned estimators are accurate, flexible, and lightweight alternatives to traditional estimators in query optimization. However, existing query-driven approaches struggle with the problem of Out-of-Distribution (OOD), where the test workload distribution differs from the training workload, leading to significant performance degradation. In this paper, we present CardOOD, a modular learning framework designed to construct robust query-driven cardinality estimators that are resilient against the OOD problem. Our framework focuses on offline training algorithms that develop one-off models from a static workload, suitable for model initialization and periodic retraining. In CardOOD, we systematically adapt prevailing transfer learning and robust learning techniques, falling into three categories: representation learning, data manipulation, and new learning strategies, and instantiate them for training cardinality estimators. Beyond transferring existing techniques, we propose a novel learning algorithm, OrderEmb, tailored to the specific properties of cardinality estimation. This algorithm, lying in the category of learning strategy, exploits the partial-order constraint on query cardinalities induced by predicate containment. We provide a theoretical analysis of OrderEmb, justifying its ability to enhance representation quality by maximizing mutual information. Comprehensive experimental studies demonstrate the efficacy of the algorithms of CardOOD in mitigating the OOD problem to varying extents. We further integrate CardOOD into PostgreSQL, showcasing its practical utility in end-to-end query optimization.

Heterogeneous information networks (HINs) model typed entities and typed relations, where dense cross-type structures can reveal cohesive semantic patterns such as prolific author-paper-venue groups. Given a query meta-path, the densest P-partite subgraph search (DPpS) problem jointly selects a nonempty vertex set at each typed position and maximizes the number of induced meta-path instances normalized by the geometric mean of the selected set sizes. Existing exact methods solve DPpS by searching over iRM-sets and reducing each fixed-M problem to minimum-cut computations. However, their scalability is limited by the large number of candidate iRM-sets and the high cost of repeatedly solving large auxiliary networks. In this paper, we propose BoxDPpS, an efficient exact approach that reduces both sources of cost. It performs box-level search with safe region pruning, eliminates redundant representations of the same iRM-set, improves early pruning through bounded warm-up, and compresses each fixed-M auxiliary network for exact parametric pseudoflow solving. Experiments on seven real-world datasets show that BoxDPpS preserves the exact DPpS optimum while achieving an average speedup of 27.04x over the state-of-the-art method.

Subgraph matching is a fundamental yet NP-hard problem in graph algorithms. Modern multi-core shared-memory architectures present substantial opportunities to accelerate subgraph matching through parallelism. However, while several parallel subgraph matching algorithms have been proposed, it warrants a systematic empirical study to evaluate: (1) the interaction effect of different parallel strategies, (2) their scalability, (3) underlying performance factors, and (4) the potential for efficiently parallelizing existing sequential algorithms. In this paper, we present a comprehensive study of parallel subgraph matching by analyzing three key components: task splitting, task scheduling, and match enumeration. To investigate their interplay, we evaluate 100 feasible combinations of representative techniques for each component. We further assess scalability across varying thread counts and explore performance variations under diverse query and data graph characteristics.

To identify dense subgraphs, many specific-subgraph algorithms are developed for decomposition and maintenance on dynamic graphs. However, it suffers from two significant limitations. First, for each kind of subgraphs, it needs the development of specific maintenance algorithms, which is a costly effort. This may also lead to potentially missing solutions for an existing subgraph (e.g., k-nucleus maintenance). Second, no commonly useful properties and rules can be derived from these quite different algorithms. To address these bottlenecks, we propose a unified framework for dense subgraph maintenance over dynamic bipartite graphs. We first give a definition of (a, /3)-core as bi-core and formulate the problem of bi-core maintenance. To our best knowledge, we are the first to propose the maintenance equivalence of bi-core to other subgraphs, e.g., k-core, k-truss, bi-truss, and k-nucleus. To handle the update efficiently, we propose a novel index structure of bi-core and onion layers, which finely decomposes one (a, /3)-core into different levels of layers. This theoretically improves state-of-the-art bi-core maintenance algorithms from unbounded to bounded. However, due to two search dimensions of (a, /3)-cores w.r.t. parameters a and /3, it brings significant challenges for fast update. To tackle it, we develop a novel xBCO-index for fast maintenance by adding a shortcut search of x-direction. This reorganizes bi-core onion layers and reduces the space complexity from O(ndmax) to O(nkmax), where n is the size of vertices, and the cardinality of x-direction kmax << dmax of the maximum degree holds in practice. Our proposed maintenance algorithms can handle a batch update of multiple edge insertions/deletions simultaneously. Extensive results on large datasets demonstrate that our unified framework efficiently maintains several dense subgraphs and runs faster than state-of-the-art bi-core maintenance algorithms.

Attributed community search (ACS) aims to identify subgraphs satisfying both structural cohesiveness and attribute homogeneity in attributed graphs, given a query consisting of query nodes and query attributes. Previously, algorithmic approaches deal with ACS through a two-stage paradigm, which suffers from structural inflexibility and attribute irrelevance. To overcome these limitations, learning-based approaches have recently been proposed to learn both structures and attributes simultaneously as a one-stage paradigm. However, these approaches train a transductive model that assumes the graph used for inference on unseen queries is the same as the graph used for training. That limits the generalization and adaptation of these approaches to different heterogeneous graphs. In this paper, we propose a new framework, Inductive Attributed Community Search, IACS+\documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$ extsf{IACS}<^>{+}$$\end{document}, based on inductive learning, which can infer new queries for different communities and graphs. Specifically, IACS+\documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$ extsf{IACS}<^>{+}$$\end{document} employs an encoder-decoder neural architecture to handle one ACS task at a time, where a task consists of a graph with only a few queries and their corresponding ground-truth. We design a three-phase workflow, 'training, adaptation, inference & refinement', that learns a shared model to absorb and induce prior effective common knowledge about ACS across different tasks. The shared model can then swiftly adapt to a new task with a small number of ground-truth labels. We conduct substantial experiments on 8 real-world datasets to verify the effectiveness of IACS+\documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$ extsf{IACS}<^>{+}$$\end{document}. Our approach IACS+\documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$ extsf{IACS}<^>{+}$$\end{document} achieves average absolute improvements of 29.96%\documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$29.96\%$$\end{document} in F1\documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$ extsf{F1}$$\end{document}-score for ACS tasks.

Vector data is ubiquitous in many applications, primarily due to the advances in deep learning that enable the representation of diverse data types as vectors. A number of vector databases have been developed to support efficient vector similarity search, and they are generally categorized into two types: specialized and generalized. The latter are gaining increasing interest as they can eliminate data silos and support complex query processing for both vector and non-vector data. However, these systems, built on specific databases, must construct and access vector indices via low-level, database-specific APIs. This requires substantial engineering effort and hinders their migration to alternative databases. In this paper, for the first time, we study whether vector similarity search can be efficiently mapped into SQL, which is independent of the underlying databases and naturally portable across relational databases. We propose a general framework SQLVec, which decomposes the vector search process into a set of atomic operators to support different variants of search tasks flexibly. We map these operators to efficient SQL statements and then further optimize them on search strategies and distance computations to accelerate vector search across various scenarios. We deployed our framework SQLVec on two representative relational databases, and conducted extensive evaluation to compare it with existing vector databases extended from them. Our experimental results demonstrate the portability of SQLVec across relational databases and show that it matches or outperforms existing systems on diverse vector search variants.

Recently developed machine learning (ML) models for cardinality estimation improve the accuracy significantly, which inspires database developers to tap learned cardinality estimators into RDBMS. However, query optimization is a complicated task involving multiple factors, and accurate estimations may not necessarily procure optimal query plans. In this demonstration, we present an interactive platform that facilitates the investigation of various learned cardinality estimators and their utilities in query optimization in real RDBMS. We bridge the model zoo and the optimizer of PostgreSQL and provide a graphical interface for users to configure parameters and visualize the results interactively. In addition, our platform exposes extensible interfaces for users to deploy plug-and-play ML estimators and datasets. The demonstration video can be found on YouTube https://www.youtube.com/watch?v=ay3w7V1JhUU .

k-approximate nearest neighbor search (k-ANNS) in high-dimensional vector spaces is a fundamental problem across many fields. With the advent of vector databases and retrieval-augmented generation, k-ANNS has garnered increasing attention. Among existing methods, proximity graphs (PG) based approaches are the state-of-the-art (SOTA) methods. However, the construction parameters of PGs significantly impact their search performance. Before constructing a PG for a given dataset, it is essential to tune these parameters, which first recommends a set of promising parameters and then estimates the quality of each parameter by building the corresponding PG and then testing its k-ANNS performance. Given that the construction complexity of PGs is superlinear, building and evaluating graph indexes accounts for the primary cost of parameter tuning. Unfortunately, there is currently no method considered and optimized this process.In this paper, we introduce FastPGT, an efficient framework for tuning the PG construction parameters. FastPGT accelerates parameter estimation by building multiple PGs simultaneously, thereby reducing repeated computations. Moreover, we modify the SOTA tuning model to recommend multiple parameters at once, which can be efficiently estimated using our method of building multiple PGs simultaneously. Through extensive experiments on real-world datasets, we demonstrate that FastPGT achieves up to 2.37x speedup over the SOTA method VDTuner, without compromising tuning quality.

k -truss is one of the most widely used community models where each edge is contained in at least k -2 triangles, and Triangle-connected k -Truss Community ( k -TTC) is a strengthened variant of k -truss that further requires edges to reach each other via a series of adjacent triangles. EquiTree is the state-of-the-art tree-structured index, which is space efficient and can support time-optimal k -TTC search for query vertices. However, for large graphs with billions of edges, the sequential algorithm still needs seconds to conduct k -TTC search and hours to construct the index due to the costly triangle connectivity examination. In this paper, we study how to accelerate k -TTC search by hardware accelerators. Specifically, we propose a tensor-based framework, including index construction, online search, and index maintenance, which can be efficiently deployed and run on heterogeneous hardware. To accelerate index construction, we first propose an iterative basic algorithm which creates and refines supernodes and superedges based on each k -class layer by layer. To further boost the parallelism, we propose a triangle-based supernode and superedge creation strategy, which categorizes triangles into three types ( internal, marginal, external ), and applies tailored operations for each type to enable batch processing instead of iterative steps. Meanwhile, we propose the batch-based merging strategy to refine the index into a tree structure. We also propose tensor-based algorithms for online k -TTC search and index maintenance. Extensive experiments show that our tensor-based algorithms achieve an average speedup of two orders of magnitude over state-of-the-art methods in both index construction and community search, while efficiently maintaining indices for dynamic graphs. Moreover, we validated that our tensor-based algorithms can be smoothly deployed and run on heterogeneous hardware accelerators (NVIDIA GPUs and AMD GPUs) for acceleration.