Typed query languages for databases containing queries

We study the expressive power of the Lara language - a recently proposed unified model for expressing relational and linear algebra operations - both in terms of traditional database query languages and some analytic tasks often performed in machine learning pipelines. We start by showing Lara to be expressive complete with respect to first-order logic with aggregation. Since Lara is parameterized by a set of user-defined functions which allow to transform values in tables, the exact expressive power of the language depends on how these functions are defined. We distinguish two main cases depending on the level of genericity queries are enforced to satisfy. Under strong genericity assumptions the language cannot express matrix convolution, a very important operation in current machine learning operations. This language is also local, and thus cannot express operations such as matrix inverse that exhibit a recursive behavior. For expressing convolution, one can relax the genericity requirement by adding an underlying linear order on the domain. This, however, destroys locality and turns the expressive power of the language much more difficult to understand. In particular, although under complexity assumptions the resulting language can still not express matrix inverse, a proof of this fact without such assumptions seems challenging to obtain.

We formulate some natural conditions which should be satisfied in an extension of the relational algebra from the usual relations to tables with null values, and we explain the motivation behind these conditions. Roughly speaking, our conditions say that the extended algebra makes it possible to correctly compute the true tuples in the result of applying a relational expression (query) to tables with nulls (database state), and that the computation can be carried out recursively, following the structure of the expression. We prove that these conditions are exactly equivalent to other conditions proposed earlier by the author and T. Imielinski. We give a simple proof of the correctness of the extension of the relational algebra to tables with marked nulls, where the nulls are treated as if they were regular values, and which supports the operations of projection, positive selection, union, join and renaming of attributes. We also show that the result of the naive evaluation of such an expression (query) is equal to the response to the query as defined --- in a proof-theoretic framework --- by Reiter.

We consider two versions of the relational algebra: (a) the attribute relational algebra, based on the natural join and relations with columns corresponding to attributes, and (b) the positional relational algebra, based on the cross product and relation with an order on the columns, and with any column identified by its position in that order. For the attribute relational algebra, we show that both the equivalence and the finite equivalence (i.e., equivalence over finite relations only) of expressions involving just one ternary relation and the operators of projection, selection, join and difference, are undecidable. For the positional relational algebra, we show that both the equivalence and finite equivalence of expressions involving just one binary relation and the operators of projection, selection, cross product, restriction and difference, are undecidable.

Bulk types such as sets, bags, and lists are monads, and therefore support a notation for database queries based on comprehensions. This fact is the basis of much work on database query languages. The monadic structure easily explains most of standard relational algebra---specifically, selections and projections---allowing for an elegant mathematical foundation for those aspects of database query language design. Most, but not all: monads do not immediately offer an explanation of relational join or grouping, and hence important foundations for those crucial aspects of relational algebra are missing. The best they can offer is cartesian product followed by selection. Adjunctions come to the rescue: like any monad, bulk types also arise from certain adjunctions; we show that by paying due attention to other important adjunctions, we can elegantly explain the rest of standard relational algebra. In particular, graded monads provide a mathematical foundation for indexing and grouping, which leads directly to an efficient implementation, even of joins.

The paper proposes a method of parsing for relational algebra expressions, which is based on the use of reverse Polish notation (postfix notation). The operation algorithm of the shunting yard, adapted for processing of operators RA, is presented. The tools of lexical analysis and the mechanism of building a syntax analyser for the language of relational algebra are presented. The algorithm of the software solution in Python is described, which allows convert the operator of relational algebra into SQL queries. Underpin of the data source for the implementation of relational algebra operators the relational database - SQLite.

Conditional event algebra (CEA) was developed in order to represent conditional probabilities with differing antecedents by the probability evaluation of well-defined individual “conditional” events in a single larger space extending the original unconditional one. These conditional events can then be combined logically before being evaluated. A major application of CEA is to data fusion problems, especially the testing of hypotheses concerning the similarity or redundancy among inference rules through use of probabilistic distance functions which critically require probabilistic conjunctions of conditional events. Relational event algebra (REA) is a further extension of CEA, whereby functions of probabilities formally representing single event probabilities — not just divisions as in the case of CEA — are shown to represent actual “relational” events relative to appropriately determined larger probability spaces. Analogously, utilizing the logical combinations of such relational events allows for testing of hypotheses of similarity between data fusion models represented by functions of probabilities. Independent of, and prior to this work, it was proven that a major portion of fuzzy logic — a basic tool for treating natural language descriptions — can be directly related to probability theory via the use of one point random set coverage functions. In this paper, it is demonstrated that a natural extension of the one point coverage link between fuzzy logic and random set theory can be used in conjunction with CEA and REA to test for similarity of natural language descriptions.

We consider the problem of finding and classifying representations in algebraic logic. This is approached by letting two players build a representation using a game. Homogeneous and universal representations are characterized according to the outcome of certain games. The Lyndon conditions defining representable relation algebras (for the finite case) and a similar schema for cylindric algebras are derived. Finte relation algebras with homogeneous representations are characterized by first order formulas. Equivalence games are defined, and are used to establish whether an algebra is ω-categorical. We have a simple proof that the perfect extension of a representable relation algebra is completely representable.An important open problem from algebraic logic is addressed by devising another two-player game, and using it to derive equational axiomatisations for the classes of all representable relation algebras and representable cylindric algebras.Other instances of this approach are looked at, and include the step by step method.

