Skip to content
An efficient PostgreSQL driver with a flexible mapping API
Haskell Shell
Branch: master
Clone or download
nikita-volkov Merge pull request #123 from jfischoff/master
Add an Exception instance to QueryError #122
Latest commit b28f88e Feb 18, 2020
Type Name Latest commit message Commit time
Failed to load latest commit information.
benchmarks Redesign decoders May 20, 2019
library/Hasql Add an Exception instance to QueryError #122 Feb 17, 2020
tasty Rename unit to noResult May 21, 2019
threads-test Rename unit to noResult May 21, 2019
.travis.yml Update Travis Nov 7, 2019
LICENSE Init Aug 3, 2014 Correct the demo Jan 28, 2020
hasql.cabal Set the version to 1.4.1 Jan 22, 2020
profile-events Add profiling Apr 13, 2017

What Hasql is

Build Status Hackage

Hasql is a highly efficient PostgreSQL driver and a mapping API. It targets both the users, who need a low level of abstraction, and the users, who face the typical tasks of DB-powered applications, providing them with higher-level APIs.


Hasql is not just a single library, it is a granular ecosystem of composable libraries, each isolated to perform its own task and stay simple.

  • "hasql" - the root of the ecosystem, which provides the essential abstraction over the PostgreSQL client functionality and mapping of values. Everything else revolves around that library.

  • "hasql-th" - Template Haskell utilities, providing compile-time syntax checking and easy statement declaration.

  • "hasql-transaction" - an STM-inspired composable abstraction over database transactions providing automated conflict resolution.

  • "hasql-dynamic-statements" - a toolkit for generating statements based on the parameters.

  • "hasql-cursor-query" - a declarative abstraction over cursors.

  • "hasql-cursor-transaction" - a lower-level abstraction over cursors, which however allows to fetch from multiple cursors simultaneously. Generally though "hasql-cursor-query" is the recommended alternative.

  • "hasql-pool" - a Hasql-specialized abstraction over the connection pool.

  • "hasql-migration" - A port of postgresql-simple-migration for use with hasql.

  • "hasql-optparse-applicative" - "optparse-applicative" parsers for Hasql.

  • "hasql-implicits" - implicit definitions, such as default codecs for standard types.

Benefits of being an ecosystem

  • Simplicity. Each library in isolation provides a simple API, which is hopefully easier to comprehend.

  • Flexibility and composability. The user picks and chooses the features, thus precisely matching the level of abstraction that he needs for his task.

  • Much more stable and more descriptive semantic versioning. E.g., a change in the API of the "hasql-transaction" library won't affect any of the other libraries and it gives the user a more precise information about which part of his application he needs to update to conform.

  • Interchangeability and competition of the ecosystem components. E.g., not everyone will agree with the restrictive design decisions made in the "hasql-transaction" library. However those decisions are not imposed on the user, and instead of having endless debates about how to abstract over transactions, another extension library can simply be released, which will provide a different interpretation of what the abstraction over transactions should be.

  • Horizontal scalability of the ecosystem. Instead of posting feature- or pull-requests, the users are encouraged to release their own small extension-libraries, with themselves becoming the copyright owners and taking on the maintenance responsibilities. Compare this model to the classical one, where some core-team is responsible for everything. One is scalable, the other is not.


Short Example

Following is a complete application, which performs some arithmetic in Postgres using Hasql.

{-# LANGUAGE OverloadedStrings, QuasiQuotes #-}
import Prelude
import Data.Int
import Data.Functor.Contravariant
import Hasql.Session (Session)
import Hasql.Statement (Statement)
import qualified Hasql.Session as Session
import qualified Hasql.Connection as Connection
import qualified Hasql.TH as TH -- from "hasql-th"

main :: IO ()
main = do
  Right connection <- Connection.acquire connectionSettings
  result <- (sumAndDivModSession 3 8 3) connection
  print result
    connectionSettings = Connection.settings "localhost" 5432 "postgres" "" "postgres"

-- * Sessions
-- Session is an abstraction over the database connection and all possible errors.
-- It is used to execute statements.
-- It is composable and has a Monad instance.
-- It's recommended to define sessions in a dedicated 'Sessions'
-- submodule of your project.

sumAndDivModSession :: Int64 -> Int64 -> Int64 -> Session (Int64, Int64)
sumAndDivModSession a b c = do
  -- Get the sum of a and b
  sumOfAAndB <- Session.statement (a, b) sumStatement
  -- Divide the sum by c and get the modulo as well
  Session.statement (sumOfAAndB, c) divModStatement

-- * Statements
-- Statement is a definition of an individual SQL-statement,
-- accompanied by a specification of how to encode its parameters and
-- decode its result.
-- It's recommended to define statements in a dedicated 'Statements'
-- submodule of your project.
-- In the following code we use the extension library "hasql-th",
-- which generates statement definitions from SQL,
-- compile-time checking the syntax on the way.

sumStatement :: Statement (Int64, Int64) Int64
sumStatement =
    select ($1 :: int8 + $2 :: int8) :: int8

divModStatement :: Statement (Int64, Int64) (Int64, Int64)
divModStatement =
      (($1 :: int8) / ($2 :: int8)) :: int8,
      (($1 :: int8) % ($2 :: int8)) :: int8
You can’t perform that action at this time.