Monad comprehensions : a versatile representation for queries

@inproceedings{Grust2004MonadC,
  title={Monad comprehensions : a versatile representation for queries},
  author={Torsten Grust},
  year={2004}
}
This chapter is an exploration of the possibilities that open up if we consistently adopt a style of database query and collection processing which allows us to look inside collections and thus enables us to play with atomic constructors instead of the monolithic collection values they build. 
Multi-model Query Processing Meets Category Theory and Functional Programming
TLDR
This work proposes category theory as a foundation for a new query language design, query processing, and transformation frameworks for MMDBS, and proposes a category theory-inspired prototype system.
A co-Relational Model of Data for Large Shared Data Banks
Fueled by their promise to solve the problem of distilling valuable information and business insight from big data in a scalable and programmer-friendly way, noSQL databases have been one of the
Collection Processing with Constraints , Monads , and Folds
We propose an intermediate form based on monad-algebra comprehensions (to represent queries), folds (to represent computation), and setoids over polynomial datatypes (to represent data), suitable for
Using dependent types and tactics to enable semantic optimization of language-integrated queries
TLDR
This work shows how to use dependent types to represent a well known class of constraints --- embedded, implicational dependencies --- and how Coq tactics can be used to implement a particular kind of semantic optimization: tableaux minimization, which minimizes the number of joins required by a query.
Comprehending Monoids with Class
TLDR
It is argued that for expressing queries over collections of data, the embedding of monoid comprehension can be more flexible, simpler, more efficient, and safer than its monadic counterpart.
An algebra for distributed Big Data analytics
  • L. Fegaras
  • Computer Science
    Journal of Functional Programming
  • 2017
Abstract We present an algebra for data-intensive scalable computing based on monoid homomorphisms that consists of a small set of operations that capture most features supported by current
First-Class Functions for First-Order Database Engines
TLDR
Query defunctionalization is a non-invasive approach that transforms such function-centric queries into the data-centric operations implemented by common query processors.
A co-relational model of data for large shared data banks
Contrary to popular belief, SQL and noSQL are really just two sides of the same coin.
Kleisli Database Instances
TLDR
This work uses monads to relax the atomicity requirement for data in a database, and shows that classical concepts like Markov chains, graphs, and finite state automata are each perfectly captured by a different monad on the same schema.
Charting the Design Space of Query Execution using VOILA
TLDR
This work proposes a framework that enables synthesizing many different engines from a description in a carefully designed domain-specific language (VOILA), and demonstrates VOILA’s flexibility by exploring the query engine design space in an automated fashion.
...
1
2
3
4
5
...

References

SHOWING 1-10 OF 31 REFERENCES
Optimizing object queries using an effective calculus
TLDR
This article concentrates on query unnesting (also known as query decorrelation), an optimization that, even though it improves performance considerably, is not treated properly by most OODB systems.
Querying Nested Collections
TLDR
This dissertation investigates a new approach to query languages inspired by structural recursion and by the categorical notion of a monad, which provides easy answers to several hitherto unresolved conjectures on query languages that are more realistic than the flat relational algebra.
On optimizing an SQL-like nested query
  • W. Kim
  • Computer Science
    TODS
  • 1982
TLDR
An SQL-like query nested to an arbitrary depth is shown to be composed of five basic types of nesting, four of which have not been well understood and more work needs to be done to improve their execution efficiency.
Comprehending queries
  • Torsten Grust
  • Computer Science
    Ausgezeichnete Informatikdissertationen
  • 1999
TLDR
A world in which datatypes determine the comprehension of queries is described, which is specific enough to grasp implementation issues, such as the generation of stream-based (pipelined) query execution plans, whose treatment has traditionally been delayed until query runtime.
Comprehension syntax
TLDR
An informal account of a language based on comprehension syntax that deals uniformly with a variety of collection types and shows how comprehension syntax is a natural fragment of structural recursion, a much more powerful programming paradigm for collection types.
A short cut to deforestation
TLDR
This work proposes an automatic technique for improving theiency of programs, by removing many of these intermediate lists, based on a single, simple, local transformation.
How to Comprehend Queries Functionally
TLDR
This work adopts a view of query processing which is greatly influenced by ideas from the functional programming domain, and presents a uniform formal framework which covers all query translation phases, including user-level query language compilation, query optimization, and execution plan generation.
Accelerating XPath location steps
TLDR
This work is a proposal for a database index structure that has been specifically designed to support the evaluation of XPath queries, capable to support all XPath axes and able to start traversals from arbitrary context nodes in an XML document.
Groupwise Processing of Relational Queries
TLDR
This paper defines and examines a particular class of queries called group queries, and gives a syntactic criterion to identify these queries and prove its sufficiency, and proves the strong result that every group query has an equivalent formulation that satisfies the authors' syntactical criterion.
Optimization of Nested Queries in a Complex Object Model
TLDR
The nest join operator is introduced, which is a generalization of the outerjoin for complex objects in the relational context, to solve the COUNT bug.
...
1
2
3
4
...