Implementing Controlled Query Evaluation in OBDA

Abstract

In the Ontology Based Data Access (OBDA) framework, users access a relational data source by querying a domain ontology, whose classes and properties are connected to the data via declarative mappings. OBDA is adopted for data management in various sectors, notably healthcare, where confidentiality of information is a key concern that requires data to be properly protected from unauthorized accesses. Controlled Query Evaluation (CQE) is a framework for privacy-preserving query answering in the presence of an ontology. In CQE, policies are used to represent the information that should be kept confidential, and the aim is to devise from policy specifications suitable censors that enforce data protection. Therefore, it is desirable to integrate CQE in OBDA to obtain a robust privacy-aware data management framework. This has been done in the recently proposed Policy-Protected OBDA (PPOBDA) framework, which ensures the integration of CQE within OBDA by embedding policies into mappings. In this paper, we present an open-source solution that implements PPOBDA and a simplified algorithm for policy embedding, compared to previously proposed ones. This facilitates the adoption of PPOBDA using any OBDA query engine capable of translating SPARQL queries into SQL. In our implementation, we rely on Ontop, a state-of-the-art open-source OBDA tool.

Keywords

• eol>Ontology Based Data Access
• Controlled Query Evaluation
• Policy-Protected OBDA
• Privacy
• Ontop

1. Introduction

Within the Ontology-Based Data Access (OBDA) framework [ 1, 2 ], illustrated in the left part of Figure 1, an ontology encapsulates relevant domain knowledge and provides to users a vocabulary of classes and properties over which they can formulate queries. In OBDA, domain knowledge is typically expressed in OWL 2 QL, a profile (i.e., fragment) of the Web Ontology Language OWL 2, standardized by the W3C [ 3 ], while the actual data is stored in a relational source, which is linked to the ontology through declarative mappings, expressed in the R2RML mapping language [ 4 ]. Intuitively, mapping assertion specify how to populate the classes and properties of the ontology by means of data retrieved through SQL queries over the source.

Guaranteeing the privacy of information represents a challenge across all data management systems, especially in those cases where sensitive data, such as medical records, need to be manipulated. This holds in particular for OBDA, where the main objective is to eficiently and efectively answer queries posed by users over the ontology, but transferring the necessary data from the underlying data source requires suitable privacy preserving methods that prevent any unauthorized disclosure of sensitive data. Recently, Controlled Query Evaluation (CQE) has emerged as a promising privacy-preserving framework for query answering in the presence of ontologies [ 5, 6, 7 ]. In CQE, policies represent confidential information and a censor protects these policies from being violated, by suitably modifying query answers. Therefore, the inclusion of CQE within OBDA would help in improving data confidentiality, reducing risks of unauthorized data access, and ensuring compliance with regulatory privacy frameworks.

Building upon the foundational principles of CQE and of OBDA, the Policy-Protected OBDA (PPOBDA) framework was introduced in [ 8 ]. In PPOBDA, policies are denial assertions formulated as first-order logic (FOL) formulas. These policies are then integrated into mapping assertions, thus establishing new mappings that are policy-protected, i.e., they ensure that policies are not violated when answering queries over the ontology by accessing the underlying data source (cf. Fig. 1). This framework has showcased promising results, and its first implementation highlights its potential to enhance privacy preservation in the OBDA settings. However, this initial implementation of PPOBDA relied on closed-source software, specifically the Mastro system [ 9 ], as the underlying OBDA query engine, which represents a limitation towards the wide adoption of PPOBA and the experimentation with such a framework.

To address this limitation, our ongoing research implements PPOBDA using the open-source OBDA engine Ontop [ 10, 11 ], by relying on its query rewriting functionalities for realizing most of the functions needed for PPOBDA. In this paper, we present the technical challenges that we faced in the implementation process. We also propose a simplified algorithm for embedding policies into mappings, with respect to the one presented in [ 8 ].

2. Preliminaries

