Safe Haskell	None
Language	Haskell2010

Database.SQLFragment.Operators

Contents

Combination
Columns Promotions
Combining & Formating
Type operations

Synopsis

Documentation

>>> :set -XOverloadedStrings
>>> :set -XDataKinds

>>> let toSelectQuery' q = unwords.lines.toSelectQuery $ q

Combination

(!&!) :: SQLFragment e p -> SQLFragment e' p' -> SQLFragment (HAppendList e e') (HAppendList p p') infixl 1

Combines two fragments. Similar to <> but combines phantom types as well.

>>> toSelectQuery' $ "a" !&! "t."
"SELECT a FROM t"
>>> toSelectQuery' $ "a" !&! "b"
"SELECT a, b"
>>> toSelectQuery' $ "t.a1" !&! "s.b" !&! "t.a2"
"SELECT t.a1, s.b, t.a2 FROM t, s"

(!#!) :: SQLFragment e p -> SQLFragment e' p' -> SQLFragment (HAppendList e e') (HAppendList p p') infixl 8

Same as !&! but higher fixity

Columns Promotions

(!\!) :: SQLFragment a b -> SQLFragment a' b' -> SQLFragment a (HAppendList b b') infixl 3

Promotes columns to the WHERE clause

>>> toSelectQuery' $ "" !\! "a > 1" !#! "b > 1"
"WHERE (a > 1) AND (b > 1)"
>>> toSelectQuery' $  "a" !\! "b > 1"
"SELECT a WHERE (b > 1)"

(!\\!) :: SQLFragment a b -> SQLFragment a' b' -> SQLFragment a (HAppendList b b')

Promotes columns to the HAVINg clause.

>>> toSelectQuery' $  "a" !\\! "b > 1"
"SELECT a HAVING (b > 1)"

(!~!) :: SQLFragment a b -> SQLFragment a' b' -> SQLFragment a (HAppendList b b')

Promotes columns to GROUP clause and criteria to HAVING Clauses

>>> toSelectQuery' $ "t.a" !~! ("a" !\! "b > 1")
"SELECT t.a FROM t GROUP BY a HAVING (b > 1)"

(!^!) :: SQLFragment a b -> SQLFragment a' [] -> SQLFragment a b

Promotes columns to ORDER BY clause (Ascending)

>>> toSelectQuery' $ "t.a" !^! "order"
"SELECT t.a FROM t ORDER BY order"

(!^-!) :: SQLFragment a b -> SQLFragment a' [] -> SQLFragment a b

Promotes columns to ORDER BY clause (Descending)

>>> toSelectQuery' $ "t.a" !^-! "order"
"SELECT t.a FROM t ORDER BY order DESC"

Combining & Formating

(!%!) :: SQLFragment e [] -> SQLFragment e [] -> SQLFragment e [] infixl 3

Replaces "$n" with columns. Can be chained to combined 2 or more columns into one.

>>> toSelectQuery' $ "IF($1>0, $1, 0)" !%! "t.a"
"SELECT IF(t.a>0, t.a, 0) FROM t"
>>> let a = forgetTypes $ "a1" !#! "b1" :: SQLFragment  '[String, Double] '[]
>>> let b =  forgetTypes $ "a2" !#! "b2" :: SQLFragment '[String, Double] '[]
>>> toSelectQuery' $ "$1 > $2" !%! a !%! b
"SELECT a1 > a2, b1 > b2"

(!%%!) :: SQLFragment e p -> SQLFragment e p -> SQLFragment e p infixl 3

Replace $1 with all the column together.

>>> toSelectQuery' $ "DISTINCT $1" !%%! "a" !#! "b"
"SELECT DISTINCT a, b"

Arithemitic operators

internOperator1 :: String -> SQLFragment e [] -> SQLFragment e' []

internOperator2 :: String -> SQLFragment e [] -> SQLFragment e [] -> SQLFragment e []

class Nums a

List of Num.

Instances

Nums ([] *)
(Num a, Nums as) => Nums ((:) * a as)

class Nums a => Fractionals a

List of Fractional.

Instances

Fractionals ([] *)
(Fractional a, Fractionals as) => Fractionals ((:) * a as)

Comparaison Operators

(!>!) :: SQLFragment a ([] *) -> SQLFragment b ([] *) -> SQLFragment (ZipToBool a b) ([] *) infixl 4

columns comparaison operators. Note the result is a column and has to be promoted to a where clause if necessary.

>>> let a = "a" :: SQLFragment '[String, Maybe Double, String] '[]
>>> let b = "b" :: SQLFragment '[Maybe String, Double, String] '[]
>>> :t a !>! b
a !>! b :: SQLFragment '[Maybe Bool, Maybe Bool, Bool] '[]
>>> toSelectQuery$ a !>! b
"SELECT (a)>(b)"
>>> let x = "x" :: SQLFragment '[String] '[]
>>> let y = "y" :: SQLFragment '[Int] '[]
>>> toSelectQuery'$ x !\! y !>! "5"
"SELECT x WHERE ((y)>(5))"

(!<!) :: SQLFragment a ([] *) -> SQLFragment b ([] *) -> SQLFragment (ZipToBool a b) ([] *) infixl 4

(!>=!) :: SQLFragment a ([] *) -> SQLFragment b ([] *) -> SQLFragment (ZipToBool a b) ([] *) infixl 4

(!<=!) :: SQLFragment a ([] *) -> SQLFragment b ([] *) -> SQLFragment (ZipToBool a b) ([] *) infixl 4

(!=!) :: SQLFragment a ([] *) -> SQLFragment b ([] *) -> SQLFragment (ZipToBool a b) ([] *) infixl 4

(!/=!) :: SQLFragment a ([] *) -> SQLFragment b ([] *) -> SQLFragment (ZipToBool a b) ([] *) infixl 4

(!&&!) :: SQLFragment a ([] *) -> SQLFragment b ([] *) -> SQLFragment (ZipToBool a b) ([] *) infixl 4

(!||!) :: SQLFragment a ([] *) -> SQLFragment b ([] *) -> SQLFragment (ZipToBool a b) ([] *) infixl 4

(!=%!) :: SQLFragment a ([] *) -> SQLFragment b ([] *) -> SQLFragment (ZipToBool a b) ([] *) infixl 4

(!=~!) :: SQLFragment a ([] *) -> SQLFragment b ([] *) -> SQLFragment (ZipToBool a b) ([] *) infixl 4

boolOperator :: String -> SQLFragment a [] -> SQLFragment b [] -> SQLFragment (ZipToBool a b) []

Comparaison

(!>?!) :: SQLFragment e p -> SQLFragment p' ([] *) -> SQLFragment e (HAppendList * p p') infixl 4

Comparaison operators with external parameters Note, the result is promoted as in where clause.

>>> let a = "a" :: SQLFragment '[String, Maybe Double, String] '[]
>>> let b = "b" :: SQLFragment '[String] '[]
>>> :t a !>?! b
a !>?! b :: SQLFragment '[String, Maybe Double, String] '[String]
>>> toSelectQuery' $ a !>?! b
"SELECT a WHERE ((b)>(?))"

(!<?!) :: SQLFragment e p -> SQLFragment p' ([] *) -> SQLFragment e (HAppendList * p p') infixl 4

(!>=?!) :: SQLFragment e p -> SQLFragment p' ([] *) -> SQLFragment e (HAppendList * p p') infixl 4

(!<=?!) :: SQLFragment e p -> SQLFragment p' ([] *) -> SQLFragment e (HAppendList * p p') infixl 4

