We propose KG-ER, a conceptual schema language for knowledge graphs that describes the structure of knowledge graphs independently of their representation (relational databases, property graphs, RDF) while helping to capture the semantics of the information stored in a knowledge graph.

We need to rethink how users understand and develop queries. The growing diversity of users, the increasing complexity of query languages and data architectures - now aided by tools like LLMs - are challenging the traditional view of a highly-trained user writing queries in a controlled environment. Query formulation has become a more exploratory endeavor that needs to be researched and supported: an iterative cycle of designing, debugging, and maintaining queries. To ground this vision, we present an empirical analysis of query logs from the Wikidata Query Service, revealing common patterns of iterative query modification. Based on these findings, we propose a concrete research program with hypotheses, user studies, and research questions for query languages, engines, and interfaces. Our contributions include a curated query session dataset, a classification of exploratory-query patterns, and a roadmap for building system-level support for exploratory querying.

In this paper, we present a brief overview of the logical foundations of conceptual modelling for relational and SQL databases. Based on the definition of a database schema within a logical framework, we formally define the notion of lossless transformations – schema transformations that preserve the information capacity of the original schema. We introduce a rigorous catalogue of the most relevant lossless transformations to enable arbitrary database restructurings without any loss of information. We observe that a conceptual schema of a database is essentially a specific type of database schema: it is a lossless variant of the database schema in sixth normal form and adheres to the basic principles of foundational ontologies – specifically, it provides a clear identification of the “kinds” of entities. Thus, every database schema has a corresponding conceptual schema that is a special lossless variant of it. This perspective allows us to characterise database design – e.g., from Entity-Relationship models – as a sequence of lossless transformations from the conceptual schema to the operational database schema. Conversely, we provide a precise characterisation of the reverse engineering process, which reconstructs a conceptual schema from an operational database schema. In doing so, we enhance and refine traditional reverse engineering approaches found in the literature. Finally, we present our implementation of a tool – the SQL Transducer – which enables querying and updating a database from any of its lossless variants, such as its conceptual schema.

The recent COVID-19 pandemic outbreak has demonstrated all the limitations of modern healthcare information systems in preventing and controlling pandemics, especially following an unexpected event. Existing approaches often fail to integrate real-time data and adaptive learning mechanisms, leading to inefficient response strategies and resource allocation challenges. To address this gap, in this paper, we propose PROTECTION, an innovative data-centric process-modeling-managing-and-mining framework for pandemic control and prevention that is based on the new paradigm that we name Knowledge-, Decision- and Data-Intensive (KDDI) processes. PROTECTION adopts Business Process Model and Notation (BPMN) as a standardized approach to model and manage complex healthcare workflows, enhancing interoperability and formal process representation. PROTECTION introduces a structured methodology that integrates Big Data Analytics, Process Mining and Adaptive Learning Mechanisms to dynamically update healthcare processes in response to evolving pandemic conditions. The framework enables real-time process optimization, predictive analytics for outbreak detection, and automated decision support for healthcare. Through case studies and experimental validation, we demonstrate how PROTECTION can effectively deal with the complex domain of pandemic control and prevention.

We consider generalizing path functional dependencies (PFDs) in Boolean complete feature logics to path description dependencies (PDDs) that now allow occurrences of inverse features. In particular, allowing such occurrences in component path descriptions of PDDs leads to a circumstance in which different notions of path agreement are now possible. We explore the cases of set intersection, set equality and non-empty set equality, studying in particular the decidability and complexity of entailment under combinations of these notions of path agreement.

Nowadays we observe an evolving landscape of data management and analytics, emphasising the significance of meticulous data management practices, semantic modelling, and bridging business-technical divides, to optimise data utilisation and enhance value from datasets in modern data environments. In this paper we introduce and explain the basic formalisation of the Semantic SQL Transducer, a well-founded but practical tool providing the materialised lossless conceptual view of an arbitrary relational source data, contributing to a knowledge-centric data stack.

All members of the FunDL family of description logics replace roles with partial functions ( features ) and have a concept constructor, called path functional dependency (PFD), for expressing extensions of functional dependencies, useful in object-relational data sources. In this paper, we consider generalizing PFDs to path description dependencies (PDD), by allowing inverse features in them, which result in paths being set-valued. We show that logical consequence for partial-𝒟ℒℱ𝒟ℐ , one of the most expressive dialects of the FunDL family, remains EXPTIME complete for coherent terminologies, when extended with PDDs. As a first application, we consider referring expression types , which are concept descriptions used to identify individuals in query answers. In the new dialect, such a type denotes a set of concept descriptions. As such, one must prove in advance that any interpretation of any member of the set will never have more than one element. We show that this “singularity condition” can be diagnosed as a collection of logical consequence questions wrt a TBox.

