Static and dynamic semantics of NoSQL languages

We present a calculus for processing semistructured data that spans differences of application area among several novel query languages, broadly categorized as "NoSQL". This calculus lets users define their own operators, capturing a wider range of data processing capabilities, whilst providing a typing precision so far typical only of primitive hard-coded operators. The type inference algorithm is based on semantic type checking, resulting in type information that is both precise, and flexible enough to handle structured and semistructured data. We illustrate the use of this calculus by encoding a large fragment of Jaql, including operations and iterators over JSON, embedded SQL expressions, and co-grouping, and show how the encoding directly yields a typing discipline for Jaql as it is, namely without the addition of any type definition or type annotation in the code

Duce: An XML-Centric General-Purpose Language

Abstract. We present the functional language ¡ Duce, discuss some design issues, and show its adequacy for working with XML documents. Distinctive features of ¡ Duce are a powerful pattern matching, first class functions, overloaded functions, a very rich type system (arrows, sequences, pairs, records, intersections, unions, differences), precise type inference for patterns and error localization, and a natural interpretation of types as sets of values. We also outline some important implementation issues; in particular, a dispatch algorithm that demonstrates how static type information can be used to obtain very efficient compilation schemas

Static management of integrity constraint in object-oriented database systems: design and implementation

International audienc

SQL à l'épreuve de Coq Une sémantique formelle pour SQL

International audienceNous proposons une sémantique formelle, exécutable, mécanisée en Coq pour un fragment réaliste du langage SQL, le standard en terme de bases de données relationnelles. Ce fragment prend en compte des requêtes de la forme select [distinct] from where group by having en présence de valeurs nulles, fonctions, agrégats, quantificateurs ainsi que de requêtes imbriquées potentiellement corrélées. Nous relions ce fragment à l'algèbre relationnelle, équivalent pour SQL du λ-calcul pour les langages fonctionnels. Nous obte-nons ainsi le premier résultat d'équivalence de ce fragment et de l'algèbre, formellement prouvé. Enfin, grâce au mécanisme d'extraction, nous fournissons un analyseur sémantique du langage SQL certifié en Coq, élément central pour l'obtention d'un compilateur SQL vérifié

Thémis: A Database Programming Language Handling Integrity Constraints

This article presents a database programming language, Thémis, which supports subtyping and class hierarchies, and allows for the definition of integrity constraints in a global and declarative way. We first describe the salient features of the language: types, names, classes, integrity constraints (including methods), and transactions. The inclusion of methods into integrity constraints allows an increase of the declarative power of these constraints. Indeed, the information needed to define a constraint is not always stored in the database through attributes, but is sometimes computed or derived data. Then, we address the problem of efficiently checking constraints. More specifically, we consider two different problems: (1) statically reducing the number of constraints to be checked, and (2) generating an efficient run-time checker. Using simple strategies, one can significantly improve the efficiency of the verification. We show how to reduce the number of constraints to be checked by characterizing the portions of the database that are involved in both the constraints and in a transaction. We also show how to generate efficient algorithms for checking a large class of constraints. We show how all the techniques presented exploit the underlying type system, which provides significant help in solving (1) and (2). Last, the current status of the Thémis prototype is presented

Ensuring efficiently the integrity of a persistent object store via abstract interpretation

National audienc

Static Integrity Constraint Management in Object-Oriented Database Programming Languages via Predicate Transformers

. In this paper, we propose an efficient technique to statically manage integrity constraints in object-oriented database programming languages. We place ourselves in the context of an extended version of the O2 database programming language, and we assume that updates are undertaken by means of methods. An important issue when dealing with constraints is that of efficiency. A naive management of such constraints can cause a severe floundering of the overall system. Our basic assumption is that the run-time checking of constraints is too costly to be undertaken systematically. Therefore, methods that are always safe with respect to integrity constraints should be proven so at compile time. The run-time checks should only concern the remaining methods. To that purpose, we propose a new approach, based on abstract interpretation, to prove the invariance of integrity constraints under complex methods. We then describe the current implementation of our prototype, reporting many experime..

Static management of integrity in object-oriented databases: Design and implementation

Abstract. In this paper, we propose an efficient technique to statically manage integrity constraints in object-oriented database programming languages. We place ourselves in the context of a simplified database programming language, close to O2, in which we assume that updates are undertaken by means of methods. An important issue when dealing with constraints is that of efficiency. A nave management of such constraints can cause a severe floundering of the overall system. Our basic assumption is that the run-time checking of constraints is too costly to be undertaken systematically. Therefore, methods that are always safe with respect to integrity constraints should be proven so at compile time. The run-time checks should only concern the remaining methods. To that purpose, we propose a new approach, based on the use of predicate transformers combined with automatic theorem proving techniques, to prove the invariance of integrity constraints under complex methods. We then describe the current implementation of our prototype, and report some experiments that have been performed with it on non trivial examples. The counterpart of the problem of program verification is that of program correction. Static analysis techniques can also be applied to solve that problem. We present a systematic approach to undertake the automatic correction of potentially unsafe methods. However, the advantages of the latter technique are not as clear as those of program verification. We will therefore discuss some arguments for and against the use of method correction.