| Copyright | (c) Eitan Chatav 2017 |
|---|---|
| Maintainer | eitan@morphism.tech |
| Stability | experimental |
| Safe Haskell | None |
| Language | Haskell2010 |
Squeal.PostgreSQL.Binary
Description
Binary encoding and decoding between Haskell and PostgreSQL types.
- class ToParam (x :: Type) (pg :: PGType) where
- class ToColumnParam (x :: Type) (ty :: ColumnType) where
- class SListI tys => ToParams (x :: Type) (tys :: [ColumnType]) where
- class FromValue (pg :: PGType) (y :: Type) where
- class FromColumnValue (colty :: (Symbol, ColumnType)) (y :: Type) where
- class SListI results => FromRow (results :: ColumnsType) y where
- newtype Only x = Only {
- fromOnly :: x
Encoding
class ToParam (x :: Type) (pg :: PGType) where #
A ToParam constraint gives an encoding of a Haskell Type into
into the binary format of a PostgreSQL PGType.
Minimal complete definition
Methods
toParam :: x -> K Encoding pg #
>>>:set -XTypeApplications -XDataKinds>>>toParam @Bool @'PGbool FalseK "\NUL"
>>>toParam @Int16 @'PGint2 0K "\NUL\NUL"
>>>toParam @Int32 @'PGint4 0K "\NUL\NUL\NUL\NUL"
>>>:set -XMultiParamTypeClasses>>>newtype Id = Id { getId :: Int16 } deriving Show>>>instance ToParam Id 'PGint2 where toParam = toParam . getId>>>toParam @Id @'PGint2 (Id 1)K "\NUL\SOH"
Instances
class ToColumnParam (x :: Type) (ty :: ColumnType) where #
A ToColumnParam constraint lifts the ToParam encoding
of a Type to a ColumnType, encoding Maybes to Nulls. You should
not define instances of ToColumnParam, just use the provided instances.
Minimal complete definition
Methods
toColumnParam :: x -> K (Maybe ByteString) ty #
>>>toColumnParam @Int16 @('Required ('NotNull 'PGint2)) 0K (Just "\NUL\NUL")
>>>toColumnParam @(Maybe Int16) @('Required ('Null 'PGint2)) (Just 0)K (Just "\NUL\NUL")
>>>toColumnParam @(Maybe Int16) @('Required ('Null 'PGint2)) NothingK Nothing
Instances
| ToParam x pg => ToColumnParam x (optionality (NotNull pg)) # | |
| ToParam x pg => ToColumnParam (Maybe x) (optionality (Null pg)) # | |
class SListI tys => ToParams (x :: Type) (tys :: [ColumnType]) where #
A ToParams constraint generically sequences the encodings of Types
of the fields of a tuple or record to a row of ColumnTypes. You should
not define instances of ToParams. Instead define Generic instances
which in turn provide ToParams instances.
Minimal complete definition
Methods
toParams :: x -> NP (K (Maybe ByteString)) tys #
>>>type PGparams = '[ 'Required ('NotNull 'PGbool), 'Required ('Null 'PGint2)]>>>toParams @(Bool, Maybe Int16) @PGparams (False, Just 0)K (Just "\NUL") :* (K (Just "\NUL\NUL") :* Nil)
>>>:set -XDeriveGeneric>>>data Hparams = Hparams { col1 :: Bool, col2 :: Maybe Int16} deriving GHC.Generic>>>instance Generic Hparams>>>toParams @Hparams @PGparams (Hparams False (Just 0))K (Just "\NUL") :* (K (Just "\NUL\NUL") :* Nil)
Instances
| (SListI ColumnType tys, IsProductType x xs, AllZip Type ColumnType ToColumnParam xs tys) => ToParams x tys # | |
Decoding
class FromValue (pg :: PGType) (y :: Type) where #
A FromValue constraint gives a parser from the binary format of
a PostgreSQL PGType into a Haskell Type.
Minimal complete definition
Methods
fromValue :: proxy pg -> Value y #
>>>newtype Id = Id { getId :: Int16 } deriving Show>>>instance FromValue 'PGint2 Id where fromValue = fmap Id . fromValue
Instances
class FromColumnValue (colty :: (Symbol, ColumnType)) (y :: Type) where #
A FromColumnValue constraint lifts the FromValue parser
to a decoding of a (Symbol, ColumnType) to a Type,
decoding Nulls to Maybes. You should not define instances for
FromColumnValue, just use the provided instances.
Minimal complete definition
Methods
fromColumnValue :: K (Maybe ByteString) colty -> y #
>>>:set -XTypeOperators -XOverloadedStrings>>>newtype Id = Id { getId :: Int16 } deriving Show>>>instance FromValue 'PGint2 Id where fromValue = fmap Id . fromValue>>>fromColumnValue @("col" ::: 'Required ('NotNull 'PGint2)) @Id (K (Just "\NUL\SOH"))Id {getId = 1}
>>>fromColumnValue @("col" ::: 'Required ('Null 'PGint2)) @(Maybe Id) (K (Just "\NUL\SOH"))Just (Id {getId = 1})
Instances
| FromValue pg y => FromColumnValue ((:::) ColumnType column (Required (NotNull pg))) y # | |
| FromValue pg y => FromColumnValue ((:::) ColumnType column (Required (Null pg))) (Maybe y) # | |
class SListI results => FromRow (results :: ColumnsType) y where #
A FromRow constraint generically sequences the parsings of the columns
of a ColumnsType into the fields of a record Type provided they have
the same field names. You should not define instances of FromRow.
Instead define Generic and HasDatatypeInfo instances which in turn
provide FromRow instances.
Minimal complete definition
Methods
fromRow :: NP (K (Maybe ByteString)) results -> y #
>>>:set -XOverloadedStrings>>>import Data.Text>>>newtype Id = Id { getId :: Int16 } deriving Show>>>instance FromValue 'PGint2 Id where fromValue = fmap Id . fromValue>>>data Hrow = Hrow { userId :: Id, userName :: Maybe Text } deriving (Show, GHC.Generic)>>>instance Generic Hrow>>>instance HasDatatypeInfo Hrow>>>type PGrow = '["userId" ::: 'Required ('NotNull 'PGint2), "userName" ::: 'Required ('Null 'PGtext)]>>>fromRow @PGrow @Hrow (K (Just "\NUL\SOH") :* K (Just "bloodninja") :* Nil)Hrow {userId = Id {getId = 1}, userName = Just "bloodninja"}
Instances
| (SListI (Symbol, ColumnType) results, IsProductType y ys, AllZip (Symbol, ColumnType) Type FromColumnValue results ys, SameFields (DatatypeInfoOf y) results) => FromRow results y # | |
Only
Only is a 1-tuple type, useful for encoding a single parameter with
toParams or decoding a single value with fromRow.
>>>import Data.Text>>>toParams @(Only (Maybe Text)) @'[ 'Required ('Null 'PGtext)] (Only (Just "foo"))K (Just "foo") :* Nil
>>>type PGShortRow = '["fromOnly" ::: 'Required ('Null 'PGtext)]>>>fromRow @PGShortRow @(Only (Maybe Text)) (K (Just "bar") :* Nil)Only {fromOnly = Just "bar"}