Automatically Generating Types for Tables with Large Numbers of Columns

[idontgetoutmuch]

How do folks create types for tables with 100 columns? Doing it by hand is extremely tedious.

I had a look at opaleye-gen but it is very bit-rotted and even when I got it to compile, it failed on a particular table type opaleye-gen: Unimplemented PostgresQL type conversion for "bpchar".

I can automate some of what I need by exporting the table to CSV and then using Frames but it is still a pain.

[ocharles]

PostgreSQL has all information about tables itself as metadata tables. What I tend to do is to query this metadata in a SELECT statement, and I format it with a bunch of string_agg and stuff so that it actually produces Haskell. Have a look at #59, which I think shows some of these metadata tables. Infact, that very PR might do the job for you.

[idontgetoutmuch]

It did most of what I wanted. So you have to use the entire branch not just the script (not a problem once you know). I also ended up with

type Float4 = Float
type Bpchar = Text

instance DBType IsPreSal where
  typeInformation = parseTypeInformation parser printer typeInformation
    where
      parser :: Text -> Either String IsPreSal
      parser = unlanguage

      printer :: IsPreSal -> Text
      printer = language

as I had already

class Language a where
  language :: a -> Text

unlanguage :: forall a . (Enum a, Bounded a, Language a) => Text -> Either String a
unlanguage y = case lookup y (let x = [minBound :: a .. maxBound :: a] in zip (map language x) x) of
  Nothing -> Left $ T.unpack y
  Just z ->  Right z

data IsPreSal = NonPreSal | HasPreSal
  deriving (Eq, Read, Show, Enum, Bounded, Data)

instance Language IsPreSal where
  language c = case c of
    NonPreSal -> "NonPreSal"
    HasPreSal -> "HasPreSal"