Request for docs: How to handle ENUM?

[saurabhnanda]

Couldn't find how to handle ENUMs in the tutorial docs. How do I make tenant_status in the following schema an ADT in Opaleye?

create type tenant_status as enum('active', 'inactive');
create table tenants(
       id serial primary key
       ,created_at timestamp without time zone not null default current_timestamp
       ,updated_at timestamp without time zone not null default current_timestamp
       ,name text not null
       ,status tenant_status not null default 'inactive'
       ,owner_id integer
       ,backoffice_domain text not null
       constraint ensure_not_null_owner_id check (tenent_status!='active' or owner_id is not null)
);

[matsumonkie]

Say you have:

data Gender = Female | Male deriving (Eq, Show, Generic)

data User' a = User'
  {  usrGender :: a
  } deriving (Eq, Show, Generic)

type User = User' (Gender)
type RUserColumn = User' (Column PGText)
type WUserColumn = User' (Column PGText)

One way to have your usrGender attribute parsed from PG to your code is by having Gender override FromField and QueryRunnerColumnDefault:

instance FromField (Gender) where
  fromField f mdata =
    return gender
    where
      gender = case mdata of
        Just "female" -> Female
        Just "male" -> Male
        _ -> Male

instance QueryRunnerColumnDefault PGText Gender where
  queryRunnerColumnDefault = fieldQueryRunnerColumn

So for your example, I guess you need to do the same with but with your enum type.
There are other possible ways to deal with this case

I Hope it helps :-)

[saurabhnanda]

Thanks @matsumonkie this solved my problem.

[saurabhnanda]

@matsumonkie @tomjaguarpaw do you know how to set-up the default Haskell => PG mapping for ENUMS? I managed to get the following:

instance ToField TenantStatus where
  toField ts = case ts of
    TenantActive -> toField "active"
    TenantInactive -> toField "inactive"
    TenantNew -> toField "new"

but I'm unable to figure out how to get Opalaye to use it:

activateTenant :: TenantId -> AppM (Tenant)
activateTenant tenantId@(TenantId tid) = do
  conn <- askDbConnection
  liftIO $ do 
    _ <- runUpdate conn tenantTable
      -- ERROR: Couldn't match type ‘Column PGText’ with ‘Database.PostgreSQL.Simple.ToField.Action’
      (\tenant -> (tenantPGReadToWrite tenant) & status .~ toField TenantActive)
      -- (\tenant -> tenantPGReadToWrite tenant)
      (\tenant -> (tenant ^. key .== pgInt8 tid))
    head <$> runQuery conn (tenantById tenantId)

[tomjaguarpaw]

I don't think Opaleye uses ToField. I don't even remember knowing that existed. Don't you want a Constant instance instead?

[tomjaguarpaw]

(Perhaps Constant should use ToField. Issue filed here: #214 )

[saurabhnanda]

Don't you want a Constant instance instead?

How do I use Constant in the code I mentioned above?

[tomjaguarpaw]

You'd write constant TenantActive instead of toField TenantActive. But in this case you don't really win much since you have to implement the Constant instance by hand anyway. It would be pretty much the same as your ToField instance.

[tomjaguarpaw]

Actually I prefer this implementation of FromField

{-# LANGUAGE MultiParamTypeClasses #-}
{-# LANGUAGE DeriveDataTypeable    #-}

import Opaleye
import Database.PostgreSQL.Simple.FromField
import Data.Typeable

data Gender = Female | Male deriving Typeable
data PGGender

instance FromField Gender where
  fromField f mdata = fromField f mdata >>= parseGender
    where parseGender genderString = case genderString of
            "female" -> return Female
            "male"   -> return Male
            _        -> returnError ConversionFailed f ("Unexpected gender: " ++ genderString)

instance QueryRunnerColumnDefault PGGender Gender where
  queryRunnerColumnDefault = fieldQueryRunnerColumn

[saurabhnanda]

instance QueryRunnerColumnDefault PGText Gender where
  queryRunnerColumnDefault = fieldQueryRunnerColumn

What if the gender column is implemented as under in Postgres:

create type gender as enum('male', 'female');

[tomjaguarpaw]

What if the gender column is implemented as under in Postgres:

I corrected that oversight. It now maps from PGGender not PGText.

[sras]

@tomjaguarpaw How would you implement the instance for, Default Constant Gender (Column PGGender). This is required if if we want to save this type to the db right?

[tomjaguarpaw]

{-# LANGUAGE MultiParamTypeClasses #-}
{-# LANGUAGE DeriveDataTypeable    #-}
{-# LANGUAGE FlexibleInstances     #-}

import Data.Typeable
import Database.PostgreSQL.Simple.FromField
import Data.Profunctor.Product.Default
import Data.Profunctor
import Opaleye

data Gender = Female | Male deriving Typeable
data PGGender

instance FromField (Gender) where
  fromField f mdata = fromField f mdata >>= parseGender
    where parseGender genderString = case genderString of
            "female" -> return Female
            "male"   -> return Male
            _        -> returnError ConversionFailed f ("Unexpected gender: " ++ genderString)

instance QueryRunnerColumnDefault PGText Gender where
  queryRunnerColumnDefault = fieldQueryRunnerColumn

constantColumnUsing :: Constant haskell (Column pgType)
                    -> (haskell' -> haskell)
                    -> Constant haskell' (Column pgType')
constantColumnUsing oldConstant f = dimap f unsafeCoerceColumn oldConstant

instance Default Constant Gender (Column PGGender) where
  def = constantColumnUsing (def :: Constant String (Column PGText)) genderToString

    where genderToString :: Gender -> String
          genderToString gender = case gender of
            Male   -> "male"
            Female -> "female"

[tomjaguarpaw]

I added the Default Constant instance.