With the advent of a new generation of database systems, the so-called multi-model database systems, a number of extensions to existing query languages are emerging to make them applicable over multiple data models, e.g. SQL/JSON, SQL/XML, or entirely new multi-model query languages are emerging, e.g. AQL. A common weakness of these languages is that they are often closely related to specific logical data model, and extending them to support multiple data models comes at the cost of increasing user complexity. The author first performs an analysis of existing query languages over multi-model data and compares its expressive power. Based on it, a novel (graphical) query language will be proposed and its prototype implementation then experimentally compared with respect to existing query languages.

Current approaches for extracting schema from data collections can generate schema that faithfully match the logical structure of the data. However, it is often the case that such schemas are unconnected, too complex, or contain repetitive structural elements. These problems are caused, for example, by redundancy in datasets, recursive data structures, or inconsistencies in attribute and entity naming across different datasets. The goal of this thesis is to design approaches that translate the automatically generated logical schema into a conceptual form. The resulting conceptual schema will be comprehensible, compact and usable by the user without losing fidelity to the original data structure. This schema simplification will be achieved through redundancy detection, resolution of inconsistencies in the data, and merging of similar or duplicate elements. Existing methods such as detecting inconsistencies in the data, schema matching based on ontologies and entity or attribute naming, or techniques for detecting recursive structures in the data can be used for this purpose.

Many datasets outlive the context in which they were created and become difficult to interpret when documentation, schema semantics, or domain assumptions are missing. The thesis proposes a phased approach for extracting metadata, integrity constraints, and business-rule candidates from unknown datasets and storing the results as a queryable metadata footprint in a graph database. A proof-of-concept implementation uses Apache Spark and Neo4j over CSV datasets while keeping the approach extensible toward multi-model data representations.

Currently, there are a number of approaches for detecting functional dependencies in relational data. These approaches are usually optimized for small data samples, which may lead to the detection of functional dependencies that are only valid on a given sample by chance. In general the set of these functional dependencies may not be valid. The goal of this thesis is to design an approach that not only detects functional dependencies in the data, but more importantly focuses on eliminating spurious functional dependencies that are only valid in a small sample of the data. A key component of the approach will be the use of so-called negative examples - data records that purposely violate the detected functional dependencies but still correspond to potentially real data. The goal is to keep the number of these negative examples as small as possible, yet eliminate spurious functional dependencies as efficiently as possible. Furthermore, interaction with domain experts (e.g., crowdsourcing) can play an important role in assessing whether the proposed negative examples correspond to real data values without accidentally disturbing the actual functional dependencies valid in the domain.

Relational and graph databases operate on fundamentally different data models, and their query languages reflect this distinction. SQL, the standard query language for relational databases, is designed to work with tabular data, while graph databases utilize specialized query languages like Cypher, Gremlin, or SPARQL to traverse and query graph structures. These graph query languages vary in their expressive power, which refers to the range of queries and operations they can perform. Migrating or synchronizing queries between relational and graph databases presents challenges due to differences in query structure, semantics, and the capabilities of these languages. Addressing these differences is essential for enabling effective cross-model query translation. The student will perform a static and experimental comparison of the expressive power of query languages from six selected graph database systems. This analysis will focus on the capabilities of each graph query language in terms of the types of operations and queries they support, comparing these to the expressive power of SQL in relational databases. Following the comparison, the student will design and propose a framework for query rewriting and migration between relational databases and a chosen graph database. This framework will ensure that queries are correctly translated, addressing any language inconsistencies by providing equivalent operations or alternative query formulations when certain features are unsupported in the target graph database system.

Current approaches for detecting functional dependencies (FDs) in relational data are primarily designed with the properties of relational data in mind. As a result, these methods tend to lack scalability, making them suitable only for processing small data samples. Moreover, they often fail to consider other data models where implicit FDs might be hidden, such as in document-oriented, columnar, or key-value data models, where dependencies may be obscured by, e.g., data embedding. The goal of this thesis is to conduct a static analysis and experimental performance evaluation of selected existing FD detection methods to assess their suitability for handling different data formats and large-scale datasets. Based on the analysis, the student will design a new approach for detecting FDs in multi-model data. This approach will focus on scalability, ensuring efficient FD detection across various popular data models, with particular emphasis on big data environments.

Modern software systems face rapidly evolving requirements that impact both their underlying data and executed queries. While automatic adaptation on the database side has received considerable attention, there is a significant gap regarding how such changes affect application code, particularly in the context of Object-Relational Mapping (ORM). The thesis introduces a unified representation and algorithms for translating ORM configurations and queries across seven .NET ORM frameworks, and an optimization advisor that evaluates translated queries and recommends a suitable framework combination using empirical performance data and integer linear programming.

The goal of this thesis is to propose a solution for universal anomaly detection in log files. This thesis first provides theoretical background and overview of related work. Se- lected approaches are then extensively evaluated on multiple data sets. Based on results of evaluation, solution prototype is proposed. This prototype consists of modules respon- sible for detecting different anomaly types. To be specific, anomalous error sequences, anomalous occurrence of log parameters and network topology change can be detected. The error sequence detector integrates selected existing approaches and parameter de- tector utilizes own method based on log parsing and parameter count vector creation. Furthermore, the network topology change detector implements novel minimum span- ning tree based algorithm. Finally, improved log parser that is able to parse logs from different systems and formats is proposed to ensure universality across systems.

NoSQL databases are becoming increasingly more popular due to their undeniable advantages in the context of storing and processing big data, mainly horizontal scalability and the lack of a requirement to define a data schema upfront. In the absence of explicit schema, however, an implicit schema inherent to the stored data still exists and can be inferred. Once inferred, a schema is of great value to the stakeholders and database maintainers. Nevertheless, the problem of schema inference is non-trivial and is still the subject of ongoing research. We explore the many aspects of NoSQL schema inference and data modeling, analyze a number of existing schema inference solutions in terms of their inner workings and capabilities, point out their shortcomings, and devise (1) a novel horizontally scalable approach based on the Apache Spark platform and (2) a new NoSQL Schema metamodel capable of modeling i.a. inter-entity referential relation- ships and deeply nested JSON constructs. We then experimentally evaluate the newly designed approach along with the preexisting solutions with respect to their functional and performance capabilities.