In this section, we present the technical preliminaries that are necessary to understand the remaining part of the paper. Specifically, we introduced Description Logics, the logical-based formalism providing the underpinning for the OWL 2 language, and present the formalization of OBDA, and the query language used to express both queries in OBDA and policies in CQE. Finally, we introduce the open-source system Ontop, on which we rely for query reformulation.

We make use of countably infinite pairwise disjoint alphabets Σ of relation names, Σ of unary and binary ontology predicates, and Σ of constants.

2.1. Description Logics

Description Logics (DLs) [ 12 ] are a family of logics widely adopted in knowledge representation and reasoning. A DL can be considered as a decidable fragment of FOL, typically restricted to unary and binary predicates, respectively called concepts and roles. Concepts denote sets of objects, while roles denote binary relationships between objects. In a DL, knowledge is represented in a knowledge base (or ontology) = ⟨ , ⟩, which consists of two components: a TBox , used to represent intensional knowledge, and an ABox , used to represent facts about individual objects. In OBDA, ontologies are typically expressed in some variant of DL-Lite, which is a family of lightweight DLs that are specifically tailored towards eficient data access. Specifically, we adopt DL-Liteℛ [ 13 ], which provides the logical underpinning for the OWL 2 QL profile of OWL 2 [ 3 ]. In DL-Liteℛ, a TBox consists of axioms of the form: 1 ⊑ 2 (concept inclusion) 1 ⊑ ¬2 (concept disjointness) 1 ⊑ 2 (role inclusion) 1 ⊑ ¬2 (role disjointness) Here and in the following, we use (possibly with a subscript) to denote either an atomic role (i.e., a role name /2 ∈ Σ ), or an inverse role − , and (possibly with a subscript) to denote either an atomic concept (i.e., a concept name /1 ∈ Σ ) or an unqualified existential restriction, which is a concept of the form ∃. An ABox is a finite set of ground atoms, comprising assertions of the form () or (, ′), where /1, /2 ∈ Σ , and , ′ ∈ Σ .

The semantics of DL-Liteℛ is given in terms of FOL interpretations, where an interpretation ℐ = ⟨∆ ℐ , · ℐ ⟩, consists of a domain ∆ ℐ , and a function · ℐ that assigns to each concept name ∈ Σ a set ℐ ⊆ ∆ ℐ of objects, to each role name ∈ Σ a binary relation ℐ ⊆ ∆ ℐ × ∆ ℐ , and to each constant ∈ Σ a domain element ℐ ∈ ∆ ℐ . We make the unique name assumption, i.e., ̸= ′ implies ℐ ̸= ′ℐ . Concept and role expressions are interpreted as follows: (− )ℐ = {(′, ) | (, ′) ∈ ℐ } ¬ℐ = ∆ ℐ ∖ ℐ (∃)ℐ = { | ∃′ ∈ ∆ ℐ s.t. (, ′) ∈ ℐ } ¬ℐ = (∆ ℐ × ∆ ℐ ) ∖ ℐ We say that ℐ satisfies a concept/role inclusion/disjointness 1 ⊑ 2, if 1ℐ ⊆ 2ℐ , and it satisfies an ABox assertion () (resp., (, ′)) if ℐ ∈ ℐ (resp., (ℐ , ′ℐ ) ∈ ℐ ). An interpretation that satisfies all axioms and assertions in (resp., , ) is called a model of (resp., , ).

2.2. Ontology Based Data Access

In OBDA, users can query a data source through an ontology TBox, which is connected to the data source via declarative mappings [ 1, 2 ]. We formalize this through the notion of OBDA specification , which is a triple = ⟨ , , ℳ⟩, where denotes a DL-Liteℛ TBox, a relational database (DB) schema over the alphabet Σ , and ℳ a mapping between and . The mapping ℳ is a finite set of mapping assertions from to , where each mapping assertion has form (⃗) ⇝ (IRI(⃗)). Here, () denotes a FOL (or SQL) source query over with answer variables ⃗. Instead, (IRI(⃗)), called the head of , is an ABox atom over the variables in ⃗ and so-called IRI-templates IRI(⃗). Each IRI-template iri(⃗) in IRI(⃗) is a term that concatenates string values and the answer variables in ⃗, and is used to construct object identifiers (i.e., IRIs) from the DB values returned by the source query (⃗). A concrete mapping language that provides such form of mappings is R2RML, standardized by the W3C [ 4 ].

