In this paper, we present a comprehensive review of the evolution of data quality awareness from traditional data management systems to modern data-driven ML systems, which are integral to data science. We synthesize the existing literature, highlighting the quality challenges and techniques that have evolved from traditional data management to data science, including Big Data and ML fields. As data science systems support a wide range of activities, our focus in this paper lies specifically in the analytics aspect driven by ML. We use the cause-and-effect connection between the quality challenges of ML and those of Big Data to allow a more thorough understanding of emerging DQ challenges and the related quality awareness techniques in data science systems. To the best of our knowledge, our paper is the first to provide a review of DQ awareness spanning traditional and emergent data science systems.
Research advancements in storage formats continuously produce more efficient encodings and better compression rates. Despite this, new formats are not adopted due to high implementation cost, and existing formats cannot evolve because they need to maintain compatibility across systems. Can this problem be solved by introducing a new abstraction? We answer affirmatively with AnyBlox, a framework for reading arbitrary datasets using lightweight WebAssembly decoders bundled with the data. By decoupling decoders from both systems and file format specifications, AnyBlox allows transparent format evolution, instance-optimized encodings, and enables mainstream adoption of research advancements. It integrates seamlessly with modern systems like DuckDB, Spark, and Umbra, while delivering solid performance and security guarantees.
ML deployments in real-world settings are often heterogeneous, spanning local multi-core CPU operations, GPU-accelerated computations, and distributed execution on platforms such as Apache Spark. This heterogeneity arises from practical necessity: a feature engineering step might run locally, a large matrix multiplication offloads to Spark when data exceeds driver memory, and DNN layers execute on GPUs. Or an initial homogeneous setup might evolve over time into a heterogeneous one. This multi-backend reality creates a systems challenge that has received surprisingly little research attention: How to holistically manage computation reuse and memory across backends with fundamentally different execution models, memory hierarchies, and caching primitives?
Differential privacy has become the de facto privacy standard, as it is widely employed by various organizations. However, only a few research works have focused on strings (e.g., [1, 2, 5]). This is surprising, given that strings are fundamental in modeling, for example, genomic sequences, mobility traces, or text logs. One of the key tasks in string database analysis is to count the occurrences of string fragments in the database: for instance, extracting frequent patterns or ??-grams, or publishing word frequency statistics. Most existing differentially private algorithms for string mining are largely heuristic and come with little or no worst-case error analysis, which is a major limitation given the fact that strings appear in key domains for decision making.
On the floors of database conferences, one can often listen to database researchers talking about the join ordering problem. However, the join ordering problem does not exist! In fact, depending on the properties of the query graph, the cardinality estimation method, the cost function, and the resulting output join tree, there exist multiple join ordering problems. For example, if the query graph is connected and acyclic, the cardinality estimator uses the independence assumption, the cost function has the ASI property, and the resulting join tree is a left-deep tree without cross products, then the problem can be solved in polynomial time [3]. The join ordering problem discussed in the paper is specified by no restriction on the query graph (it can even have no edges), no restriction on the cardinality estimation method, and for the resulting join trees can be bushy with cross products. The framework DPconv transforms the join ordering problem to some kind of subset space, solves the problem therein, and transforms the solution back; this is similar in spirit to discrete FFT. Thereby, DPconv exhibits a reduced complexity compared to traditional ones working on the same join ordering problem (such as DPsub): It is the first approach to beat the O(3n) complexity barrier.
From the moment of their inception, languages for relational data have been described as sublanguages embedded in a host programming language. Rel is a new relational language that goes beyond this paradigm, with features that allow for programming in the large, making it possible to fully describe end to end application semantics. With the new approach we can model the semantics of entire enterprise applications relationally, which helps significantly reduce architecture complexity and avoid the well-known impedance mismatch problem. This paradigm shift is enabled by 50 years of database research, making it possible to revisit the sublanguage/host language paradigm, starting from the fundamental principles. We present a gentle introduction to Rel and the principles behind its design philosophy.
For databases consisting of many text documents, one of the most fundamental data analysis tasks is counting (i) how often a pattern appears as a substring in the database (substring counting) and (ii) how many documents in the collection contain the pattern as a substring (document counting). If such a database contains sensitive data, it is crucial to protect the privacy of individuals in the database. Differential privacy is the gold standard for privacy in data analysis. It gives rigorous privacy guarantees, but comes at the cost of yielding less accurate results. In this paper, we study the problem of substring and document counting under differential privacy. We give the first differentially private data structures for these problems and provide bounds on their additive error. For & varepsilon;-differential privacy, we show that the error of our data structure is optimal up to a poly-logarithmic factor in the number of documents and length of the longest document. Our data structures immediately lead to improved algorithms for related problems, such as privately mining frequent substrings and q-grams.
The history of UDF optimization in relational databases reads as a story of increasing transparency [2]. Compilation makes UDFs faster but leaves them opaque to the optimizer. Batching and fusion amortize invocation costs but still treat UDFs as black boxes. Inlining, most notably demonstrated by Microsoft's FROID system [3], aspires to the ultimate transparency by converting UDFs entirely into SQL, hence letting the optimizer reason about their contents. The trajectory seems inevitable: the path to better performance runs through making everything visible.
One of the most celebrated results for evaluating conjunctive queries (CQs) is the Yannakakis algorithm [24] proposed in 1981. It is known that free-connex CQs can be evaluated in O(N + OUT) time, where N is the input size of the database and OUT is the output size of the query result. This is already output-optimal. However, only an upper bound O(N & centerdot; OUT) on the runtime is known for the remaining acyclic but non-freeconnex CQs. Alternatively, one can convert a non-freeconnex CQ into a free-connex one using tree decomposition techniques, and then run the Yannakakis algorithm. However, none of them is known to be output-optimal. In this work, we show a lower and upper bound matching Theta (N & centerdot; OUT1-1/fn-fhtw +OUT) for computing acyclic CQs, where fn-fhtw is the free-connex fractional hyper-tree width of the query. Although free-connex fractional hypertree width is a natural and well-established measure of how far a CQ is from being free-connex, we demonstrate that it precisely captures the output-optimal complexity of acyclic CQs. To our knowledge, this has been the first polynomial improvement over the Yannakakis algorithm in the last 40 years and completely resolves the open question of computing acyclic CQs in an output-optimal way. Our output-optimal algorithm proposed for acyclic CQs also extends to cyclic CQs, as well as CQs with aggregations over arbitrary commutative semirings.
Graph data, which are used to model relationships between objects of interest, arise in many important applications today. For example, they are used to model human relationships in social networks, links among Web pages on the Internet, transactions in financial networks, interactions among proteins, genes, and molecules in biological/chemical networks, meshes in scientific simulations, particle interactions in physical/quantum systems, relationships among galaxies in astronomical studies, communication in cyber networks, and links in geospatial data. Analyzing the structure and properties of these graphs is an important component of many data analytics pipelines.
The best asymptotic runtime that we can hope for a query evaluation algorithm is O(N + OUT), where N is the size of the input database and OUT is the size of the query's output. Indeed, any algorithm must read the input, and must write the output, hence one cannot do better asymptotically. It is not immediately obvious how to evaluate a query in this time. The standard approach taken by all query engines is to compute one join at a time, but in that case the intermediate results may become much larger than both the input and the final output. Yannakakis' algorithm from the early 80's achieves a runtime of O(N +OUT) on all full, acyclic queries, by first removing all dangling tuples from all relations using a sequence of semijoins, then performing the joins.
Modern machine learning (ML) systems leverage multiple backends, including CPUs, GPUs, and distributed execution platforms like Apache Spark or Ray. Depending on workload and cluster characteristics, these systems typically compile an ML pipeline into hybrid plans of in-memory CPU, GPU, and distributed operations. Prior work found that exploratory data science processes exhibit a high degree of redundancy, and accordingly applied tailor-made techniques for reusing intermediates in specific backend scenarios. However, achieving efficient holistic reuse in multibackend data systems remains a challenge due to its tight coupling with other aspects such as memory management, data exchange, and operator scheduling. In this paper, we introduce MEMPHIS, a principled framework for holistic, application-agnostic, multi-backend reuse and memory management. MEMPHIS's core component is a hierarchical lineage-based reuse cache, which acts as a unified abstraction and manages the reuse, recycling, exchange, and cache eviction across different backends. To address challenges of different backends such as lazy evaluation, asynchronous execution, memory allocation overheads, small available memory, and different interconnect bandwidths, we devise a suite of cache management policies. Moreover, we extend an optimizing ML system compiler by special operators and rewrites for asynchronous data exchange, workload-aware speculative cache management, and related operator ordering for concurrent execution. Our experiments across diverse ML tasks and pipelines show improvements of up to 9.6x compared to state-of-the-art ML systems.
For more than half a century, relational data management has lived in a ''two-language world'': a powerful declarative sublanguage for data (SQL) glued to a host programming language for everything else. This split into two worlds creates friction: First, there is an ''impedance mismatch'' between the set oriented query language SQL and the usually more imperative host programming language. And second, while programming languages aim for producing reusable components, SQL queries are often ad-hoc, and there is little if any reuse of logic and functionality across queries.
Modern enterprises collect, store, and analyze increasingly large volumes of data. This relentless explosion in data volumes has driven the need for more effective encoding algorithms for reducing data size. In particular, this paper looks at lossless encodings, which support perfect reconstruction of the original data via decoding. Lossless encodings are widely used in database systems because they are able to not only compress data sizes, thereby reducing the cost of storing data, but also to minimize the I/O overhead of reading data, since compressed data requires less I/O bandwidth to read from persistent storage. In modern cloud-native database systems, where data is stored durably on cloud object stores and a hot set of data is cached on a compute node's local storage, encodings also enable more data to be cached as part of the hot set.
To accelerate data access, database systems have long relied on probabilistic filters, most notably Bloom filters, to avoid unnecessary I/O. These compact structures are highly effective for point queries: they answer ''is key x present?'' with one-sided error, i.e., with false positives but not false negatives.
Although user-defined functions (UDFs) are a popular way to augment SQL's declarative approach with procedural code, the mismatch between programming paradigms creates a fundamental optimization challenge. UDF inlining automatically removes all UDF calls by replacing them with equivalent SQL subqueries. Although inlining leaves queries entirely in SQL (resulting in large performance gains), we observe that inlining the entire UDF often leads to suboptimal performance. A better approach is to analyze the UDF, deconstruct it into smaller pieces, and inline only the pieces that help query optimization. To achieve this, we propose UDF outlining, a technique to intentionally hide pieces of a UDF from the optimizer, resulting in simpler UDFs and significantly faster query plans. Our implementation (PRISM) demonstrates that UDF outlining improves performance over conventional inlining (on average 1.29× speedup for DuckDB and 298.73× for SQL Server) through a combination of more effective unnesting, improved data skipping, and by avoiding unnecessary joins.
Many graph workloads repeatedly run the same traversal or iterative computation from many different source vertices. Multi-instance execution can share work across sources and, if implemented carefully, exploit SIMD by packing per-source state into vectors. However, in vertex-centric graph processing systems, naive "vectorize everything" transformations can be wrong: a vertex may be active for only a subset of sources in a round, yet unguarded SIMD updates implicitly advance all lanes, leading to incorrect answers. We present AutoMI, a source-to-source compilation framework that automatically converts a single-instance program into a provably correct SIMD-vectorized multi-instance program runnable on existing vertex-centric engines. AutoMI uses a per-message bit-vector track to recover per-source activation and generate masked SIMD updates. It further provides a TrackFree optimization, guided by an algebraic idempotence characterization, that safely drops track and produces streamlined code when over-activation is harmless. On six real graphs (up to billions of edges) and up to 256 sources, AutoMI achieves 9.6 to 29.5 & times; speedup over parallelized serial evaluation, 7.1 to 26.4 & times; over batch processing, and 2.6 to 4.6 & times; over prior handcrafted multi-instance code.
Range filters are compact data structures that answer approximate range emptiness queries. They are used in many domains, e.g., in key-value stores, to quickly rule out the existence of keys in a given query range and avoid having to search for them in storage. However, all existing range filters exhibit at least one of the following shortcomings: (1) they do not provide robust false positive rate and performance guarantees, (2) they do not support variable-length keys and query ranges, and (3) they do not allow dynamic operations such as insertions, deletions, or expansions. We introduce Diva, the first range filter to address all the above challenges simultaneously. Diva learns the dataset's distribution by sampling keys and storing them in a cacheefficient trie. It compresses the keys in-between samples by removing their longest common prefix and truncating their suffixes while leaving enough bits in the middle (i.e., an infix) to allow differentiating between the keys in the sorted order. It stores infixes in constant-time dynamic data blocks, which it stretches and eventually splits to handle insertions and expansions. It processes a range query by traversing the trie and checking for the inclusion of at least one infix in the target query range. Diva is the culmination of several years of research on filters from Orca Lab at the University of Toronto, in collaboration with KTH and Copenhagen University. This paper describes how Diva builds on this body of work, and how it addresses the limitations of prior art.
We revisit the join ordering problem in query optimization. The standard exact algorithm, DPccp, has a worst-case running time of O(3 n ). This is prohibitively expensive for large queries, which are not that uncommon anymore. We develop a new algorithmic framework based on subset convolution. DPconv achieves a super-polynomial speedup over DPccp, breaking the O(3 n ) time-barrier for the first time. We show that the framework instantiation for the C max cost function is up to 30x faster than DPccp for large clique queries.
When I was 5 growing up in Algiers, my parents took me to the music conservatory and asked me which instrument I wanted to learn to play. I did not know the answer and I said I wanted to sign up for Ballet dancing. Since then, dancing has been central to my life. When they asked me what I wanted to do after high school, I did not know the answer and I chose computer science because I heard my Math teacher say it was the future. When my husband asked me to marry him, I literally answered ''I am hungry, let's get dinner''. Since then, dinner has been a special moment for us. I was in my mid-career transition when I moved from NYC to Barcelona to Doha and then to Grenoble. I love not knowing the answer and yet making great choices. My mid-career advice is: nurture doubt, develop intuition, and learn to make great choices. The biggest change you will experience when entering your mid-career phase is a widening of your choices. That applies to your collaborators, your academic responsibilities, the conferences you will attend, the projects you will get involved in as a leader or as a partner, the people you want to mentor, the life choices you get to make, the grants you will apply for, the topics you want to work on, the services you get to complete for your research community, and the students and collaborators you will interact with on a daily basis. Choice is a blessing and a responsibility.
