We present an empirical study of relational data generation with open-weight language models under structural constraints. Using an execution-based benchmark, we evaluate 1,975 main runs across three locally runnable model backbones in the 3B–7B range, three inference modes, and two generation strategies. To assess the effect of model scale, we additionally evaluate qwen2.5:14b, the largest locally runnable model in our experimental suite, in a targeted 180-run scale probe on the hardest composite schema. In the main benchmark, generation strategy has a much larger impact than backbone choice within the evaluated 3B–7B range: topological per-table generation with an identifier catalog achieves 86.5
The data supply chain encompasses the lineage of all data products. Managing data supply chains requires tasks like introducing new data products and adjusting to evolving data contracts, i.e., processes that are complex and highly susceptible to errors when handled manually. We present our vision for a semi-automated management of data supply chains within a data mesh architecture. We therefore propose a labeled directed acyclic graph (DAG) formalization of data supply chains to foster discussions and guide future research and implementation efforts. Our approach addresses industry challenges by outlining solutions for root cause analysis, duplicate detection, and contract updates, ultimately improving the efficiency and reliability of data products.
As the educational use of large language models (LLMs) expands, excessive learner reliance on LLMs becomes a concern. To address this, we propose KMAP, a peer-learning framework in which LLM agents operate at deliberately varied knowledge levels, controlled by restricting the scope of a textbook-derived knowledge graph accessible to each agent. This design enables level-appropriate dialogues with intentional errors, encouraging learners to critically evaluate and correct agent responses rather than passively accept them. In a short-session human study with nine participants, KMAP yielded lower knowledge gains than baseline methods, but it achieved higher dialogue diversity, lower cognitive fatigue, and some higher-order cognitive processes.
Key-value databases are widely used in write-intensive workloads due to their high throughput and ability to efficiently handle large volumes of inserts. Although they provide fast key-based lookups, they perform poorly when processing queries on non-key attributes, particularly multi-attribute conjunctive queries. Secondary indexes can alleviate this limitation, but they often introduce substantial storage overhead and increased write amplification. This paper presents two Bloom filter-based indexing strategies for column-family key-value stores to address this challenge. The first approach employs a single Bloom filter tree to identify candidate keys, which are subsequently verified against additional columns. The second approach constructs separate Bloom filter trees for each column and performs a coordinated search that prunes the search space through the intersection of key ranges. Experimental results using RocksDB show that both approaches significantly reduce query execution time compared with full table scans while maintaining minimal storage overhead. The multi-column approach consistently outperforms the single-column approach, particularly for low-selectivity and partial-match queries, demonstrating the effectiveness of hierarchical Bloom filter structures for evaluating complex non-key queries in key-value stores.
Web services supply data formatted in JavaScript Object Notation (JSON). Typically only as the current snapshot of the data is represented. But JSON documents evolve over time as data is inserted, updated, or removed, and many applications needed to reason about earlier states of the data. Prior work modeled temporal JSON as a representational model in which time metadata is interleaved with JSON data, and showed how to evaluate temporal path expressions over this representational model. This paper builds on that foundation and investigates an alternative representation for temporal JSON. The new representational model is designed to improve both space and time efficiency. In the new representation, each node in the JSON tree groups its versions, timestamps, and type information, increasing the portion of the representation that is stable over time. Arrays and static subtrees are represented once and shared across many versions. We describe temporal operations, including time slice, version slice, and snapshot, over this representation. To evaluate the approach, we implemented a temporal JSON generator that constructs histories from ordinary JSON documents by applying random insertions, deletions, and modifications. Using this generator, we converted real datasets into both the original and alternative representations and measured how space usage and query time grew as additional versions were added. The experiments show that when large parts of a document remain stable, the alternative representation outperforms the original representation. Finally, we also present a path expression interface for Python that treats temporal JSON documents as first-class objects. This interface allows programmers to write temporal queries, such as retrieving a previous version, making it possible to model temporal objects in Python.
