Abstract:This paper presents a benchmark for measuring the blocking behavior of schema transformations in relational database systems. As a basis for our benchmark, we have developed criteria for the functionality and performance of schema transformation mechanisms based on the characteristics of state of the art approaches. To address limitations of existing approaches, we assert that schema transformations must be composable while satisfying the ACID guarantees like regular database transactions. Additionally, we have identified important classes of basic and complex relational schema transformations that a schema transformation mechanism should be able to perform. Based on these transformations and our criteria, we have developed a benchmark that extends the standard TPC-C benchmark with schema transformations, which can be used to analyze the blocking behavior of schema transformations in database systems. The goal of the benchmark is not only to evaluate existing solutions for non-blocking schema transformations, but also to challenge the database community to find solutions that allow more complex transactional schema transformations.

In earlier work we have extended the TPC-C benchmark with basic and complex schema transformations. This paper uses this benchmark to investigate the blocking behaviour of online schema transformations in PostgreSQL, MySQL and Oracle 11g. First we discuss experiments using the data definition language of the DBMSs, which show that all complex operations are blocking, while we have mixed results for basic transformations. Second, we look at a technique for online schema transformations by Ronström, based on triggers. Our experiments show that pt-online-schema-change for MySQL and DBMS_REDEFINITION for Oracle can perform basic transformations without blocking, however, support for complex transformations is missing. To conclude, we provide a solution outline for complex non-blocking transformations.

No abstract

Functional languages provide new approaches to concurrency control, based on techniques such as lazy evaluation and memoization. We have designed and implemented a persistent functional language based on these ideas, which we plan to use for the implementation of a relational database system. With such a database system, we aim to show that lazy evaluation can be used to perform online schema transformations. Additionally, our persistent language allows database programs to be written as stored transactions, a mechanism similar to stored procedures. At a later stage, we want to leverage existing verification tools for the automatic verification of postconditions over these functional transactions.

Existing concurrency control systems cannot execute transactions with overlapping updates concurrently. This is especially problematic for bulk updates, which usually overlap with all concurrent transactions. To solve this, we have developed a concurrency control mechanism based on lazy evaluation, which moves evaluation of operations from the writer to the reader. This allows readers to prioritize evaluation of those operations in which they are interested, without loss of atomicity of transactions. To handle bulk operations, we dynamically split large transactions into transactions on smaller parts of the data. In this paper we present an abstract lazy index structure for lazy transactions, and show how transactions can be encoded to effectively use this data structure. Moreover, we discuss evaluation strategies for lazy transactions, where trade-offs can be made between latency and throughput. To evaluate our approach, we have implemented a concurrent lazy trie, on which we performed a number of micro benchmarks.