Database.Quibble

Documentation

data Query (ctx :: Type)

Instances

DBRender (Query ctx)

Defined in Database.Quibble

Methods

renderSQL :: Query ctx -> ByteString

ctx ~ ctx' => DBWhere (Query ctx) ctx'

Defined in Database.Quibble

Methods

whereCond :: Lens' (Query ctx) (Maybe (Expr ctx' Bool))

allRows :: Query ctx

data RowsOf (ctx :: Type)

Instances

DBRender (RowsOf ctx)

Defined in Database.Quibble

Methods

renderSQL :: RowsOf ctx -> ByteString

ctx ~ ctx' => DBWhere (RowsOf ctx) ctx'

Defined in Database.Quibble

Methods

whereCond :: Lens' (RowsOf ctx) (Maybe (Expr ctx' Bool))

allRows :: RowsOf ctx

class DBWhere qry ctx where

Methods

whereCond :: Lens' qry (Maybe (Expr ctx Bool))

allRows :: qry

A convenience function for when the user doesn't want to specify any conditions.

Instances

ctx ~ ctx' => DBWhere (RowsOf ctx) ctx'

Defined in Database.Quibble

Methods

whereCond :: Lens' (RowsOf ctx) (Maybe (Expr ctx' Bool))

allRows :: RowsOf ctx

ctx ~ ctx' => DBWhere (Query ctx) ctx'

Defined in Database.Quibble

Methods

whereCond :: Lens' (Query ctx) (Maybe (Expr ctx' Bool))

allRows :: Query ctx

class DBRender a where

Methods

renderSQL :: a -> ByteString

Instances

DBRender (RowsOf ctx)

Defined in Database.Quibble

Methods

renderSQL :: RowsOf ctx -> ByteString

DBRender (Query ctx)

Defined in Database.Quibble

Methods

renderSQL :: Query ctx -> ByteString

newtype Expr (ctx :: Type) (ty :: Type)

The constructor is exposed in case you need to unsafely construct | expressions. But you shouldn't rely on it too much.

Constructors

Expr

Fields

• unExpr :: Builder

Instances

(KnownSymbol tbl, HasTable ctx tbl, HasColumn ctx col ty) => IsLabel col (Expr ctx ty)

Defined in Database.Quibble

Methods

fromLabel :: Expr ctx ty

(Show a, Fractional a) => Fractional (Expr ctx a)

Defined in Database.Quibble

Methods

(/) :: Expr ctx a -> Expr ctx a -> Expr ctx a

recip :: Expr ctx a -> Expr ctx a

fromRational :: Rational -> Expr ctx a

(Show a, Num a) => Num (Expr ctx a)

Defined in Database.Quibble

Methods

(+) :: Expr ctx a -> Expr ctx a -> Expr ctx a

(-) :: Expr ctx a -> Expr ctx a -> Expr ctx a

(*) :: Expr ctx a -> Expr ctx a -> Expr ctx a

negate :: Expr ctx a -> Expr ctx a

abs :: Expr ctx a -> Expr ctx a

signum :: Expr ctx a -> Expr ctx a

fromInteger :: Integer -> Expr ctx a

IsString (Expr ctx String)

Defined in Database.Quibble

Methods

fromString :: String -> Expr ctx String

IsString (Expr ctx Text)

Defined in Database.Quibble

Methods

fromString :: String -> Expr ctx Text

IsString (Expr ctx Text)

Defined in Database.Quibble

Methods

fromString :: String -> Expr ctx Text

IsString (Expr ctx ByteString)

Defined in Database.Quibble

Methods

fromString :: String -> Expr ctx ByteString

IsString (Expr ctx ByteString)

Defined in Database.Quibble

Methods

fromString :: String -> Expr ctx ByteString

data SortExpr (ctx :: Type)

You can think of this as a wrapper around Expr that adds sorting direction. | Unfortunately, we can't allow ASC NULLS LAST or friends here because that's | not portable across database.

Constructors

Asc Builder

Desc Builder

CustomSort ByteString Builder

class KnownSymbol tbl => HasTable (ctx :: Type) (tbl :: Symbol) | ctx -> tbl

Allows us to lookup table name by type.