Given an OBDA specification = ⟨ , , ℳ⟩ and a DB instance for , the pair = ⟨, ⟩ is called an OBDA instance. The retrieved ABox for , denoted ret( ), consists of all facts (IRI(⃗)), where (⃗) ⇝ (IRI(⃗)) is a mapping assertion in ℳ, and ⃗ ∈ eval( (⃗), ) is a tuple of constants in the evaluation of the mapping source query over . Notice that the fact (IRI(⃗)) contains IRIs of the form iri(⃗) constructed from the answer tuple ⃗ using the IRI template iri(⃗) in the mapping head. Hence, ret( ) is an ABox over constants in the set ∆ consisting of (i) all DB values in and (ii) all possible IRIs iri(⃗) constructed from some tuple ⃗ of values in and some IRI template iri(⃗) in some mapping assertion in ℳ. Then, a model of the OBDA instance is defined as a model of the knowledge base ⟨ , ret( )⟩. We denote the set of models of by Mod( ), and we say that is inconsistent if Mod( ) = ∅. Moreover, |= , indicating that entails a sentence , holds if is true in every model in Mod( ).

We make here the standard name assumption, i.e., given ⟨, ⟩, we consider interpretations over a fixed domain ∆ containing ∆ and such that all values in ∆ are interpreted as themselves. Notice that the standard name assumption implies the unique name assumption.

2.3. Queries

We consider queries, expressed as FOL formulas, over DB and OBDA instances. A query over an OBDA instance is formulated over the ontology predicates, and we are interested in the certain answers cert(, ) to , which are defined as those answers that hold over all models of , i.e., ⃗ ∈ cert(, ) if |= (⃗). A conjunctive query (CQs) has the form (⃗) = ∃⃗. 1(⃗, ⃗) ∧ · · · ∧ (⃗, ⃗), where each is a DB/ontology predicate. A Boolean CQ (BCQ) is a CQ () without answer variables, i.e., of zero arity, which returns either the empty tuple {()} (i.e., true), or the empty set ∅ (i.e., false). A ground atom (GA) is a BCQ with only one atom and no variables. CQ denotes the language of BCQs, and GA the language of GAs.

2.4. The OBDA System Ontop

We make use here of the state-of-the-art open-source OBDA system Ontop [ 10, 11 ], which implements query answering over an OBDA instance, by adopting a query transformation approach and advanced query optimization techniques. Specifically, an Ontop installation operates over an OBDA specification = ⟨ , , ℳ⟩, where is an OWL 2 QL TBox, ℳ an R2RML [ 4 ] mapping, and a relational schema with constraints. It is able to eficiently answer SPARQL queries1 [ 14 ] over the OBDA instance ⟨, ⟩, where is a DB instance for , according to the OWL 2 QL entailment regime [ 15 ]. Ontop is compliant with all relevant W3C standards, and supports all major commercial and free relational DB engines (and also several data federation tools, such as Denodo, Dremio, and Teiid, which expose a collection of heterogeneous data sources via a single relational DB schema).

Ontop implements query answering by rewriting, i.e., it computes the certain answers to SPARQL queries over the OBDA instance, by reformulating them into SQL queries expressed over , which then get executed by the underlying DB engine. To do so, Ontop first performs some of-line tasks, in which it pre-processes , , and ℳ (e.g., by saturating ℳ w.r.t. ), in 1We can consider SPARQL as a concrete syntax for CQs, although SPARQL features additional constructs not present in CQs (e.g., OPTIONAL and aggregations), and adopts a diferent semantics for existentially quantified variables. order to be then more eficient during query answering. At query answering time, it transforms a given SPARQL query into a logically equivalent (w.r.t. ) SQL query SQL and optimizes such query by taking into account mapping information and the DB constraints in .

