IBM at VLDB 2026

Allocating executors (i.e. compute resources) to distributed processing systems must balance resource costs of scaling-out unnecessarily against artificial, performance-limiting bottlenecks. Naive approaches may allocate executors at the application level, which have predictable costs and performance but are almost guaranteed to be sub-optimal for each of the thousands of diverse, individual stages executed by the application. Users may also have explicit preferences, such as completing an application within a specific time bud- get while minimizing cost, that existing solutions usually fail to support. We propose a novel method for determining the number of executors per stage in a serverless Apache Spark™ environment, enabling users to specify their desired cost–performance trade-off. Our approach trains tree-ensemble models to estimate the run times and costs of a stage as a function of allocated resources. These estimates are then used to recommend resources for each stage individually. We evaluate our approach on TPC-DS and SQLStorm benchmarks and compare it against two baselines. Depending on the user-defined trade-off parameter and setup, our approach achieves ∼50% cost savings across 103 TPC-DS queries with only a ∼16% slow- down, and ∼40.5% on 96 SQLStorm queries at a ∼29% slowdown.

We describe how we extended Presto to be GPU-aware. We focus on two critical challenges: efficiently moving data from storage to GPU operators, and enabling data exchange between operators without leaving GPU memory even when a query is distributed. To guide our design, we conducted a series of initial experiments in which we executed queries derived from the TPC-H benchmark on a multi-GPU cluster using NVIDIA's C++ cuDF data-frame library, and measured how different architectures and configurations influenced performance. We show how these insights inform our extensions to Presto, detailing the architectural changes required to integrate GPU execution into the existing Presto framework. Our initial evaluation demonstrates substantial cost/performance (up to 6$\times$) improvements over CPU Presto on standard analytical benchmarks. Our code is available as part of open-source Presto/Velox, and we have started to use it to run customer production workloads.

Text-to-SQL systems translate natural language questions into executable SQL queries, enabling intuitive access to structured data. While recent large language models have substantially improved generation quality, evaluating these systems remains a complex challenge: SQL semantics are subtle, multiple valid query formulations exist for the same question, and execution-based metrics are implemented inconsistently across the community. We demonstrate Text-to-SQL Evaluation Toolkit, an open-source, modular framework for rigorous evaluation of text-to-SQL systems. The toolkit provides a comprehensive suite of over twelve metrics, spanning execution accuracy, SQL syntactic equivalence, and LLM-as-judge scoring, together with integrated pipelines for inference, SQL execution against real databases, SQL profiling, and detailed error analysis. A web-based dashboard enables interactive exploration of benchmark results, cross-pipeline comparison, and per-record drill-down with live re-evaluation. The demonstration walks attendees through evaluating and comparing text-to-SQL pipelines on both established public benchmarks and new enterprise benchmarks, diagnosing failure patterns, and using LLM-as-judge to assess predictions where traditional metrics fall short.

Data Analysis is described as the process of inspecting, cleansing, transforming, and modeling data with the goal of discovering useful information, informing conclusions, and supporting decision-making. Performing such tasks over large and heterogeneous collections of tabular data, as found in enterprise data lakes and on the Web, is extremely challenging and an attractive research topic in data management, AI, and related communities. The goal of this workshop is to bring together researchers and practitioners in these diverse communities that work on addressing the fundamental research challenges of tabular data analysis and building automated solutions in this space.

We aim to provide a forum for: a) exchange of ideas between two communities: 1) an active community of data management researchers working on data integration and schema and data matching problems over tabular data, and 2) a vibrant community of researchers in AI and Semantic Web communities working on the core challenge of matching tabular data to Knowledge Graphs as a part of the ISWC SemTab Challenges. b) presentation of late-breaking results related to several emerging research areas such as table representation learning and its applications, use of large language models (LLMs) for tabular data analysis, andautomation of data science pipelines, and automation of data science pipelines that rely on tabular data. c) discussion of real-world challenges related to implementing industrial-scale tabular data anaylsis pipelines, and data lakes and data lakehouse solutions.

Discovering joinable tables in data lakes is a crucial task for systems that provide insights to users such as business analysts, data engineers, and data scientists. Due to the lack of unifying schema for such data lakes, it is typically necessary to require some level of access to the contents of tables to inspect the contents of table columns and discover joinable pairs. We introduce an alternate approach for tackling this problem, wherein we utilize only the textual metadata of tables to predict joinability. Our approach, MeGNN-Join (Metadata Graph Neural Network for Joinability Prediction), models table metadata as a knowledge graph and frames predicting table joinability as a link prediction task over the graph. MeGNN-Join’s lack of reliance on table contents allows it to perform predictions in situations where typical content-based methods cannot operate, and it utilizes semantic enrichment of missing metadata to produce more effective predictions. To validate our approach, we design an evaluation framework using real world data from open government data portals and demonstrate that MeGNN-Join shows superior performance and generalizability to new tables compared to baselines.