We show how JSON documents can be abstracted as concept descriptions in an appropriate Description Logic (DL). This representation allows the use of a DL ontology, which includes naming conventions ("referring expression types (RETs)") for instances of certain primitive concepts, in order to locate (perhaps multiple) subdocuments of the original JSON document capturing information about some particular conceptual entity. Detecting such situations allows for normalizing the JSON document into several separate smaller documents that capture all information about each such conceptual entity. This transformation preserves all the original information present in the input document. The RET assignment enables more refined and normalized capture of documents, and lead to query answers that adhere better to user expectations. We also show how RETs allow checking for a document admissibility condition ensuring that each final subdocument describes a single conceptual entity.

We show how JSON documents can be abstracted as concept descriptions in an appropriate description logic. This representation allows the use of additional background knowledge in the form of a TBox and an assignment of referring expression types (RETs) to certain primitive concepts to detect situations in which subdocuments, perhaps multiple subdocuments located in various parts of the original documents, capture information about a particular conceptual entity. Detecting such situations allows for normalizing the JSON document into several separate documents that capture all information about such conceptual entities in separate documents. This transformation preserves all the original information present in the input documents. The RET assignment contributes a set of possible concept descriptions that enable more refined and normalized capture of documents, and to more crafted answers to queries that adhere to user expectations expressed as RETs. We also show how RETs allow checking for a document admissibility condition ensuring that each document describes a single conceptual entity.

The logic of nulls in databases has been subject of investigation since their introduction in Codd's Relational Model, which is the foundation of the SQL standard. We show a logical characterisation of a first-order fragment of SQL with null values, by first focussing on a simple extension with null values of standard relational algebra, which captures exactly the SQL fragment, and then proposing two different domain relational calculi, in which the null value is a term of the language but it does not appear as an element of the semantic interpretation domain of the logics. In one calculus, a relation can be seen as a set of partial tuples, while in the other (equivalent) calculus, a relation is horizontally decomposed as a set of relations each one holding regular total tuples. We extend Codd's theorem by proving the equivalence of the relational algebra with both domain relational calculi in presence of SQL null values.

The problem of determining the relative information capacity between two knowledge bases or schemas, of the same or different models, is inherent when implementing schema transformations. When restructuring one schema into another, one expects that the schema transformation supports the complete and correct mapping of all the information contents from the source schema to the target schema. Such a characteristic is commonly referred to as information capacity preservation or schema dominance. This paper presents a formal and constructive approach to measure the relative information capacity, in the restricted case of first-order schemas related by first-order mappings. It complements the existing definitions of information capacity preservation from the perspective of model theory, showing the exact relationships among the constraints of the involved schemas, the mappings between the components of these schemas, and the database states which the schemas admit. Since satisfying some sort of schema equivalence property is essential in areas such as database conceptual design and database reverse engineering, our approach allows us to characterize the notion of normalization in database design. We review the current literature concerning database normal forms and decompositions. We also review the process of reverse engineering a database schema. In addition, we provide deeper insight into database reverse engineering methodologies, suggesting horizontal decompositions as a useful tool for facilitating the discovery of more specific objects and relationships in the conceptualization phase of the process. With the aid of simple examples, we show the essence behind our reasoning. We discuss the need for an unambiguous means through which objects in the output schema can be identified. Ultimately, the knowledge this paper ensues will be beneficial to database engineers in performing a correct schema transformation.

Object-Role Modelling (ORM) is a framework for modelling a domain using a rich set of constraints with an intuitive diagrammatic representation, not dissimilar to UML class diagrams. ORM is backed by Microsoft with Visual Studio, and it is used to support the design of large database schemas and/or complex software, easing the workflow for all stakeholders and bridging the gap among them, since every constraint of the diagram is encoded in a language which is understandable even by non-IT users. Besides the standard constraints, ORM also supports Derivation Rules that, in a way similar to UML/OCL constraints and SQL triggers, are able to express knowledge which is beyond standard graphic-based ORM capabilities. Despite ORM has its own formalisation in literature, Derivation Rules in ORM lack of this feature. The purpose of this paper is to provide a formalisation for ORM Derivation Rules in order to extend the automated reasoning on diagrams equipped with Derivation Rules. Automated reasoning is useful to check the consistency of diagrams, new inferred knowledge to validate the diagram or to avoid mistakes which could degrade the quality of the system. We provide the formalisation of Derivation Rules with a precise syntax and a semantics grounded on a precise and non-ambiguous encoding in first-order logic. Finally, we also detect an expressive decidable fragment of Derivation Rules by means of an encoding in an expressive Description Logic. A reasoner for this fragment has been implemented in a plugin for Microsoft Visual Studio.

