A decoder for a single field/column.

A FieldDecoder that accepts and decodes SQL NULLs into Nothing values for a given decoder.

Derives FromPgRow generically.

For the very common case of a Haskell enum matching a custom postgres enum type that has its values all as lower case strings, this newtype can help you derive instances as such:

data Mood = Sad | Ok | Happy
  deriving stock (Generic)
  deriving (FromPgField, ToPgField) via (LowerCasedPgEnum Mood)

And this would match the Postgres equivalent:

CREATE TYPE mood AS ENUM ('sad', 'ok', 'happy');

If you run into PostgreSQL type inference problems with this, you can write instances manually with genericEnumFieldDecoder, genericEnumFieldEncoder, typeFieldEncoder, and typeFieldDecoder.

One of the functions behind LowerCasedPgEnum, but you can decide how to map your type's constructor names arbitrarily, which can be useful if you're not using lowercase values in your postgres enums.

One of the functions behind LowerCasedPgEnum, but you can decide how to map your type's constructor names arbitrarily, which can be useful if you're not using lowercase values in your postgres enums.

Allows you to create a FieldDecoder for composite types. For a type such as:

CREATE TYPE int_and_bool AS (numfield INT, boolfield BOOL);

You can define a Haskell type as such:

data IntAndBool = IntAndBool Int Bool

instance FromPgField IntAndBool where
  fieldDecoder = compositeTypeDecoder rowDecoder <&> \(i, b) -> IntAndBool i b

Allows you to create a FieldEncoder for composite types. For a type such as:

CREATE TYPE int_and_bool AS (numfield INT, boolfield BOOL);

You can define a Haskell type as such:

data IntAndBool = IntAndBool Int Bool

instance ToPgField IntAndBool where
  fieldEncoder = typeFieldEncoder (typeOidWithName "int_and_bool")
    $ compositeTypeEncoder $ contramap (\(IntAndBool i b) -> (fromIntegral i :: Int32, b)) rowEncoder

Allows you to specify a type (and other checks, possibly) for a FieldDecoder. This can be useful to ensure you're not accidentally decoding a different type.

data MyEnum = Val1 | Val2 | Val3
myEnumFieldDecoderWithTypeInfoCheck :: FieldDecoder MyEnum
myEnumFieldDecoderWithTypeInfoCheck =
  let convert = \case
        "val1" -> Val1
        "val2" -> Val2
        "val3" -> Val3
        _ -> error "Invalid value for MyEnum"
   in typeFieldDecoder
        (typeMustBeNamed "my_enum")
        $ convert <$> rawBytesFieldDecoder

This will work unless you use non-default flags in your connection options.

Allows you to specify a type for a FieldEncoder. This can be useful to avoid letting postgres infer types itself, which can cause errors. For example:

data MyEnum = Val1 | Val2 | Val3
myEnumFieldDecoderWithTypeInfoCheck :: FieldEncoder MyEnum
myEnumFieldDecoderWithTypeInfoCheck =
  let convert = \case
        Val1 -> "val1" :: Text
        Val2 -> "val2"
        Val3 -> "val3"
   in typeFieldEncoder
        (typeOidWithName "my_enum")
        $ contramap convert fieldEncoder

This will work unless you use non-default flags in your connection options.

A decoder that accepts any PG type and returns the object's postgres' binary representation as a ByteString.

Returns a FieldEncoder that is sent without a type OID in queries. This means postgres will try to infer the type of these arguments. Check typedFieldEncoder if you're interested in encoding your custom types, you probably don't need this.

Returns a field-encoding function for a vector-like Foldable (e.g. Lists and Vector itself).

A FieldDecoder that accepts and decodes Postgres arrays.