Corpus ID: 992788

Transaction Repair: Full Serializability Without Locks

  title={Transaction Repair: Full Serializability Without Locks},
  author={Todd L. Veldhuizen},
Transaction Repair is a method for lock-free, scalable transaction processing that achieves full serializability. It demonstrates parallel speedup even in inimical scenarios where all pairs of transactions have significant read-write conflicts. In the transaction repair approach, each transaction runs in complete isolation in a branch of the database; when conflicts occur, we detect and repair them. These repairs are performed efficiently in parallel, and the net effect is that of serial… Expand
Transaction Repair for Multi-Version Concurrency Control
This paper proposes a novel approach for conflict resolution in MVCC for in-memory databases that maximizes the reuse of the computations done in the initial execution round, and increases the transaction processing throughput. Expand
Program Analysis and Compilation Techniques for Speeding up Transactional Database Workloads
This thesis proposes a novel transaction repair approach for in-memory databases, and shows how to build an optimizing compiler for transaction programs using generative programming and state-of-the-art compiler technology, and presents techniques for aggressive code inlining, fusion, deforestation, and data structure specialization in the domain of relational transaction programs. Expand
LogiQL: A Declarative Language for Enterprise Applications
We give an overview of LogiQL, a declarative, Datalog based language for data management and analytics, along with techniques for efficient evaluation of LogiQL programs, emphasizing theoreticalExpand
K-Pg: Shared State in Differential Dataflows
K-Pg is a data-processing framework that provides high-throughput, low-latency incremental view maintenance for a general class of iterative data-parallel computations, which includes SQL, stratified Datalog with negation and non-monotonic aggregates, and much of graph processing. Expand
Join Processing for Graph Patterns: An Old Dog with New Tricks
It is found that classical relational databases like Postgres and MonetDB or newer graph databases/stores like Virtuoso and Neo4j may be orders of magnitude slower than these new approaches compared to a fully featured RDBMS, LogicBlox, using these new ideas. Expand
Design and Implementation of the LogicBlox System
The design considerations behind the LogicBlox system are discussed and the use of purely functional data structures; novel join processing strategies; advanced incremental maintenance and live programming facilities; and a novel concurrency control scheme are given. Expand
Version Reconciliation for Collaborative Databases
MindPalace is proposed, a prototype of a versioned database for efficient collaborative data management that formalizes the concept of auto-mergeability, a condition under which branches may be reconciled without human intervention, and proposes an efficient framework for determining whether two branches are auto-MERgeable and identifying particular records for manual reconciliation. Expand
Shared Arrangements: practical inter-query sharing for streaming dataflows
This paper implements shared arrangements in a modern stream processor and shows order-of-magnitude improvements in query response time and resource consumption for incremental, interactive queries against high-throughput streams, while also significantly improving performance in other domains including business analytics, graph processing, and program analysis. Expand


Optimistic concurrency control by melding trees
A new optimistic concurrency control algorithm for tree-structured data called meld, used in the Hyder transaction system and enables Hyder to scale out without partitioning, which can perform over 400K update transactions per second for transactions with two operations, and 130K for Transactions with eight operations. Expand
Maintaining views incrementally
A counting algorithm that tracks the number of alternative derivations (counts) for each derived tuple in a view, and shows that the count for a tuple can be computed at little or no cost above the cost of deriving the tuple. Expand
Concurrency Control in Distributed Database Systems
This paper describes a decomposition of the concurrency control problem into two major subproblems: read-write and write-write synchronization, and describes a series of synchromzation techniques for solving each subproblem and how to combine these techniques into algorithms for solving the entire conccurrency control problem. Expand
Purely functional data structures
This work describes several techniques for designing functional data structures, and numerous original data structures based on these techniques, including multiple variations of lists, queues, double-ended queues, and heaps, many supporting more exotic features such as random access or efficient catenation. Expand
Triejoin: A Simple, Worst-Case Optimal Join Algorithm
It is established that leapfrog triejoin is also worst-case optimal, up to a log factor, in the sense of NPRR. Expand
Leapfrog Triejoin: a worst-case optimal join algorithm
This paper improves on the results of NPRR by proving that leapfrog triejoin achieves worst-case optimality for finer-grained classes of database instances, such as those defined by constraints on projection cardinalities, and shows that NPRR is not best-case optimal for such classes. Expand
Principles of Transaction Processing
This book is a must for any developer who is designing a Web site that connects users to data in a distributed environment and is a definitive guide to an intriguing area of computing. Expand
On Optimistic Methods for Concurrency Control
In this paper, two families of nonlocking concurrency controls are presented and the methods used are "optimistic" in the sense that they rely mainly on transaction backup as a control mechanism, “hoping” that conflicts between transactions will not occur. Expand
Materialized views: techniques, implementations, and applications
This comprehensive volume, with a foreword by Jeff Ullman of Stanford University, will serve as a reference for students and commercial users, and encourage further use and development of materialized views. Expand
Dynamizing static algorithms, with applications to dynamic trees and history independence
A machine model for automatically dynamizing static algorithms and applying it to history-independent data structures is described and an analysis technique based on trace stability is presented. Expand