When a knowledge base (called here schema) is restructured into another schema via some mappings, it is expected that the transformed one contains at least the same information as the original. This characteristic of the transformation is commonly referred to as information capacity preservation or schema dominance. In this paper, we complement the existing definitions of information capacity by offering a formal and constructive perspective to test schema dominance and schema equivalence, in the restricted case of first-order schemas related by first-order mappings. Satisfying some sort of schema equivalence property is essential in areas such as database conceptual design and database reverse engineering. We review, through the lens of our approach, the current literature concerning database normal forms and decompositions, and the process of reverse engineering a database schema.

The goal of this chapter is to survey the formalisation of a precise and uniform integration between first-order ontologies, first-order queries, and classical relational databases (DBoxes) We include here non-standard variants of first-order logic, such as the one with active domain semantics and standard name assumption, used typically in database theory. We present a general framework for the rewriting of a domain independent first-order query in presence of an arbitrary domain independent first-order logic ontology over a signature extending a database signature with additional predicates. The framework supports deciding the existence of a logically equivalent and – given the ontology – safe-range first-order reformulation (called exact reformulation) of a domain independent first-order query in terms of the database signature, and if such a reformulation exists, it provides an effective approach to construct the reformulation based on interpolation using standard theorem proving techniques (i.e., tableau). Since the reformulation is a safe-range formula, it is effectively executable as an SQL query. We finally present an application of the framework with the very expressive $$\mathcal {ALCHOI}$$ and $$\mathcal {SHOQ}$$ description logics ontologies, by providing effective means to compute safe-range first-order exact reformulations of queries.

We consider the notion of reification as adopted in standard conceptual modelling languages and provide a logical formalisation using description logics. To this purpose, we use the description logic DLR+, an extension of the n-ary propositionally closed description logic DLR to deal with attribute-labelled tuples (generalising the positional notation), projections of relations, and objectification/reification of relations. This paper conducts a general investigation on the expressive power required on description logics to capture the different constructs used in conceptual models with a particular emphasis on relation reification.

OCL is the standard language for defining constraints in UML class diagrams. Unfortunately, as we show in this paper, full OCL is so expressive that it is not possible to check general OCL constraints efficiently. In particular, we show that checking general OCL constraints is not only not polynomial, but not even semidecidable. To overcome this situation, we identify OCL_ , a fragment of OCL which is expressively equivalent to relational algebra (RA). By equivalent we mean that any OCL_ constraint can be checked through a RA query (which guarantees that OCL_ checking is efficient, i.e., polynomial), and any RA query encoding some constraint can be written as an OCL_ constraint (which guarantees expressiveness of OCL_ ). In this paper we define the syntax of OCL_ , we concisely determine its semantics through set theory, and we prove its equivalence to RA. Additionally, we identify the core of this language, i.e., a minimal subset of OCL_ equivalent to RA.

OCL is the standard language for defining constraints in UML class diagrams. Unfortunately, as we show in this paper, full OCL is so expressive that it is not possible to check general OCL constraints efficiently. In particular, we show that checking general OCL constraints is not only not polynomial, but not even semidecidable. To overcome this situation, we identify \(\hbox {OCL}_\textsf {FO}\), a fragment of OCL which is expressively equivalent to relational algebra (RA). By equivalent we mean that any \(\hbox {OCL}_\textsf {FO}\) constraint can be checked through a RA query (which guarantees that \(\hbox {OCL}_\textsf {FO}\) checking is efficient, i.e., polynomial), and any RA query encoding some constraint can be written as an \(\hbox {OCL}_\textsf {FO}\) constraint (which guarantees expressiveness of \(\hbox {OCL}_\textsf {FO}\)). In this paper we define the syntax of \(\hbox {OCL}_\textsf {FO}\), we concisely determine its semantics through set theory, and we prove its equivalence to RA. Additionally, we identify the core of this language, i.e., a minimal subset of \(\hbox {OCL}_\textsf {FO}\) equivalent to RA.