We propose a novel approach to the view update problem for tree-structured data: a domainspecific programming language in which all expressions denote bi-directional transformations on trees. In one direction, these transformations—dubbed lenses—map a “concrete ” tree into a simplified “abstract view”; in the other, they map a modified abstract view, together with the original concrete tree, to a correspondingly modified concrete tree. Our design emphasizes both robustness and ease of use, guaranteeing strong well-behavedness and totality properties for welltyped lenses. We identify a natural mathematical space of well-behaved bi-directional transformations over arbitrary structures, study definedness and continuity in this setting, and state a precise connection with the classical theory of “update translation under a constant complement ” from databases. We then instantiate this semantic framework in the form of a collection of lens combinators that can be assembled to describe transformations on trees. These combinators include familiar constructs from functional programming (composition, mapping, projection, conditionals, recursion) together with some novel primitives for manipulating trees (splitting, pruning, copying, merging, etc.). We illustrate the expressiveness of these combinators by developing a number of bi-directional listprocessing transformations as derived forms. An extended example shows how our combinators can be used to define a lens that translates between a native HTML representation of browser bookmarks and a generic abstract bookmark format.

We propose a novel approach to the classical view update problem. The view update problem arises from the fact that modifications to a database view may not correspond uniquely to modifications on the underlying database; we need a means of determining an “update policy ” that guides how view updates are reflected in the database. Our approach is to define a bi-directional query language, in which every expression can be read both (from left to right) as a view definition and (from right to left) as an update policy. The primitives of this language are based on standard relational operators. Its type system, which includes recordlevel predicates and functional dependencies, plays a crucial role in guaranteeing that update policies are well-behaved, in a precise sense, and that they are total—i.e., able to handle arbitrary changes to the view.

This paper presents a novel editor supporting interactive refinement in the development of structured documents. The user performs a sequence of editing operations on the document view, and the editor automatically derives an efficient and reliable document source and a transformation that produces the document view. The editor is unique in its programmability, in the sense that transformation can be obtained through editing operations. The main tricks behind are the utilization of the view-updating technique developed in the database community, and a new bidirectional transformation language that cannot only describe the relationship between the document source and its view, but also data dependency in the view.

A closed view of a database schema is one which is totally encapsulated. Insofar as the user is concerned, the view is the database schema. The rest of the database system is not visible through the view, and is is not required for complete use of the view. Similarly, the updates which may be effected through the view have their scope limited entirely to that view. In this paper, we lay the mathematical foundations for the systematic support of such views. The proper context is shown to be that of update translation under constant meet complement, a refinement of the constant complement strategy of Bancilhon and Spyratos. The central complexity result for relational schemata is that checking the legality of updates is “infinitely ” simpler than blindly checking that the new state is legal for the view schema, and in the particular case that the base schema is constrained by functional dependencies, may always be performed in constant time, even if the view schema is not finitely axiomatizable. We further establish that, under very natural assumptions, update strategies for closed views are unique.

Object-oriented databases are said to support evolution and incremental development. On the schema level, a firm restriction in this evolution is that it can only be done by evolving class hierarchies downwards by subclassing. We show a unified approach to class evolution in object-oriented databases, where class hierarchies are allowed to grow in all directions, covering for evolution situations like generalisation, specialisation, and class versioning. We show how to make the evolution transparent, allowing existing and new clients to coexist and be clients of the same (existing and new) objects. A design of this approach based on object-oriented database views is shown. 1 Introduction In most database applications there is a need for letting the schema evolve. There are several reasons for this. There may be design flaws that are not discovered before (some of the) applications are implemented and the database is populated. The domain being modelled is evolving, new applications ha...

We argue that, despite a substantial number of proposed and existing new database systems, a suitable database system for software development environments and especially process-centred environments does not yet exist. We do so by reviewing and refining the requirements for such systems in detail based on a number of examples. We then sketch a number of available and archetypical database systems and indicate why they do not meet these requirements. 1 This report has been published in: I. Sommerville and M. Paul, editors, Software Engineering ESEC '93 --- Proc. of the 4 th European Software Engineering Conference, Garmisch Partenkirchen, Germany, volume 717 of Lecture Notes in Computer Science, pages 145--162, Springer 1993. 1 Introduction Software development environments (SDEs) include tools which support most of the software life-cycle phases, i.e. construction and analysis of the corresponding documents and document interdependencies. Sophisticated integrated environments en...

Translating data and data access operations between applications and databases is a longstanding data management problem. We present a novel approach to this problem, in which the relationship between the application data and the persistent storage is specified using a declarative mapping, which is compiled into bidirectional views that drive the data transformation engine. Expressing the application model as a view on the database is used to answer queries, while viewing the database in terms of the application model allows us to leverage view maintenance algorithms for update translation. This approach has been implemented in a commercial product. It enables developers to interact with a relational database via a conceptual schema and an object-oriented programming surface. We outline the implemented system and focus on the challenges of mapping compilation, which include rewriting queries under constraints and supporting non-relational constructs. Categories and Subject Descriptors: H.2 [Database Management], D.3 [Programming Languages]

In many occasions would one encounter the task of maintaining the consistency of two pieces of structured data that are related by some transform --- synchronising bookmarks in di#erent web browsers, the source and the view in an editor, or views in databases, to name a few. This paper proposes a formal model of such tasks, basing on a programming language allowing injective functions only. The programmer designs the transformation as if she is writing a functional program, while the synchronisation behaviour is automatically derived by algebraic reasoning. The main advantage is being able to deal with duplication and structural changes. The result will be integrated to our structure XML editor in the Programmable Structured Document project.

The fundamental problem in the design of update strategies for views of database schemata is that of selecting how the view update is to be reflected back to the base schema. This work presents a solution to this problem, based upon the dual philosophies of closed update strategies and order-based database mappings. A closed update strategy is one in which the entire set of updates exhibit natural closure properties, including transitivity and reversibility. The order-based paradigm is a natural one; most database formalisms endow the database states with a natural order structure, under which update by insertion is an increasing operation, and update by deletion is decreasing. Upon augmenting the original constant-complement strategy of Bancilhon and Spyratos – which is an early version of a closed update strategy – with compatible order-based notions, the reflection to the base schema of any update to the view schema which is an insertion, a deletion, or a modification which is realizable as a sequence of insertions and deletions is shown to be unique and independent of the choice of complement. In addition to this uniqueness characterization, the paper also develops a theory which identifies conditions under which a natural, maximal, update strategy exists for a view. This theory is then applied to a ubiquitous example – single-relational schemata constrained by equality-generating dependencies. Within this framework it is shown that for a view defined as a projection of the main relation, the only possibility is that the complement defining the update process is also a projection, and that the reconstruction is based upon functional dependencies. † A preliminary version of parts of this paper appeared as reference [16]. 1 1.

Bidirectional transformation is a pair of transformations: a view function and a backward transformation. A view function maps one data structure called source onto another called view. The corresponding backward transformation reflects changes in the view to the source. Its practically useful applications include replicated data synchronization, presentation-oriented editor development, tracing software development, and view updating in the database community. However, developing a bidirectional transformation is hard, because one has to give two mappings that satisfy the bidirectional properties for system consistency. In this paper, we propose a new framework for bidirectionalization that can automatically generate a useful backward transformation from a view function while guaranteeing that the two transformations satisfy the bidirectional properties. Our framework is based on two known approaches to bidirectionalization, namely the