Database queries and constraints via lifting problems

Previous work has demonstrated that categories are useful and expressive models for databases. In the present paper we build on that model, showing that certain queries and constraints correspond to lifting problems, as found in modern approaches to algebraic topology. In our formulation, each so-called SPARQL graph pattern query corresponds to a category-theoretic lifting problem, whereby the set of solutions to the query is precisely the set of lifts. We interpret constraints within the same formalism and then investigate some basic properties of queries and constraints. In particular, to any database $\pi$ we can associate a certain derived database $\Qry(\pi)$ of queries on $\pi$. As an application, we explain how giving users access to certain parts of $\Qry(\pi)$, rather than direct access to $\pi$, improves ones ability to manage the impact of schema evolution.

💡 Research Summary

The paper builds on the well‑established categorical model of databases, in which a schema is a small category S, an instance is a functor P:S→Set (often called a “database”), and the schema‑instance relationship is the projection functor π:S→Set. The authors’ main contribution is to show that both queries and integrity constraints can be uniformly expressed as lifting problems, a concept borrowed from modern algebraic topology.

A query is modeled by a second small category Q together with a functor q:Q→S that embeds the query pattern into the schema. The answer to the query is then a functor ℓ:Q→Set such that the outer square

Q ─ℓ→ Set
│q      │π
v       v
S ─π→ Set

commutes. In other words, a lift ℓ exists exactly when the pattern described by Q can be mapped into the actual data of π, and every possible lift corresponds to a distinct solution of the query. This categorical picture matches SPARQL graph‑pattern queries: each triple pattern is a morphism in Q, and the SPARQL engine’s matching process is precisely the search for a lift.

Constraints are treated in the same framework. An existence constraint (e.g., a foreign‑key) requires that a particular lifting square must have at least one lift; a uniqueness constraint (e.g., a key) demands that at most one lift exists. Classical relational constraints such as functional dependencies, domain restrictions, and referential integrity can all be encoded as conditions on the existence or uniqueness of lifts, often reducible to categorical constructions like pushouts or pullbacks. Consequently, constraint checking becomes a problem of verifying the existence (or non‑existence) of certain lifts, opening the door to automated reasoning tools from category theory.

Beyond individual queries, the authors introduce a derived database Qry(π). For a fixed base database π, Qry(π) collects all possible query categories Q together with their lifts ℓ. Its objects are “answers to a query”, and its morphisms encode inclusion of query patterns or transformations between answers. Importantly, Qry(π) contains no raw data; it stores only the meta‑information about query results. This separation allows system designers to expose only a controlled sub‑category of Qry(π) to users, granting them access to query results without giving direct access to the underlying instance π.

The paper then explores the impact of schema evolution. When the original schema S changes (e.g., adding or removing tables, altering foreign‑key relationships), the lifts that already exist in Qry(π) may remain valid, because they are defined independently of the concrete presentation of S. By granting users access to a stable sub‑category of Qry(π) rather than to π itself, applications can continue to operate unchanged despite schema modifications. This approach improves modularity, eases versioning, and simplifies access‑control policies in large‑scale data environments.

The authors also discuss limitations and future work. While the lifting formulation is elegant, finding lifts can be computationally hard (often NP‑complete), so practical algorithms and heuristics are needed. Extending the framework to dynamic schemas, streaming data, and more expressive query languages (e.g., full SPARQL with OPTIONAL and UNION) remains an open challenge. Nonetheless, the paper demonstrates that categorical lifting provides a unifying, mathematically rigorous lens through which queries, constraints, and schema evolution can be understood and managed.