With the prevalence of graph data in a variety of domains, there is an increasing need for a language to query and manipulate graphs with heterogeneous attributes and structures. We present a graph query language (GraphQL) that supports bulk operations on graphs with arbitrary structures and annotated at- tributes. In this language, graphs are the basic unit of information and each query manipulates one or more collections of graphs at a time. The core of GraphQL is a graph algebra extended from the relational algebra in which the selection operator is generalized to graph pattern matching and a composition operator is introduced for rewriting matched graphs. Then, we investigate access methods of the selection operator. Pattern matching over large graphs is challenging due to the NP-completeness of subgraph isomorphism. We address this by a combination of techniques: use of neighborhood subgraphs and pro- files, joint reduction of the search space, and optimization of the search order. Experimental results on real and synthetic large graphs demonstrate that graph specific optimizations outperform an SQL-based implementation by orders of magnitude.

This paper examines a number of programming primitives in query languages for relational databases. The basic framework is a language based on relational algebra, whose variables take relations as values. The primitives considered are (i) looping, (ii) counters, (iii) generic (or unranked) variables, (iv) equality, (v) bounded looping (which corresponds to counting the number of tuples in a relation), and (vi) isomorphism class (which corresponds to knowing the isomorphism class of the data base). A comparison diagram is given relating all combinations of these six primitives, and several of the resulting classes of queries are characterized by their complexity or algebraic properties. It is shown, for example, that equality cannot be simulated using all the other primitives, that generic variables (with loops) cannot be simulated with only ranked variables and all the other primitives, and that with bounded loops one can determine the isomorphism class of the database when generic variables are allowed, but not otherwise.

The problem of computing windows using relational expressions has been solved only in certain cases in which the chase semantics and the extension chase semantics of the database coincide. However, the general problem of computing windows under either chase semantics or extension chase semantics, but without restrictions, remained an open problem. In this paper we present a complete solution of the general problem, under extension chase semantics. Our solution is complete in the sense that it does not require any assumption on the database scheme or on the database state. It follows that our approach subsumes previous approaches, and we exhibit cases in which our approach correctly computes the windows, while previous approaches fail to do so. Moreover, the efficiency of our approach lies in the fact that it uses only those relation schemes and only those functional dependencies that are necessary in the computation of windows. The main technique employed by our approach is a least fixpoint construction using the notion of cover (a cover being a set of relation schemes satisfying certain properties). The proposed technique can be implemented using relational algebra plus recursion.

DNA computing has a rich history of computing paradigms with great expressive power. However, far less expressive power is needed for data manipulation. Indeed, the relational algebra, the yardstick of database systems, is expressible in first-order logic, and thus less powerful than Turing-complete models. Turing-complete DNA computing models have to account for many and varied scenarios. A DNA implementation of data manipulations might be nimbler and perform its operation faster than a Turing-complete DNA computing model. Hence, we propose a restrictive model for implementing data manipulation operations, focused on implementability in DNA. We call this model the sticker complex model. A forte of the sticker complex model, is its ability to detect when hybridization becomes an uncontrolled chain reaction. Such chain reactions make hybridization less predictable and thus less attractive for deterministic computations. Next, we define a query language on sticker complexes, called DNAQL. DNAQL is a typed, applicative functional programming language, powerful enough to simulate the relational algebra on sticker complexes. The type system enjoys a number of desirable properties such as soundness, maximality, and tightness.

The treatment of abstract query languages such as Relational Algebra, Relational Calculus, and Datalog in introductory database courses varies considerably across the various computer science departments around the world. We propose an integrated approach in which students learn how to express a natural language query in Domain Relational Calculus (DRC), apply a query-transforming algorithm to the DRC expression tree to produce Datalog Rules (DLG), and finally apply another query-transforming algorithm to the DLG rules to produce an equivalent Relational Algebra (RA) expression. This systematic approach works very well for forall-queries in which the forall-quantifier is necessary in the DRC expression. To make this approach even more effective, the students are required to use DRC, DLG, and RA interpreters that allow them to execute query expressions as well as produce equivalent expressions. The students are also involved in implementing these interpreters to get a deeper understanding of querying in relational systems.

Constraint databases use constraints to model and query data. In particular, constraints allow a finite representation of infinite sets of relational tuples (also called generalized tuples). The choice of different logical theories to express constraints inside relational languages leads to the definition of constraint languages with different expressive power. Practical constraint database languages typically use linear constraints. This choice allows the use of effcient algorithms but, at the same time, some useful queries, needed by the considered application, may not be represented inside the resulting languages (for example, the convex hull cannot be computed [19]). These additional queries can only be modeled by changing the theory (thus, loosing the advantages of the linear theory), or extending the language, or using external functions. In this paper we consider the last approach and we propose an algebra and a calculus for constraint relational databases extended with external functions, formally proving their equivalence. In doing that, we use an approach similar to the one used by Klug to prove the equivalence between the relational algebra and the relational calculus extended with aggregate functions [14]. As far as we know, this is the first approach to introduce external functions in constraint query languages.

The traditional focus of database language research has been on high-level languages for data access and manipulation (query languages, trigger definition languages, 4th generation languages, script languages) or on implementation-oriented languages which capture the characteristic operations of a specific target system at hand (relational algebra, object algebra, structural recursion,…).

Large parts of today’s data is stored in text documents that undergo a series of changes during their lifetime. For instance during the development of a software product the source code changes frequently. Currently, managing such data relies on version control systems (VCSs). Extracting information from large documents and their different versions is a manual and tedious process. We present Qvestor, a system that allows to declaratively query documents. It leverages information about the structure of a document that is available as a context-free grammar and allows to declaratively query document versions through a grammar annotated with relational algebra expressions. We define and illustrate the annotation of grammars with relational algebra expressions and show how to translate the annotations to easy to use SQL views.KeywordsSource CodeRelational AlgebraParse TreeNode DataGrammar RuleThese keywords were added by machine and not by the authors. This process is experimental and the keywords may be updated as the learning algorithm improves.