Categorical Query Language (CQL)

• Categorical Query Language (CQL) is a formal query language family that uses category theory to unify database querying, schema integration, and migration.
• It leverages categorical constructs such as functors, adjunctions, limits, and colimits to generalize traditional relational, graph, and hierarchical models.
• CQL enables functorial data migration with adjoint functors, providing correctness-preserving, provenance-aware schema transformations and optimized query composition.

Categorical Query Language (CQL) denotes a family of formal query languages rooted in category theory, designed to provide expressive, mathematically rigorous frameworks for database querying, schema integration, and migration. CQL appears in multiple research contexts, most notably as (1) the Categorical Query Language for functorial data integration over categorical schemas, (2) the categorical query languages of Categorical Calculus (CCalc) and Categorical Algebra (CAlg), and (3) the combinator-based, categorically interpreted query model exemplified by Rabbit. Across these frameworks, CQL leverages core category-theoretic constructs—objects, morphisms, functors, adjunctions, limits and colimits, and natural transformations—to unify disparate data models, ensure correctness-preserving data migrations, and provide a general semantics for declarative querying beyond the limits of traditional relational databases.

1. Category-Theoretic Foundations and Data Model

At the core of CQL is the categorical data model, in which a database schema is formalized as a finitely presented small category $\mathcal{C}$:

• Objects: Entity types, attributes, and relationships form the objects $\mathrm{Ob}(\mathcal{C})$.
• Morphisms: Foreign keys, relationship arrows, and attribute projections, typically restricted so that for each $X,Y\in\mathrm{Ob}(\mathcal{C})$, at most one morphism $f:X\to Y$ is present (i.e., a thin category structure).
• Composition and Identities: Standard categorical composition $\circ$ and identity morphisms satisfy associativity and unitality.

A database instance is a functor $I:\mathcal{C}\to\mathbf{Set}$, mapping objects to sets (of rows) and morphisms to functions between sets, subject to the requirement that all path equations and commutative diagrams in the schema are satisfied (Brown et al., 2019, Lu, 13 Apr 2025). Equational constraints allow encoding rich domain knowledge and invariants directly into the schema.

This model generalizes and subsumes the entity-relationship, relational, hierarchical, and graph data models by viewing all as special cases of functors over categories with suitable objects and morphisms (Lu, 13 Apr 2025).

2. Core Query Constructs: Categorical Algebra and Calculus

CQL provides two expressive query languages—Categorical Algebra (CAlg) and Categorical Calculus (CCalc):

• CAlg Syntax supports operators analogous to relational algebra but extended categorically:
  • $\mathrm{Map}_f(S)$: Apply morphism $f$ to set $S$;
  • $\mathrm{Select}_{A\,\mathrm{OM}\,B}(S)$: Selection under predicate;
  • $\mathrm{Project}_{A_1,\dots,A_k}(R)$: Projection;
  • $A\cup A$, $A\cap A$, $A-A$: Set operations;
  • $A\times B$: Cartesian product;
  • $R[A]:S[B]$: Division;
  • Categorical constructions such as $\mathrm{getParent}$, $\mathrm{getReach}$ (graph navigation), $\mathrm{Cat}$ (free category on generators), and $\mathrm{Lim}$ (limit, categorical join).
• CAlg Semantics: Each construct is evaluated as sets under the instance functor, using the image of the relevant morphisms (e.g., $$\llbracket \mathrm{Map}_f(S)\rrbracket(I) = \{I(f)(x)\mid x\in I(S)\}$$).
• CCalc Syntax generalizes first-order logic:
  • Range terms ($x\in S$), function terms ($y=f(x)$), predicate terms ($x\sim_E y$), logical connectives, quantifiers.
  • Queries use comprehensions $\{X,R\mid W\}$, selecting tuples of entities and relationships satisfying logical conditions under the instance.
• Equivalence Theorem: Every CAlg expression corresponds to a semantically equivalent CCalc formula and vice versa, enabling translation between algebraic and logical query forms (Lu, 13 Apr 2025).
• Expressivity: CAlg/CCalc strictly subsume relational algebra/calculus, XPath/XQuery twig patterns, graph pattern queries (via path and reachability predicates), and enable multi-model joins through $\mathrm{Lim}$ operations.

3. Functorial Data Migration and Integration

CQL exploits the functoriality of schemas and instances to define three adjoint data migration functors for every schema mapping $F:S\to T$:

• $\Delta_F$ (Pullback/project): $T$-instances to $S$-instances, $J\mapsto J\circ F$.
• $\Sigma_F$ (Left Pushforward/import): $S$-instances to $T$-instances, colimit-based, merges or coequalizes rows as needed.
• $\Pi_F$ (Right Pushforward/aggregate): $S$-instances to $T$-instances, limit-based, projects along $F$ and aggregates/join as required.

