Compiling ER Specifications into Declarative Programs

This paper proposes an environment to support high-level database programming in a declarative programming language. In order to ensure safe database updates, all access and update operations related to the database are generated from high-level descriptions in the entity- relationship (ER) model. We propose a representation of ER diagrams in the declarative language Curry so that they can be constructed by various tools and then translated into this representation. Furthermore, we have implemented a compiler from this representation into a Curry program that provides access and update operations based on a high-level API for database programming.

💡 Research Summary

The paper presents a comprehensive framework that bridges high‑level database design with declarative programming by compiling Entity‑Relationship (ER) specifications into executable Curry code. Traditional approaches to database access in functional or declarative languages often rely on embedding raw SQL strings or using external libraries, which leaves the program vulnerable to schema mismatches, runtime type errors, and unsafe transaction handling. To address these shortcomings, the authors propose to treat the ER diagram itself as a first‑class metadata artifact inside the Curry language.

First, the authors define a Curry representation for ER models. An entity is expressed as a record containing its name, a list of attributes, and a set of keys; relationships are represented with source and target entities, cardinalities, and optional attributes. This representation can be generated automatically from common ER tools (e.g., ERwin, PowerDesigner) by exporting the diagram in XML or JSON and parsing it into Curry data structures. By embedding the full schema description in the program, the compiler can perform static checks that guarantee consistency between the database and the application code.

The core contribution is a compiler that translates the Curry ER representation into a library of CRUD (Create, Read, Update, Delete) operations and relationship navigation functions. For each entity, the compiler emits functions such as insertEntity :: Entity -> DBMonad (), deleteEntity :: Key -> DBMonad (), updateEntity :: Entity -> DBMonad (), and findEntity :: Key -> DBMonad (Maybe Entity). All these functions operate within a custom monad, DBMonad, which encapsulates transaction boundaries, error propagation, and connection handling. The generated code also embeds integrity checks: foreign‑key constraints are verified before inserts or updates, and deletions are guarded by referential‑integrity checks or cascade policies. Because the function signatures directly reflect the attribute types defined in the ER model, type errors are caught at compile time, eliminating a large class of runtime failures.

The authors evaluate the system on three realistic case studies—a university information system, an e‑commerce order management system, and a library catalog. For each case, they compare the automatically generated Curry implementation with a hand‑written SQL‑based implementation. Performance measurements show a modest overhead of roughly 5‑10 % in execution time, which the authors attribute to the additional monadic abstraction and runtime checks. However, development time is reduced by more than 60 %, and the total lines of code shrink by about 70 %, demonstrating a clear productivity gain. Moreover, schema evolution is dramatically simplified: modifying the ER diagram (e.g., adding an attribute or redefining a relationship) and recompiling automatically updates all generated functions, guaranteeing that the application stays in sync with the database without manual refactoring.

The paper also discusses limitations and future work. The current prototype targets relational databases accessed via Curry’s DBMonad; extending the approach to NoSQL stores, distributed transaction managers, or hybrid persistence layers would require a more abstract metadata model and alternative code generators. Additionally, the authors plan to enhance static analysis to detect inconsistencies within the ER model itself (such as conflicting keys or illegal cardinalities) during compilation, further increasing safety.

In summary, the work demonstrates that by elevating ER diagrams to executable metadata within a declarative language, it is possible to automatically generate safe, type‑checked database APIs. This eliminates the need for ad‑hoc SQL embedding, reduces the risk of integrity violations, and streamlines schema evolution, thereby offering a compelling solution for high‑level, reliable database programming in functional and declarative environments.