Ontop’s toolkit encompass a Plugin for the widely adopted Protégé ontology editor, facilitating the development of OBDA specifications. Moreover, it allows for setting up a SPARQL endpoint, via a command line interface, with which users can interact by issuing queries via HTTP requests. In our work, we have used Ontop as a blackbox to exploits its query rewriting functionalities.

3. Encoding a Policy into a Mapping

To create a privacy-preserving OBDA setting, one can proceed in three ways: (i) the ontology can be modified by adjusting TBox axioms based on policy requirements [ 16 ]; (ii) the answers of queries can be modified through a censor, leading to Controlled Query Evaluation, which is an extensively explored topic [ 6, 17 ]; (iii) mappings can be modified according to policies, user authorization rights, or so that instances are anonymized. We follow here the third approach, on the one hand because of the promising outcomes demonstrated by the existing PPOBDA framework, e.g., for query evaluation over the NPD Benchmark [ 8 ], on the other hand because of the flexibility that manipulating mappings gives to introduce more privacy aspects.

To introduce formally the PPOBDA setting, we first define a denial (assertion) as a FOL sentence of the form ∀⃗. (⃗) → ⊥, such that ∃⃗. (⃗) is a BCQ. Given a set of FOL sentences (e.g., a TBox) and a denial , we have that ∪ { } is consistent if ̸|= ∃⃗. (⃗). Following [ 8 ], we define a PPOBDA specification as a 4-tuple ℰ = ⟨ , , ℳ, ⟩, such that ⟨ , , ℳ⟩ is an OBDA specification and a policy, i.e., a finite set of denials over the signature of , such that ∪ is consistent. The semantics of a PPOBDA specification coincides with that of the underlying OBDA specification, and we naturally extend to PPOBDA also all other notions (source DB , instance ⟨ℰ , ⟩, retrieved ABox ret(⟨ℰ , ⟩), and set Mod(⟨ℰ , ⟩) of models).

For a query language ℒ (e.g., CQ or GA), let ℒ( ) be the restriction of ℒ to the predicates in , and ℒ the formulas in ℒ mentioning only constants in . An optimal censor for ℰ in query language ℒ is a function cens(· ) that, for each source DB for ℰ , returns a set cens() ⊆ ℒ such that (i) ⟨⟨ , , ℳ⟩, ⟩ |= , for each ∈ cens(), and (ii) ∪ ∪ cens() is consistent. ℒ is called the censor language. We are interested in optimal censors, i.e., that return as much formulas as possible. The set of all optimal censors in ℒ for a PPOBDA specification ℰ is denoted ℒ-OptCensℰ .

To obtain a notion of censor that allows for embedding a policy into the mapping, [ 8 ] have defined censors that approximate censors for ℰ in GA, the language of ground atoms [ 7 ]. , censIGA() = ⋂︀cens∈GA-OptCensℰ cens().

Definition 1 (IGA censor [ 8 ]). Given a PPOBDA specification ℰ = ⟨ , , ℳ, ⟩, the intersection GA (IGA) censor for ℰ is the function censIGA(· ) such that, for every DB instance for ▷ Hence, an IGA censor, when applied to a DB instance for source schema of ℰ , returns the intersection of the sets of ground atoms computed by all optimal censors.

In [ 8 ], an algorithm, called PolicyEmbed is presented, that embeds a policy into a OBDA mapping ℳ and generates a new mapping ℳ′. Such mapping has the property that all answers Algorithm 1: EncodeMapping

Input: a DL-Liteℛ TBox , a mapping ℳ, a policy .