(!=?!) :: SQLFragment e p -> SQLFragment p' ([] *) -> SQLFragment e (HAppendList * p p') infixl 4

(!/=?!) :: SQLFragment e p -> SQLFragment p' ([] *) -> SQLFragment e (HAppendList * p p') infixl 4

(!&&?!) :: SQLFragment e p -> SQLFragment p' ([] *) -> SQLFragment e (HAppendList * p p') infixl 4

(!||?!) :: SQLFragment e p -> SQLFragment p' ([] *) -> SQLFragment e (HAppendList * p p') infixl 4

(!=%?!) :: SQLFragment e p -> SQLFragment p' ([] *) -> SQLFragment e (HAppendList * p p') infixl 4

(!=~?!) :: SQLFragment e p -> SQLFragment p' ([] *) -> SQLFragment e (HAppendList * p p') infixl 4

buildBoolParamOp :: (SQLFragment p' [] -> SQLFragment b [] -> SQLFragment (ZipToBool p' b) []) -> SQLFragment e p -> SQLFragment p' [] -> SQLFragment e (HAppendList p p')

type family ZipToBool a b :: [*]

Equations

ZipToBool [] [] = []
ZipToBool (Tagged l a : as) (Tagged l' b : bs) = Tagged l (IfMaybe2 a b Bool) : ZipToBool as bs
ZipToBool (a : as) (b : bs) = IfMaybe2 a b Bool : ZipToBool as bs

Type operations

Full type

(!::!) :: SQLFragment e p -> SQLFragment e' p' -> SQLFragment e' p' infixl 1

Retype a fragment with the right one

(!#:!) :: SQLFragment e p -> SQLFragment e' p' -> SQLFragment e' p' infixl 8

Same as !::! but with higher fixity

Label

(!:@!) :: SQLFragment `[a]` p -> Label (l' :: Symbol) -> SQLFragment `[Tagged l' (GetValue a)]` p infixl 1

Label a fragment with the given label

(!#:@!) :: SQLFragment `[a]` p -> Label (l' :: Symbol) -> SQLFragment `[Tagged l' (GetValue a)]` p infixl 8

Same as !:@! but with hight fixity

Underlying Type

(!::#!) :: SQLFragment `[Tagged (l :: Symbol) a]` p -> SQLFragment `[b]` [] -> SQLFragment `[Tagged l (GetValue b)]` p infixl 1

Change the underlying type but keep the actual label

(!#:#!) :: SQLFragment `[Tagged (l :: Symbol) a]` p -> SQLFragment `[b]` [] -> SQLFragment `[Tagged l (GetValue b)]` p infixl 8