class KnownSymbol col => HasColumn (ctx :: Type) (col :: Symbol) (ty :: Type) | ctx col -> ty

Allows us to infer the column type from the table type and column name.

class Inline ty where

Methods

inline :: ty -> Expr ctx ty

Instances

Inline Bool

Defined in Database.Quibble

Methods

inline :: Bool -> Expr ctx Bool

Inline Int16

Defined in Database.Quibble

Methods

inline :: Int16 -> Expr ctx Int16

Inline Int32

Defined in Database.Quibble

Methods

inline :: Int32 -> Expr ctx Int32

Inline Int64

Defined in Database.Quibble

Methods

inline :: Int64 -> Expr ctx Int64

Inline Word16

Defined in Database.Quibble

Methods

inline :: Word16 -> Expr ctx Word16

Inline Word32

Defined in Database.Quibble

Methods

inline :: Word32 -> Expr ctx Word32

Inline Word64

Defined in Database.Quibble

Methods

inline :: Word64 -> Expr ctx Word64

Inline String

Defined in Database.Quibble

Methods

inline :: String -> Expr ctx String

Inline ByteString

Defined in Database.Quibble

Methods

inline :: ByteString -> Expr ctx ByteString

Inline ByteString

Defined in Database.Quibble

Methods

inline :: ByteString -> Expr ctx ByteString

Inline Text

Defined in Database.Quibble

Methods

inline :: Text -> Expr ctx Text

Inline Text

Defined in Database.Quibble

Methods

inline :: Text -> Expr ctx Text

Inline UTCTime

Defined in Database.Quibble

Methods

inline :: UTCTime -> Expr ctx UTCTime

Inline UUID

Defined in Database.Quibble

Methods

inline :: UUID -> Expr ctx UUID

query :: forall ctx. Query ctx

A Query is meant to represent everything in a SELECT statement, other | than the columns selection and the joined tables. | This is meant to be used with -XTypeApplications, like query @Foo.

rowsOf :: forall ctx. RowsOf ctx

A RowsOf is meant to represent the conditions of an UPDATE or DELETE. | This is meant to be used with -XTypeApplications, like rowsOf @Foo.

where_ :: DBWhere qry ctx => Expr ctx Bool -> qry -> qry

Add a condition to the Query or RowsOf. If where_ is used multiple times, | the condition will be ANDed together. | | > rowsOf @Foo | > & where_ (...)

orderBy :: Seq (SortExpr ctx) -> Query ctx -> Query ctx

Specify how the output should be sorted. If orderBy is used multiple times, | all sort expressions are concatenated together, with later calls having | lower sort precedence. | | -XOverloadedLists can help make specifying the list of sort expressions | simpler. | | > query @Foo | > & orderBy [asc col2]

limit :: Word64 -> Query ctx -> Query ctx

Set the number of rows specified by a LIMIT. If limit is used multiple | times, only the result of the last call matters. | | > query @Foo | > & limit 50

offset :: Word64 -> Query ctx -> Query ctx

Set the number of rows specified by an OFFSET. If offset is used | multiple times, only the result of the last call matters. | | > query Foo | > & offset 100 | | Note that in the general case, your query will still pay the cost of | looking up all the rows that were skipped! Be careful when using OFFSET@.

asc :: Expr ctx ty -> SortExpr ctx

desc :: Expr ctx ty -> SortExpr ctx

(.&&) :: Expr ctx Bool -> Expr ctx Bool -> Expr ctx Bool infixl 0

(.||) :: Expr ctx Bool -> Expr ctx Bool -> Expr ctx Bool infixl 1

(.==) :: Expr ctx a -> Expr ctx a -> Expr ctx Bool

(./=) :: Expr ctx a -> Expr ctx a -> Expr ctx Bool

true :: Expr ctx Bool

false :: Expr ctx Bool

isNull :: Expr ctx a -> Expr ctx Bool

isNotNull :: Expr ctx a -> Expr ctx Bool

(&) :: a -> (a -> b) -> b infixl 1

& is a reverse application operator. This provides notational convenience. Its precedence is one higher than that of the forward application operator $, which allows & to be nested in $.

>>> 5 & (+1) & show
"6"

Since: base-4.8.0.0