haskell-opaleye

The only way out that I can see is to design embedded domain specific languages (EDSLs) that inherit the expressiveness, composability and type safety from the host language. That's what Opaleye and Rel8 (Postgres EDSLs for Haskell do. Haskell is particularly good for this. The query language can be just a monad and therefore users can carry all of their knowledge of monadic programming to writing database queries. This approach doesn't resolve all of the author's complaints but it does solve many. Disclaimer: I'm the author of Opaleye. Rel8 is built on Opaleye. Other relational query EDSLs are available. [1] https://github.com/tomjaguarpaw/haskell-opaleye/ [2] https://github.com/circuithub/rel8/

I made a Haskell Postgres library inspired by David Spivak's work: https://github.com/tomjaguarpaw/haskell-opaleye/

I'll link to some of my own code, since I know it better than any other https://github.com/tomjaguarpaw/haskell-opaleye/blob/master/... For someone who knows Haskell idioms this is extremely readable compared to functionally equivalant code in another language.

Two potential counter-examples to your productive software claim: Opaleye [0], an Arrow-based [1] DSL for Postgres SQL that allows the user to create type-safe, composable, and (generally) optimally fast SQL queries. Halogen [2], a type-safe frontend framework for PureScript [3] that models view component interaction as an algebraic datatype containing query actions (among other fairly advanced concepts). If someone is used to a certain level of abstraction, then the higher levels might seem unnecessary until they invest the time into learning them. The only thing unique to functional programming is that it has inherited a lot of terms from theory (profunctor, monad, algebra) rather than inventing friendlier ones. [0] https://github.com/tomjaguarpaw/haskell-opaleye [1] https://www.haskell.org/arrows/ [2] https://github.com/slamdata/puresc

* https://github.com/tomjaguarpaw/haskell-opaleye * https://github.com/khibino/haskell-relational-record

> SQL is a very high level language (may be even higher than Haskell minus the great type system of Haskell). I have a solution for that :) https://github.com/tomjaguarpaw/haskell-opaleye/

> the majority of my modeling needs to be done in the database and merely wrapped with Haskell I highly recommend Opaleye for this (with the caveat that I'm the primary author!). From the Opaleye front page: > Opaleye is a Haskell library that provides an SQL-generating embedded domain specific language for targeting Postgres. You need Opaleye if you want to use Haskell to write typesafe and composable code to query a Postgres database. > "Opaleye really is great. You've managed to bring what is so wonderful about relational databases and give it type safety and composition (i.e. what is wonderful about Haskell)" – Daniel Patterson, Position Development https://github.com/tomjaguarpaw/haskell-opaleye/

Some corrections/comments/questions: > Opaleye ... no join support (simulated via sub selects) This is true for exactly one reason: despite being raised frequently, nobody has ever been able to demonstrate any performance difference between subselects and joins (in Postgres)! As soon as someone does, they should file an issue (https://github.com/tomjaguarpaw/haskell-opaleye/issues/) and I'll add joins forthwith. > Opaleye ... tough syntax to parse What do you mean by this? The Haskell syntax of Opaleye, or the generated SQL? > Esqueleto ... Postgres only You're incorrect about this. From your Esqueleto link: "It has many kinds of backends, such as SQL backends (persistent-mysql, persistent-postgresql, persistent-sqlite) and NoSQL backends (persistent-mongoDB)." > Esqueleto ... can't/doesn't prevent invalid sql But you're right about th

Honestly none of the statically typed sql generators (Opaleye included) really tick all the boxes; all are lacking in one way or another. Here's a breakdown of the leaders of the pack on this front[0] Haskell 1) Opaleye[1]: composable and prevents invalid sql, but no join support (simulated via sub selects), Postgres only, and tough syntax to parse. 2) Esqueleto[2]: composable, readable, supports joins, but Postgres only, and the DSL can't/doesn't prevent invalid sql (which is, IIRC, one of the reasons why Opaleye came into being). Scala 1) Slick[3] myriad databases supported (Oracle and SQL Server require non-free license), join support, fully composable (really, king of monad hill), and elegant syntax (until you `groupBy`/`sortBy` and then enter unreadble tuple_.1, tuple._N soup). Also, grouping requires flattening result set via min, m

Off topic: Hello, just wondered if you've seen this that I released earlier this week: https://github.com/tomjaguarpaw/haskell-opaleye Feel free to send me an email (address linked in the README) if you have any questions about the project.