Search

Theoretical models used in database research often have subtle differences with those occurring in practice. One particular mismatch that is usually neglected concerns the use of marked nulls to represent missing values in theoretical models of incompleteness, while in an SQL database these are all denoted by the same syntactic object. It is commonly argued that results obtained in the model with marked nulls carry over to SQL, because SQL nulls can be interpreted as Codd nulls , which are simply marked nulls that do not repeat. This argument, however, does not take into account that even simple queries may produce answers where distinct occurrences of do in fact denote the same unknown value. For such queries, interpreting SQL nulls as Codd nulls would incorrectly change the semantics of query answers. To use results about Codd nulls for real-life SQL queries, we need to understand which queries preserve the Codd interpretation of SQL nulls. We show, however, that the class of relational algebra queries preserving Codd interpretation is not recursively enumerable, which necessitates looking for sufficient conditions for such preservation. Those can be obtained by exploiting the information provided by NOT NULL constraints on the database schema. We devise mild syntactic restrictions on queries that guarantee preservation, do not limit the full expressiveness of queries on databases without nulls, and can be checked efficiently. • SQL nulls are commonly interpreted as non-repeating marked nulls, but even simple queries may produce answers that break this interpretation. • The class of queries preserving the Codd interpretation of SQL nulls cannot be captured syntactically. • Sufficient syntactic restrictions for preservation can be obtained by leveraging NOT NULL constraints on the database schema. [ABSTRACT FROM AUTHOR]

Abstract In Relational Algebra, the operator Division (÷) is an intuitive tool used to write queries with the concept of "for all", and thus, it is constantly required in real applications. However, as we demonstrate here, the division does not support many of the needs common to modern applications, particularly those that involve complex data analysis, such as processing images, audio, genetic data, large graphs, fingerprints, and many other "non-traditional" data types. The main issue is the existence of intrinsic comparisons of attribute values in the operator, which, by definition, are always performed by identity (=), despite the fact that complex data must be compared by similarity. Recent works focus on supporting similarity comparison in relational operators, but no one treats the division. This paper presents the new Similarity-aware Division (÷ ˆ) operator. Our novel operator is naturally well suited to answer queries with an idea of "candidate elements and exigencies" to be performed on complex data from modern applications. For example, it is potentially useful to support agriculture, genetic analyses, digital library search, prospective client identification, and even to help controlling the quality of manufactured products in industry. We validate our proposals by studying the first two of these applications. Highlights • The relational division database operator is not suited for complex data analysis. • A novel similarity-aware division operator is proposed to process complex data. • The similarity-aware division is formally defined. • Fast and scalable algorithms for the similarity-aware division are presented. • The new division operator is validated in case studies in Agriculture and Genetics. [ABSTRACT FROM AUTHOR]

While all relational database systems are based on the bag data model, much of theoretical research still views relations as sets. Recent attempts to provide theoretical foundations for modern data management problems under the bag semantics concentrated on applications that need to deal with incomplete relations, i.e., relations populated by constants and nulls. Our goal is to provide a complete characterization of the complexity of query answering over such relations in fragments of bag relational algebra. The main challenges that we face are twofold. First, bag relational algebra has more operations than its set analog (e.g., additive union, max-union, min-intersection, duplicate elimination) and the relationship between various fragments is not fully known. Thus we first fill this gap. Second, we look at query answering over incomplete data, which again is more complex than in the set case: rather than certainty and possibility of answers, we now have numerical information about occurrences of tuples. We then fully classify the complexity of finding this information in all the fragments of bag relational algebra. • Database systems are based on bags, but theoretical research focuses on sets • Classification of relative expressive power of bag relational algebra fragments • Complexity of computing certain and possible answers in those fragments. [ABSTRACT FROM AUTHOR]

Modern data-intensive applications have to manage huge quantities of streaming/relational data and need advanced query capabilities involving combinations of continuous queries (CQs) and one-time queries (OTQs) also requiring the verification of complex temporal conditions. In this paper, we go beyond the disjointed panorama of current approaches and adopt a new holistic approach to the integration of stream processing capabilities into the temporal database world based on the streaming table concept. To this end, we propose a full-fledged query interface composed of a TSQL2-like query language with an underlying algebraic framework. The algebraic framework, which is aimed at implementing the query interface on top of a working DBMS, is made up of: (a) the extended temporal algebra TA ⋆ supporting OTQs with an hybrid temporal semantics (sequenced and non-sequenced); (b) the continuous temporal algebra CTA that extends TA ⋆ with window expressions for CQ specification; (c) the translation of CTA expressions into TA ⋆ ones that can be executed by a traditional DBMS with an extended kernel. • Unification of streaming, temporal, and relational querying for advanced analytics. • Full acknowledgment of the inherently temporal nature of streaming data. • Definition of the Continuous Temporal Algebra. • Unified semantics for one-time and continuous queries. • Implementability on standard DBMS technology to leverage on well-founded procedures. [ABSTRACT FROM AUTHOR]

The industry-wide adoption of graph databases has been hindered due to the fragmentation in syntax and semantics of available graph query languages. As a result, several projects have been proposed by industry and academia to develop a standard query language by integrating features from existing practical graph query languages. A significant factor that can impact query language integration is the lack of common theoretical language formalisms. We propose common formalisms by extending conjunctive queries and union of conjunctive queries with Tarski's relation algebra ( CQT / UCQT ). We use common graph query patterns to compare the expressive power of ( CQT / UCQT ) with two practical graph query languages - C y p h e r and P G Q L. The query languages are analysed on the core features of graph pattern matching and graph navigation, revealing the common and exclusive characteristics for these languages. Overall, our study serves as a formal basis for comparing existing graph query languages and assists the move towards query language integration and interoperability between available graph database technologies. • There is a lack of explicit mapping between practical graph query languages and theoretical language formalisms. • Current formalisms used by practical graph query languages are not expressive enough. • Extension of conjunctive queries and union of conjunctive queries with Tarski's relation algebra. • Use of extended formalisms to compare the expressiveness of practical graph query languages. • A comprehensive comparison of two practical graph query languages Cypher and PGQL. [ABSTRACT FROM AUTHOR]

Motivated by the continuing interest in the tree data model, we study the expressive power of downward navigational query languages on trees and chains. Basic navigational queries are built from the identity relation and edge relations using composition and union. We study the effects on relative expressiveness when we add transitive closure, projections, coprojections, intersection, and difference; this for Boolean queries and path queries on labeled and unlabeled structures. In all cases, we present the complete Hasse diagram. In particular, we establish, for each query language fragment that we study on trees, whether it is closed under difference and intersection. • Complete Hasse diagrams are given for relative expressiveness on trees and chains. • Different Hasse diagrams are obtained for Boolean and path semantics. • Basic downward queries are closed under intersection and difference. • Condition automata are introduced as a proof tool. • Boolean downward queries on chains are closed under projection. [ABSTRACT FROM AUTHOR]