These functors are adjoint: $\Sigma_F\dashv\Delta_F\dashv\Pi_F$, which enables structure-preserving, correct-by-construction migrations—data migrations provably respect all path equations and invariants in both source and target schemas (Brown et al., 2019, Nagy et al., 23 Jan 2026).

Schema integration is achieved by computing categorical colimits over diagrams of mappings, yielding an amalgamated schema into which all data sources can be migrated. This approach guarantees $O(n)$ specification complexity for $n$ input schemas due to the colimit’s universal property and yields all necessary instance migrations and cross-ontology queries with no additional point-to-point mappings (Nagy et al., 23 Jan 2026).

4. Query Composition and Optimization

Query algebra supports composability—queries and data migrations are morphisms in functor categories, and their composition is guaranteed by structural induction and the associativity of categorical composition (Brown et al., 2019, Lu, 13 Apr 2025). Optimization leverages transformation rules proven to preserve denotation:

• Cascade of maps: $$\mathrm{Map}_{f_n}(\dots(\mathrm{Map}_{f_1}(S)))\cong\mathrm{Map}_{f_n\circ\cdots\circ f_1}(S)$$;
• Projection–limit adjunction: Projections of categorical joins yield original sets;
• Push-down of Select through Lim/reachability: Selects distribute over categorical joins and reachability;
• Commutation of function with limit: Maintains correct evaluation order under limiting constructions.

These rules generalize classical query optimization (predicate pushdown, join reordering) to multi-model, graph, and hierarchical queries (Lu, 13 Apr 2025).

5. Applications: Data Integration, Computational Science, and Semantic Interoperability

CQL is applied across computational science, linguistics, and building lifecycle data integration:

• Open Quantum Materials Database integration: Provenance-preserving, structure-respecting migration from OQMD to bespoke Catalysis schema uses functorial migration, full path-equation enforcement, and traces of data provenance for every record (Brown et al., 2019).
• Building ontology interoperability: Integration of IFC, BRICK, and RealEstateCore ontologies via CQL demonstrates automated generation of unified schemas and bidirectional, correct-by-construction migrations. The $O(n)$ complexity overcomes the combinatorial explosion of point-to-point mappings (Nagy et al., 23 Jan 2026).
• Corpus Query Language (CQL) for linguistics: While not fundamentally functorial, this CQL is a pattern-centric formalism with regular expression–like token constraints, scope (via XML structure), and cross-token conditions for searching linguistically annotated corpora. Recent work automates natural language to CQL query translation (Lu et al., 2024).

6. Categorical Query Languages in Context: Rabbit and Generalizations

Combinator-based Categorical Query Languages (e.g., Rabbit) interpret queries as Kleisli arrows for suitable monads (Id, Opt, Seq), leveraging the monadic composition law to uniformly handle navigation, aggregation, filtering, sorting, grouping, and context-aware queries. The categorical semantics encompass:

• Queries as morphisms $A\to MB$ in $\mathrm{Kl}(M)$;
• Combinators as higher-order natural transformations or distributive-law constructions, with pipeline syntax mapping to Kleisli composition;
• Context/parameters via comonads $W$, with bi-Kleisli algebra accommodating parameterized and window queries;
• Extensions to streams, effectful computation, and schema evolution.

These frameworks provide categorical blueprints subsuming traditional, probabilistic, time-series, and hierarchical query languages (Evans et al., 2017).

7. Expressiveness, Complexity, and Theoretical Properties

• Expressive Power: CQL strictly contains classical query languages and supports complex, multi-model patterns, graph traversals, and federated queries through categorical operators.
• Complexity: For categorical schemas with $p$ objects, $q$ morphisms, and maximum instance cardinality $n$, data complexity for fixed queries is $O(q\cdot n^p)$; space usage is $NSPACE[\log n]$ (Lu, 13 Apr 2025).
• Correctness: Functorial migration and schema composition guarantee all invariants and constraints are preserved on migration and query evaluation, with round-trip and path-independence properties in multi-ontology integration (Nagy et al., 23 Jan 2026).
• Provenance: Each migrated or queried data item can be traced to its source and transformation path (Brown et al., 2019).

---

References:

• "A Categorical Unification for Multi-Model Data: Part II Categorical Algebra and Calculus" (Lu, 13 Apr 2025)
• "Categorical Data Integration for Computational Science" (Brown et al., 2019)
• "A Categorical Approach to Semantic Interoperability across Building Lifecycle" (Nagy et al., 23 Jan 2026)
• "Query Combinators" (Evans et al., 2017)
• "From Text to CQL: Bridging Natural Language and Corpus Search Engine" (Lu et al., 2024)