How to Make SQL Stand for String Query Language

@inproceedings{Grahne1999HowTM,
  title={How to Make SQL Stand for String Query Language},
  author={G{\"o}sta Grahne and Emmanuel Waller},
  booktitle={DBPL},
  year={1999}
}
A string database is simply a collection of tables, the columns of which contain strings over some given alphabet. We address in this paper the issue of designing a simple, user friendly query language for string databases. We focus on the language FO(•), which is classical first order logic extended with a concatenation operator, and where quantifiers range over the set of all strings. We wish to capture all string queries, i.e., well-typed and computable mappings involving a notion of string… 

Definable relations and first-order query languages over strings

This article studies analogs of classical relational calculus in the context of strings, and shows that by choosing the string vocabulary carefully, one gets string logics that have desirable properties: computable evaluation and normal forms.

String operations in query languages

The space between relational calculi with support for string operations is explored, and two intermediate languages are considered: the first extends the base language with functions that trim/add leading characters, and the other extends it by adding the full power of regular-expression pattern-matching.

Query Languages for Sequence Databases: Termination and Complexity

The main idea is to use safe recursion to control and limit unsafe recursion and the definition of a finite form of recursion, called domain-bounded recursions, and a characterization of its complexity and expressive power.

Expressiveness within Sequence Datalog

This work considers classical features of Datalog programs, such as negation, recursion, intermediate predicates, and relations of higher arities, and considers new features that are useful for sequences, notably, equations between path expressions, and "packing''.

Avoiding Infinite Loops in the Solving of Equations Involving Sequence Variables and Terms with Flexible Arity Function Symbols

This paper presents a simple method for checking if a branch will lead to a loop, based on an abstraction of the original unification by a Diophantine equation on the sizes of the terms involved.

Adding string processing capabilities to data management systems

The work continues the development of the Alignment Declaration language, the proposal for specifying string relations, by presenting a new and improved method for evaluating the queries and analysing their finiteness.

Pattern Unification with Sequence Variables, Flexible Arity Symbols

  • Temur Kutsia
  • Computer Science
    Electron. Notes Theor. Comput. Sci.
  • 2002

Unification with Sequence Variables and Flexible Arity Symbols and Its Extension with Pattern-Terms

A minimal and complete unification procedure for a theory with individual and sequence variables, free constants and free fixed and flexible arity function symbols is described and a brief overview

References

SHOWING 1-10 OF 43 REFERENCES

AQL: an Alignment Based Language for Querying String Databases

This paper describes an implementation of Alignment Calculus, a powerful string database language based on a modal logic extension of relational calculus, and shows that the inference engine has the efficiency of an equivalent query computed in compiled Prolog.

Reasoning about strings in databases

In order to enable the database programmer to reason about relations over strings of arbitrary length we introduce alignment logic, a modal extension of relational calculus. In addition to relations,

Safe constraint queries

This work shows how to give an effective syntax to safe queries and prove that for conjunctive queries the preservation properties are decidable, and gets syntactic characterizations of the queries on constraint databases that preserve geometric conditions in the constraint data model.

Languages for relational databases over interpreted structures

A set of algorithms for eliminating unbounded quantifications in favor of bounded ones is given, and an elementary proof of the fact that parity test is not definable in the relational calculus with polynomial inequality constraints is obtained.

The Design and Implementation of a Sequence Database System

The issues that were addressed when building the SEQ sequence database system, a database system with support for sequence data, are described and a novel nested design paradigm used in PREDATOR to combine sequence ‘and relational data is presented.

Sequences, Datalog and transducers

By carefully limiting the amount of unsafe recursion, the paper develops a safe and expressive subset of Sequence Datalog, which has both a clear operational and declarative semantics, based on a new notion called the extended active domain of a database.

Safety, Translation and Evaluation of Alignment Calculus

This paper purses the study of Alignment Calculus, a declarative string database query language that supports both string querying and restructuring, and defines a domain independent syntactic subset of the full language and develops a query evaluation mechanism for this sublanguage.

Supporting Lists in a Data Model (A Timely Approach)

A new framework based on Boolean circuits for evaluating the truth of an assertion on a given list is described, which provides many opportunities for optimization and parallelism, and it lends insight to the meaning and complexity of a temporal formula.

Regular Sequence Operations and Their Use in Database Queries

A family of regular sequence operations (called rs-operations) to be used in database queries is introduced, based on a simple pattern matching mechanism using regular expressions as its patterns, and includes most of the “natural” operations on sequences.

The AQUA approach to querying lists and trees in object-oriented databases

An object-oriented query algebra called AQUA (= A Query Algebra) for lists and trees is described, which preserves the ordering between the elements of a list and tree, even when the result list or tree contains an arbitrary set of nodes from the original tree.