Output: a mapping ℳ0. 1 Let ′ be the expansion of the policy w.r.t. ; 2 ℳ0 ← ∅ ; 3 for each atomic concept do 4 ← addConstraints((), ′); 5 ℳ′ ← ℳ ′ ∪ {(unfold(rewrite(, ), ℳ) ⇝ ()} 6 for each atomic role do 7 ← addConstraints((, ), ′); 8 ℳ′ ← ℳ ′ ∪ {(unfold(rewrite(, ), ℳ) ⇝ (, )} 9 return ℳ′ returned to queries posed over the ontology and processed by an OBDA engine making use of ℳ’ automatically comply to according to an IGA censor. We present in Algorithm 1 EncodeMapping, a streamlined version of that algorithm that reduces the number of calls to a DL-Liteℛ query rewriting procedure. We discuss its functioning on the following example: = { Reviewer ⊑ Student , ∃ReviewsProject − ⊑ Student }, ℳ = { 1 : ∃.student(, ) ⇝ Student () 2 : student(, ’review’) ⇝ Reviewer () 3 : project(, ) ⇝ ReviewsProject (, ) } = { Reviewer () ∧ ReviewsProject (, ) ∧ Student () → ⊥ } Here, the TBox specifies that reviewer students (concept Reviewer ) are special kinds of students (concept Student ), and that projects of students are being reviewed (inverse of role ReviewsProject ). The policy says that the fact that a reviewer reviews a project of a student is a confidential information (to protect the information regarding who graded whom).

Following the definition of the IGA censor, the target is to remove the facts that belong to at least one minimal ABox such that ∪ ∪ is inconsistent. Identifying such facts is facilitated when we can analyze each denial independently. This requires that the policy exhibits the following property: for every denial in , every minimal ABox where ∪ ∪ is inconsistent must also be minimal when ∪ ∪ is inconsistent.

To achieve this, [ 8 ] introduces the concept of an extended denial, formulated as ∀. () ∧ ¬ () → ⊥, where ∃. () forms a BCQ and () is a disjunction of conjunctions of equality atoms. The extended policy is a finite set of extended denials, enabling the transformation of the initial policy into an updated policy satisfying the above mentioned property.

In Step 1, we use the perfectRef(, ) algorithm of DL-Liteℛ to expand policy with respect to [ 13 ]. The existing policy expands as follows: 1 : Reviewer () ∧ ReviewsProject (, ) ∧ Student () → ⊥ 2 : Reviewer () ∧ ReviewsProject (, ) ∧ Reviewer () → ⊥ 3 : Reviewer () ∧ ReviewsProject (, ) → ⊥ Since 3 implies 1 and 2, we discard 1 and 2 and ′ = {3}.

Then, one mapping assertion is constructed for each ontology predicate.

At Step 4, for each concept of the ontology, addConstraints((), ′) transforms () into a formula ensuring that the conditions leading to a policy violation cannot be satisfied, when retrieving data from the source through the mapping. Specifically, assume that all denials in ′ containing an atom that unifies with () are ∀, ⃗.(()∧ (, ⃗)) → ⊥, for ∈ {1, . . . , }. Then addConstraints((), ′) returns () ∧ ⋀︀1≤ ≤ ¬∃⃗. (, ⃗). Similarly, at Step 7, for each role of the ontology. For instance, assume that ′ contains the denials ∀.(() ∧ ()) → ⊥ and ∀, .(() ∧ (, ) ∧ ()) → ⊥. Then, addConstraints((), ′) returns () ∧ ¬() ∧ ¬∃.((, ) ∧ ()). For predicates that are not present in the policy ′, we do not apply the transformation, as they pose no threat to the policy. In our running example, Student () is not transformed, while addConstraints(Reviewer (), ′) = Reviewer () ∧ ¬∃.ReviewsProject (, ) addConstraints(ReviewsProject (, ), ′) = (, ) ∧ ¬Reviewer () Steps 5 and 8 invoke rewrite(, ), which rewrites each of the transformed predicates w.r.t. the TBox . Notice that might contain negated atoms, and for this step we rely on the capability of the query rewriting engine to correctly deal with SPARQL queries containing the MINUS operator. The resulting expression is then unfolded with respect to the original mapping ℳ [ 1 ], to obtain the source query of the new mapping ℳ′ for the concept or role . For this, we again rely on the OBDA engine.

In our running example, EncodeMapping( , ℳ, ) returns the following mapping ℳ′: ′1 : ∃.student(, ) ∨ student(, ’review’) ∨ ∃.project(, ) ⇝ ′2 : (,′ ′) ∧ ¬∃.project(, )) ⇝ Reviewer () ′3 : project(, ) ∧ ¬student(, ’review’) ⇝ ReviewsProject (, ) Student ()

4. Implementation in the Ontop System

To implement the EncodeMapping algorithm, we need to exploit the query answering capabilities of an OBDA engine, and specifically both query rewriting with respect to an OWL 2 QL TBox, and query unfolding with respect to R2RML mappings. The original implementation of the PPOBDA framework described in [ 8 ] relied on the Mastro system [ 9 ]. That tool is, however, a proprietary software that is not openly accessible, therefore the implementation described in [ 8 ] is not available for experimentation and for possible extensions. For this reason, we have reimplemented the PPOBDA framework from scratch, by relying on an open-source OBDA engine, and specifically on the Ontop system [ 10, 11 ]. The workflow we followed for our implementation is depicted in Fig. 2.

The initial step of expanding the policy w.r.t. the TBox relies on the query rewriting functionality. Since for optimization purposes, Ontop combines the steps of query rewriting and of unfolding w.r.t. the mapping, it requires the existence of a relational data source and of mappings even to perform only query rewriting. To address this, we have developed a Direct Mapping Generator, which simulates a data source with unary and binary relations corresponding directly to the concepts and roles names in the ontology, and establishes direct (one-to-one) mappings from this dummy DB to the ontology. The Policy Expander function exploits this setup to activate the Ontop query reformulation functionality over the denials in the policy as queries to be expanded. Given that the mappings are one-to-one, they have no impact on the outcome of the reformulation.

The rewritten queries, serving as policies expanded w.r.t. the ontology, are then provided as input to the addConstraints algorithm, which redefines each predicate as a SPARQL query. These SPARQL queries, along with the ontology, the original mapping, and the DB schema are then processed by the Policy Embed function, which converts them into SQL queries using Ontop for query reformulation. Subsequently, a new mapping is created with these SQL queries as the source parts for the respective predicates, which appear in the target part of the mapping assertions. This process efectively generates mappings that embed the policy constraints.

5. Conclusions

We have described an ongoing research efort that aims at extending the OBDA framework so as to incorporate privacy policies expressed as denials, in line with the Controlled Query Evaluation (CQE) approach. Following an approach in the literature, we have provided an initial implementation in a prototype system that builds on the open-source OBDA system Ontop. Our implementation is available as an open-source project2. We rely on our prototype implementation in our ongoing research, which aims at analyzing privacy requirements in real-world scenarios, and at assessing the adequacy of the CQE approach to capture them. We also plan to investigate how the approach we have presented for embedding policies into mappings impacts performance of query evaluation in OBDA, specifically when compared to the original approach proposed in [ 8 ].

Acknowledgments

This work has been partially supported by the Wallenberg AI, Autonomous Systems and Software Program (WASP) funded by the Knut and Alice Wallenberg Foundation, by the Province of Bolzano and DFG through the project D2G2 (DFG grant n. 500249124), and by the HEU project CyclOps (under GA n. 101135513). 2https://github.com/divyabaura/PPOBDA-with-Ontop

References

[1] A. Poggi , D. Lembo , D. Calvanese , G. De Giacomo, M. Lenzerini , R. Rosati , Linking data to ontologies , J. on Data Semantics 10 ( 2008 ). doi: 10 .1007/978-3- 540 -77688- 8 _ 5 .

[2] G. Xiao , D. Calvanese , R. Kontchakov , D. Lembo , A. Poggi , R. Rosati , M. Zakharyaschev , Ontology-based data access: A survey , in: Proc. IJCAI , IJCAI Org., 2018 , pp. 5511 - 5519 . doi: 10 .24963/ijcai. 2018 /777.

[3] B. Motik , B. Cuenca Grau , I. Horrocks , Z. Wu , A. Fokoue , C. Lutz , OWL 2 Web Ontology Language Profiles (Second Edition ), W3C Recommendation, W3C , 2012 .

[4] S. Das , S. Sundara , R. Cyganiak , R2RML: RDB to RDF Mapping Language , W3C Recommendation, W3C , 2012 . Available at http://www.w3.org/TR/r2rml/.

[5] P. A. Bonatti , L. Sauro , A confidentiality model for ontologies , in: Proc. ISWC , volume 8218 of LNCS , Springer, 2013 , pp. 17 - 32 . doi: 10 .1007/978-3- 642 -41335- 3 _ 2 .

[6] B. C. Grau , E. Kharlamov , E. V. Kostylev , D. Zheleznyakov , Controlled query evaluation for Datalog and OWL 2 Profile ontologies , in: Proc. IJCAI , AAAI Press, 2015 , pp. 2883 - 2889 .

[7] D. Lembo , R. Rosati , D. F. Savo , Revisiting controlled query evaluation in description logics , in: Proc. IJCAI , IJCAI Org., 2019 , pp. 1786 - 1792 . doi: 10 .24963/IJCAI. 2019 /247.

[8] G. Cima , D. Lembo , L. Marconi , R. Rosati , D. F. Savo , Controlled query evaluation in ontology-based data access , in: Proc. ISWC , volume 12506 of LNCS , Springer, 2020 , pp. 128 - 146 . doi: 10 .1007/978-3- 030 -62419- 4 _ 8 .

[9] D. Calvanese , G. De Giacomo, D. Lembo , M. Lenzerini , A. Poggi , M. Rodriguez-Muro , R. Rosati , M. Ruzzi , D. F. Savo , The Mastro system for ontology-based data access , Semantic Web J . 2 ( 2011 ) 43 - 53 . doi: 10 .3233/SW-2011-0029.

[10] D. Calvanese , B. Cogrel , S. Komla-Ebri , R. Kontchakov , D. Lanti , M. Rezk , M. RodriguezMuro, G. Xiao, Ontop: Answering SPARQL queries over relational databases , Semantic Web J . 8 ( 2017 ) 471 - 487 . doi: 10 .3233/SW-160217.

[11] G. Xiao , D. Lanti , R. Kontchakov , S. Komla-Ebri , E. Güzel-Kalayci , L. Ding , J. Corman , B. Cogrel , D. Calvanese , E. Botoeva, The virtual knowledge graph system Ontop , in: Proc. ISWC , volume 12507 of LNCS , Springer, 2020 , pp. 259 - 277 . doi: 10 .1007/ 978-3- 030 -62466-8_ 17 .

[12] F. Baader , D. Calvanese , D. McGuinness , D. Nardi , P. F. Patel-Schneider (Eds.), The Description Logic Handbook: Theory, Implementation and Applications , CUP, 2003 .

[13] D. Calvanese , G. De Giacomo, D. Lembo , M. Lenzerini , R. Rosati , Tractable reasoning and eficient query answering in description logics: The DL-Lite family , JAR 39 ( 2007 ) 385 - 429 . doi: 10 .1007/s10817-007-9078-x.

[14] S. Harris , A. Seaborne , SPARQL 1 . 1 Query Language , W3C Recommendation, W3C , 2013 . Available at http://www.w3.org/TR/sparql11-query.

[15] B. Glimm , C. Ogbuji , SPARQL 1 .1 Entailment Regimes, W3C Recommendation, W3C , 2013 . Available at http://www.w3.org/TR/sparql11-entailment/.

[16] F. Baader , F. Kriegel , A. Nuradiansyah , R. Peñaloza , Repairing Description Logic Ontologies by Weakening Axioms, CoRR Technical Report arXiv:1808 . 00248 , arXiv.org, 2018 .

[17] P. A. Bonatti , G. Cima , D. Lembo , L. Marconi , R. Rosati , L. Sauro , D. F. Savo , Controlled query evaluation in OWL 2 QL: A “longest honeymoon” approach , in : Proc. ISWC , volume 13489 of LNCS , Springer, 2022 , pp. 428 - 444 . doi: 10 .1007/978-3- 031 -19433-7_ 25 .