Universal text embedding models demonstrate that a single pre- trained model can produce representations effective across tasks such as classification, clustering, and retrieval. In contrast, existing tabular foundation models are largely task-specific. In this work, we investigate whether a single tabular embedding model can generalize effectively across tasks. We propose an initial approach that first aligns heterogeneous table-cell representations into a shared space using Hirschfeld–Gebelein–Rényi maximal correlation(HGR), enabling numerical and non-numerical cells co-occurring in the same row to be mapped consistently. We then perform message passing with All-Set Transformer modules within a Hypergraph Transformer architecture to preserve row and column permutation invariance. Both stages are trained using self-supervised objectives to learn consistent representations at multiple granularities, including the cell, row, column, and table levels. Without additional training on new datasets, the model produces table embeddings that generalize across tasks. We evaluate the approach on row similarity, column similarity, and predictive machine learning tasks, and find that it generalizes competitively compared to models specifically designed for individual tasks.

As agentic systems run longer and reason over larger evidence collections, simple context-window memory becomes insufficient. Knowledge-graph (KG) memory is a natural response, but existing KG-for-retrieval systems are difficult to compare because they vary construction assumptions, retrievers, reader models, metrics, and cost accounting. This paper studies KG construction as a \emph{structure-boundary} problem, i.e., how much structure should be materialized before retrieval, and how much reasoning should be deferred to retrieval-time traversal, embeddings, and the reader LLM?

We evaluate this question in a normalized multi-hop retrieval setting across a spectrum of construction choices: heavy event/schema-rich KG construction, lightweight entity-centric construction, prompt / model-optimized extraction, Wikidata-aligned construction, token-free graph construction, and flat compiled-wiki/context baselines. The main result is that both extremes fail in different ways. Heavy construction can spend most of the token budget on abstractions that the downstream retrieval stack does not use, while graph-free or nearly graph-free baselines lose reliable multi-hop evidence composition. In our validated setting, an entity-centric construction with prompt/model optimization improves answer quality over the full high-structure baseline while reducing construction cost by more than an order of magnitude; with a stronger reader, the same lightweight graph supports further gains.

This work's contribution is therefore not a new universal KG algorithm, but an empirical recipe for setting the structure boundary: compare against both low- and high-structure baselines, keep retrieval and reader stacks fixed when testing construction choices, report quality--cost frontiers, and require each added layer of graph structure to improve downstream utility.

Data-centric agents increasingly operate over heterogeneous environments that combine structured data with operational APIs. In such settings, retrieving the small subset of catalog entities relevant to a user query is often more challenging than executing the resulting tool calls. The DASHSys challenge exemplifies this problem through a relational knowledge graph and hundreds of REST endpoints exposed by Adobe Experience Platform and Adobe Journey Optimizer. We present a modular architecture that separates context retrieval from agent execution through a structured metadata interface. The retrieval stage combines factual catalog extraction, semantic augmentation of schemas and OpenAPI specifications, and multiple retrieval strategies ranging from deterministic lexical and embedding-based methods to hierarchical LLM-based retrieval. The execution stage consumes the retrieved context through a ReAct-style agent equipped with SQL and API tools. Our evaluation on a curated benchmark of 100 verified queries shows that semantic augmentation provides larger gains than changes to the underlying retrieval algorithm, improving dimension-table recall from 74.6% to 94.9% and bridge-table recall from 25.0% to 93.8% for BM25F retrieval. Furthermore, a lightweight OSS retrieval pipeline that combines deterministic pre-selection with a single LLM reranking step approaches the retrieval quality of a substantially more expensive hierarchical LLM retriever while reducing average input tokens by 66%. The results suggest that carefully constructed retrieval context is sufficient to recover most of the benefits of full-catalog LLM retrieval. At the same time, exact grounding of tables, columns, endpoints, and parameters remains a key challenge for reliable data-centric agents.

Agentic systems operating over heterogeneous data ecosystems face data management challenges distinct from single-turn LLM inference. When a pipeline ingests large artifacts---log streams, database query results, document corpora---into a monolithic context window, the result is unbounded, non-queryable state that is expensive to recover on failure.

We present \emph{structured state management} (SSM), a data-centric architectural pattern in which each pipeline stage reads only its declared upstream keys, every stage output is schema-validated before commit to a persistent state store, and the execution engine performs selective recovery---retrying only the failed stage over its bounded context.

We evaluate SSM on two data-intensive workloads: Kubernetes root cause analysis (84,000-record input artifact) and multi-file code debugging. Across three configurations (monolithic, static-decomposed, SSM), we find that static decomposition \emph{increases} retry cost by 80.5% over monolithic ($1{,}632 \pm 145$ vs.\ $904 \pm 17$ tokens) due to cascading re-reads of upstream state, while SSM reduces retry cost by 73.2% over static decomposition and 51.7% over monolithic ($436 \pm 132$ tokens). Schema contracts also create structured human-in-the-loop intervention points at every stage boundary.