{-# LANGUAGE FlexibleContexts,ConstraintKinds #-}
-- | Overloaded functions to convert SQL rows (query result) to tuples
module SqlRows where
import Database.HDBC
import Data.Convertible.Base

type Row  = [SqlValue]
type Rows = [Row]

-- * Converting SQL rows to tuples of normal Haskell values
-- ** Monadic functions (raise errors in the monad on conversion failures)

fromRowM :: (FromRow a,Monad m) => Row -> m a
fromRowM  r  = either (fail.prettyConvertError) return (safeFromRow r)

fromRowsM :: (FromRow a,Monad m) => Rows -> m [a]
fromRowsM rs = mapM fromRowM rs

-- ** Pure functions (call 'error' on conversion failures)

fromRow :: FromRow a => Row -> a
fromRow  r  = either (error.prettyConvertError) id (safeFromRow r)

fromRows :: FromRow a => Rows -> [a]
fromRows rs = map fromRow rs

--------------------------------------------------------------------------------

class FromRow a where safeFromRow :: Row -> ConvertResult a

type FromSql a = Convertible SqlValue a

fromRowError row dst =
  Left (ConvertError (show row) "Row" dst "row size mismatch")

instance (FromSql a,FromSql b) => FromRow (a,b) where
  safeFromRow [a,b] = (,) <$> sf a <*> sf b
  safeFromRow row = fromRowError row "(,)"

instance (FromSql a,FromSql b,FromSql c) => FromRow (a,b,c) where
  safeFromRow [a,b,c] = (,,) <$> sf a <*> sf b <*> sf c
  safeFromRow row = fromRowError row "(,,)"

instance (FromSql a,FromSql b,FromSql c,FromSql d) => FromRow (a,b,c,d) where
  safeFromRow [a,b,c,d] = (,,,) <$> sf a <*> sf b <*> sf c <*> sf d
  safeFromRow row = fromRowError row "(,,,)"

instance (FromSql a,FromSql b,FromSql c,FromSql d,FromSql e)
         => FromRow (a,b,c,d,e) where
  safeFromRow [a,b,c,d,e] = (,,,,) <$> sf a <*> sf b <*> sf c <*> sf d <*> sf e
  safeFromRow row = fromRowError row "(,,,,)"

instance (FromSql a,FromSql b,FromSql c,FromSql d,FromSql e,FromSql f)
         => FromRow (a,b,c,d,e,f) where
  safeFromRow [a,b,c,d,e,f] = (,,,,,) <$> sf a <*> sf b <*> sf c <*> sf d <*> sf e <*> sf f
  safeFromRow row = fromRowError row "(,,,,,)"

instance (FromSql a,FromSql b,FromSql c,FromSql d,FromSql e,FromSql f,FromSql g)
         => FromRow (a,b,c,d,e,f,g) where
  safeFromRow [a,b,c,d,e,f,g] = (,,,,,,) <$> sf a <*> sf b <*> sf c <*> sf d <*> sf e <*> sf f <*> sf g
  safeFromRow row = fromRowError row "(,,,,,,)"

sf x = safeFromSql x