{-# LANGUAGE BangPatterns, OverloadedStrings #-}

-- |
-- Module:      Database.MySQL.Simpe.QueryResults
-- Copyright:   (c) 2011 MailRank, Inc.
-- License:     BSD3
-- Maintainer:  Paul Rouse <pyr@doynton.org>
-- Stability:   experimental
-- Portability: portable
--
-- The 'QueryResults' typeclass, for converting a row of results
-- returned by a SQL query into a more useful Haskell representation.
--
-- Predefined instances are provided for tuples containing up to ten
-- elements.

module Database.MySQL.Simple.QueryResults
    (
      QueryResults(..)
    , convertError
    ) where

import Control.Exception (throw)
import Data.ByteString (ByteString)
import qualified Data.ByteString.Char8 as B
import Database.MySQL.Base.Types (Field(fieldType, fieldName))
import Database.MySQL.Simple.Result (ResultError(..), Result(..))
import Database.MySQL.Simple.Types (Only(..))

-- | A collection type that can be converted from a list of strings.
--
-- Instances should use the 'convert' method of the 'Result' class
-- to perform conversion of each element of the collection.
--
-- This example instance demonstrates how to convert a two-column row
-- into a Haskell pair. Each field in the metadata is paired up with
-- each value from the row, and the two are passed to 'convert'.
--
-- @
-- instance ('Result' a, 'Result' b) => 'QueryResults' (a,b) where
--     'convertResults' [fa,fb] [va,vb] = (a,b)
--         where !a = 'convert' fa va
--               !b = 'convert' fb vb
--     'convertResults' fs vs  = 'convertError' fs vs 2
-- @
--
-- Notice that this instance evaluates each element to WHNF before
-- constructing the pair. By doing this, we guarantee two important
-- properties:
--
-- * Keep resource usage under control by preventing the construction
--   of potentially long-lived thunks.
--
-- * Ensure that any 'ResultError' that might arise is thrown
--   immediately, rather than some place later in application code
--   that cannot handle it.
--
-- You can also declare Haskell types of your own to be instances of
-- 'QueryResults'.
--
-- @
--data User = User { firstName :: String, lastName :: String }
--
--instance 'QueryResults' User where
--    'convertResults' [fa,fb] [va,vb] = User <$> a <*> b
--        where !a = 'convert' fa va
--              !b = 'convert' fb vb
--    'convertResults' fs vs  = 'convertError' fs vs 2
-- @

class QueryResults a where
    convertResults :: [Field] -> [Maybe ByteString] -> a
    -- ^ Convert values from a row into a Haskell collection.
    --
    -- This function will throw a 'ResultError' if conversion of the
    -- collection fails.

instance (Result a) => QueryResults (Only a) where
    convertResults :: [Field] -> [Maybe ByteString] -> Only a
convertResults [Field
fa] [Maybe ByteString
va] = a -> Only a
forall a. a -> Only a
Only a
a
        where !a :: a
a = Field -> Maybe ByteString -> a
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fa Maybe ByteString
va
    convertResults [Field]
fs [Maybe ByteString]
vs  = [Field] -> [Maybe ByteString] -> Int -> Only a
forall a. [Field] -> [Maybe ByteString] -> Int -> a
convertError [Field]
fs [Maybe ByteString]
vs Int
1

instance (Result a, Result b) => QueryResults (a,b) where
    convertResults :: [Field] -> [Maybe ByteString] -> (a, b)
convertResults [Field
fa,Field
fb] [Maybe ByteString
va,Maybe ByteString
vb] = (a
a,b
b)
        where !a :: a
a = Field -> Maybe ByteString -> a
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fa Maybe ByteString
va; !b :: b
b = Field -> Maybe ByteString -> b
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fb Maybe ByteString
vb
    convertResults [Field]
fs [Maybe ByteString]
vs  = [Field] -> [Maybe ByteString] -> Int -> (a, b)
forall a. [Field] -> [Maybe ByteString] -> Int -> a
convertError [Field]
fs [Maybe ByteString]
vs Int
2

instance (Result a, Result b, Result c) => QueryResults (a,b,c) where
    convertResults :: [Field] -> [Maybe ByteString] -> (a, b, c)
convertResults [Field
fa,Field
fb,Field
fc] [Maybe ByteString
va,Maybe ByteString
vb,Maybe ByteString
vc] = (a
a,b
b,c
c)
        where !a :: a
a = Field -> Maybe ByteString -> a
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fa Maybe ByteString
va; !b :: b
b = Field -> Maybe ByteString -> b
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fb Maybe ByteString
vb; !c :: c
c = Field -> Maybe ByteString -> c
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fc Maybe ByteString
vc
    convertResults [Field]
fs [Maybe ByteString]
vs  = [Field] -> [Maybe ByteString] -> Int -> (a, b, c)
forall a. [Field] -> [Maybe ByteString] -> Int -> a
convertError [Field]
fs [Maybe ByteString]
vs Int
3

instance (Result a, Result b, Result c, Result d) =>
    QueryResults (a,b,c,d) where
    convertResults :: [Field] -> [Maybe ByteString] -> (a, b, c, d)
convertResults [Field
fa,Field
fb,Field
fc,Field
fd] [Maybe ByteString
va,Maybe ByteString
vb,Maybe ByteString
vc,Maybe ByteString
vd] = (a
a,b
b,c
c,d
d)
        where !a :: a
a = Field -> Maybe ByteString -> a
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fa Maybe ByteString
va; !b :: b
b = Field -> Maybe ByteString -> b
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fb Maybe ByteString
vb; !c :: c
c = Field -> Maybe ByteString -> c
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fc Maybe ByteString
vc
              !d :: d
d = Field -> Maybe ByteString -> d
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fd Maybe ByteString
vd
    convertResults [Field]
fs [Maybe ByteString]
vs  = [Field] -> [Maybe ByteString] -> Int -> (a, b, c, d)
forall a. [Field] -> [Maybe ByteString] -> Int -> a
convertError [Field]
fs [Maybe ByteString]
vs Int
4

instance (Result a, Result b, Result c, Result d, Result e) =>
    QueryResults (a,b,c,d,e) where
    convertResults :: [Field] -> [Maybe ByteString] -> (a, b, c, d, e)
convertResults [Field
fa,Field
fb,Field
fc,Field
fd,Field
fe] [Maybe ByteString
va,Maybe ByteString
vb,Maybe ByteString
vc,Maybe ByteString
vd,Maybe ByteString
ve] = (a
a,b
b,c
c,d
d,e
e)
        where !a :: a
a = Field -> Maybe ByteString -> a
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fa Maybe ByteString
va; !b :: b
b = Field -> Maybe ByteString -> b
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fb Maybe ByteString
vb; !c :: c
c = Field -> Maybe ByteString -> c
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fc Maybe ByteString
vc
              !d :: d
d = Field -> Maybe ByteString -> d
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fd Maybe ByteString
vd; !e :: e
e = Field -> Maybe ByteString -> e
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fe Maybe ByteString
ve
    convertResults [Field]
fs [Maybe ByteString]
vs  = [Field] -> [Maybe ByteString] -> Int -> (a, b, c, d, e)
forall a. [Field] -> [Maybe ByteString] -> Int -> a
convertError [Field]
fs [Maybe ByteString]
vs Int
5

instance (Result a, Result b, Result c, Result d, Result e, Result f) =>
    QueryResults (a,b,c,d,e,f) where
    convertResults :: [Field] -> [Maybe ByteString] -> (a, b, c, d, e, f)
convertResults [Field
fa,Field
fb,Field
fc,Field
fd,Field
fe,Field
ff] [Maybe ByteString
va,Maybe ByteString
vb,Maybe ByteString
vc,Maybe ByteString
vd,Maybe ByteString
ve,Maybe ByteString
vf] = (a
a,b
b,c
c,d
d,e
e,f
f)
        where !a :: a
a = Field -> Maybe ByteString -> a
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fa Maybe ByteString
va; !b :: b
b = Field -> Maybe ByteString -> b
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fb Maybe ByteString
vb; !c :: c
c = Field -> Maybe ByteString -> c
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fc Maybe ByteString
vc
              !d :: d
d = Field -> Maybe ByteString -> d
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fd Maybe ByteString
vd; !e :: e
e = Field -> Maybe ByteString -> e
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fe Maybe ByteString
ve; !f :: f
f = Field -> Maybe ByteString -> f
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
ff Maybe ByteString
vf
    convertResults [Field]
fs [Maybe ByteString]
vs  = [Field] -> [Maybe ByteString] -> Int -> (a, b, c, d, e, f)
forall a. [Field] -> [Maybe ByteString] -> Int -> a
convertError [Field]
fs [Maybe ByteString]
vs Int
6

instance (Result a, Result b, Result c, Result d, Result e, Result f,
          Result g) =>
    QueryResults (a,b,c,d,e,f,g) where
    convertResults :: [Field] -> [Maybe ByteString] -> (a, b, c, d, e, f, g)
convertResults [Field
fa,Field
fb,Field
fc,Field
fd,Field
fe,Field
ff,Field
fg] [Maybe ByteString
va,Maybe ByteString
vb,Maybe ByteString
vc,Maybe ByteString
vd,Maybe ByteString
ve,Maybe ByteString
vf,Maybe ByteString
vg] =
        (a
a,b
b,c
c,d
d,e
e,f
f,g
g)
        where !a :: a
a = Field -> Maybe ByteString -> a
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fa Maybe ByteString
va; !b :: b
b = Field -> Maybe ByteString -> b
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fb Maybe ByteString
vb; !c :: c
c = Field -> Maybe ByteString -> c
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fc Maybe ByteString
vc
              !d :: d
d = Field -> Maybe ByteString -> d
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fd Maybe ByteString
vd; !e :: e
e = Field -> Maybe ByteString -> e
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fe Maybe ByteString
ve; !f :: f
f = Field -> Maybe ByteString -> f
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
ff Maybe ByteString
vf
              !g :: g
g = Field -> Maybe ByteString -> g
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fg Maybe ByteString
vg
    convertResults [Field]
fs [Maybe ByteString]
vs  = [Field] -> [Maybe ByteString] -> Int -> (a, b, c, d, e, f, g)
forall a. [Field] -> [Maybe ByteString] -> Int -> a
convertError [Field]
fs [Maybe ByteString]
vs Int
7

instance (Result a, Result b, Result c, Result d, Result e, Result f,
          Result g, Result h) =>
    QueryResults (a,b,c,d,e,f,g,h) where
    convertResults :: [Field] -> [Maybe ByteString] -> (a, b, c, d, e, f, g, h)
convertResults [Field
fa,Field
fb,Field
fc,Field
fd,Field
fe,Field
ff,Field
fg,Field
fh] [Maybe ByteString
va,Maybe ByteString
vb,Maybe ByteString
vc,Maybe ByteString
vd,Maybe ByteString
ve,Maybe ByteString
vf,Maybe ByteString
vg,Maybe ByteString
vh] =
        (a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h)
        where !a :: a
a = Field -> Maybe ByteString -> a
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fa Maybe ByteString
va; !b :: b
b = Field -> Maybe ByteString -> b
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fb Maybe ByteString
vb; !c :: c
c = Field -> Maybe ByteString -> c
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fc Maybe ByteString
vc
              !d :: d
d = Field -> Maybe ByteString -> d
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fd Maybe ByteString
vd; !e :: e
e = Field -> Maybe ByteString -> e
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fe Maybe ByteString
ve; !f :: f
f = Field -> Maybe ByteString -> f
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
ff Maybe ByteString
vf
              !g :: g
g = Field -> Maybe ByteString -> g
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fg Maybe ByteString
vg; !h :: h
h = Field -> Maybe ByteString -> h
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fh Maybe ByteString
vh
    convertResults [Field]
fs [Maybe ByteString]
vs  = [Field] -> [Maybe ByteString] -> Int -> (a, b, c, d, e, f, g, h)
forall a. [Field] -> [Maybe ByteString] -> Int -> a
convertError [Field]
fs [Maybe ByteString]
vs Int
8

instance (Result a, Result b, Result c, Result d, Result e, Result f,
          Result g, Result h, Result i) =>
    QueryResults (a,b,c,d,e,f,g,h,i) where
    convertResults :: [Field] -> [Maybe ByteString] -> (a, b, c, d, e, f, g, h, i)
convertResults [Field
fa,Field
fb,Field
fc,Field
fd,Field
fe,Field
ff,Field
fg,Field
fh,Field
fi] [Maybe ByteString
va,Maybe ByteString
vb,Maybe ByteString
vc,Maybe ByteString
vd,Maybe ByteString
ve,Maybe ByteString
vf,Maybe ByteString
vg,Maybe ByteString
vh,Maybe ByteString
vi] =
        (a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i)
        where !a :: a
a = Field -> Maybe ByteString -> a
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fa Maybe ByteString
va; !b :: b
b = Field -> Maybe ByteString -> b
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fb Maybe ByteString
vb; !c :: c
c = Field -> Maybe ByteString -> c
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fc Maybe ByteString
vc
              !d :: d
d = Field -> Maybe ByteString -> d
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fd Maybe ByteString
vd; !e :: e
e = Field -> Maybe ByteString -> e
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fe Maybe ByteString
ve; !f :: f
f = Field -> Maybe ByteString -> f
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
ff Maybe ByteString
vf
              !g :: g
g = Field -> Maybe ByteString -> g
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fg Maybe ByteString
vg; !h :: h
h = Field -> Maybe ByteString -> h
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fh Maybe ByteString
vh; !i :: i
i = Field -> Maybe ByteString -> i
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fi Maybe ByteString
vi
    convertResults [Field]
fs [Maybe ByteString]
vs  = [Field] -> [Maybe ByteString] -> Int -> (a, b, c, d, e, f, g, h, i)
forall a. [Field] -> [Maybe ByteString] -> Int -> a
convertError [Field]
fs [Maybe ByteString]
vs Int
9

instance (Result a, Result b, Result c, Result d, Result e, Result f,
          Result g, Result h, Result i, Result j) =>
    QueryResults (a,b,c,d,e,f,g,h,i,j) where
    convertResults :: [Field] -> [Maybe ByteString] -> (a, b, c, d, e, f, g, h, i, j)
convertResults [Field
fa,Field
fb,Field
fc,Field
fd,Field
fe,Field
ff,Field
fg,Field
fh,Field
fi,Field
fj]
                   [Maybe ByteString
va,Maybe ByteString
vb,Maybe ByteString
vc,Maybe ByteString
vd,Maybe ByteString
ve,Maybe ByteString
vf,Maybe ByteString
vg,Maybe ByteString
vh,Maybe ByteString
vi,Maybe ByteString
vj] =
        (a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i,j
j)
        where !a :: a
a = Field -> Maybe ByteString -> a
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fa Maybe ByteString
va; !b :: b
b = Field -> Maybe ByteString -> b
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fb Maybe ByteString
vb; !c :: c
c = Field -> Maybe ByteString -> c
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fc Maybe ByteString
vc
              !d :: d
d = Field -> Maybe ByteString -> d
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fd Maybe ByteString
vd; !e :: e
e = Field -> Maybe ByteString -> e
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fe Maybe ByteString
ve; !f :: f
f = Field -> Maybe ByteString -> f
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
ff Maybe ByteString
vf
              !g :: g
g = Field -> Maybe ByteString -> g
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fg Maybe ByteString
vg; !h :: h
h = Field -> Maybe ByteString -> h
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fh Maybe ByteString
vh; !i :: i
i = Field -> Maybe ByteString -> i
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fi Maybe ByteString
vi
              !j :: j
j = Field -> Maybe ByteString -> j
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fj Maybe ByteString
vj
    convertResults [Field]
fs [Maybe ByteString]
vs  = [Field]
-> [Maybe ByteString] -> Int -> (a, b, c, d, e, f, g, h, i, j)
forall a. [Field] -> [Maybe ByteString] -> Int -> a
convertError [Field]
fs [Maybe ByteString]
vs Int
10

instance (Result a, Result b, Result c, Result d, Result e, Result f,
          Result g, Result h, Result i, Result j, Result k) =>
    QueryResults (a,b,c,d,e,f,g,h,i,j,k) where
    convertResults :: [Field] -> [Maybe ByteString] -> (a, b, c, d, e, f, g, h, i, j, k)
convertResults [Field
fa,Field
fb,Field
fc,Field
fd,Field
fe,Field
ff,Field
fg,Field
fh,Field
fi,Field
fj,Field
fk]
                   [Maybe ByteString
va,Maybe ByteString
vb,Maybe ByteString
vc,Maybe ByteString
vd,Maybe ByteString
ve,Maybe ByteString
vf,Maybe ByteString
vg,Maybe ByteString
vh,Maybe ByteString
vi,Maybe ByteString
vj,Maybe ByteString
vk] =
        (a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i,j
j,k
k)
        where !a :: a
a = Field -> Maybe ByteString -> a
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fa Maybe ByteString
va; !b :: b
b = Field -> Maybe ByteString -> b
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fb Maybe ByteString
vb; !c :: c
c = Field -> Maybe ByteString -> c
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fc Maybe ByteString
vc
              !d :: d
d = Field -> Maybe ByteString -> d
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fd Maybe ByteString
vd; !e :: e
e = Field -> Maybe ByteString -> e
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fe Maybe ByteString
ve; !f :: f
f = Field -> Maybe ByteString -> f
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
ff Maybe ByteString
vf
              !g :: g
g = Field -> Maybe ByteString -> g
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fg Maybe ByteString
vg; !h :: h
h = Field -> Maybe ByteString -> h
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fh Maybe ByteString
vh; !i :: i
i = Field -> Maybe ByteString -> i
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fi Maybe ByteString
vi
              !j :: j
j = Field -> Maybe ByteString -> j
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fj Maybe ByteString
vj; !k :: k
k = Field -> Maybe ByteString -> k
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fk Maybe ByteString
vk
    convertResults [Field]
fs [Maybe ByteString]
vs  = [Field]
-> [Maybe ByteString] -> Int -> (a, b, c, d, e, f, g, h, i, j, k)
forall a. [Field] -> [Maybe ByteString] -> Int -> a
convertError [Field]
fs [Maybe ByteString]
vs Int
11

instance (Result a, Result b, Result c, Result d, Result e, Result f,
          Result g, Result h, Result i, Result j, Result k, Result l) =>
    QueryResults (a,b,c,d,e,f,g,h,i,j,k,l) where
    convertResults :: [Field]
-> [Maybe ByteString] -> (a, b, c, d, e, f, g, h, i, j, k, l)
convertResults [Field
fa,Field
fb,Field
fc,Field
fd,Field
fe,Field
ff,Field
fg,Field
fh,Field
fi,Field
fj,Field
fk,Field
fl]
                   [Maybe ByteString
va,Maybe ByteString
vb,Maybe ByteString
vc,Maybe ByteString
vd,Maybe ByteString
ve,Maybe ByteString
vf,Maybe ByteString
vg,Maybe ByteString
vh,Maybe ByteString
vi,Maybe ByteString
vj,Maybe ByteString
vk,Maybe ByteString
vl] =
        (a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i,j
j,k
k,l
l)
        where !a :: a
a = Field -> Maybe ByteString -> a
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fa Maybe ByteString
va; !b :: b
b = Field -> Maybe ByteString -> b
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fb Maybe ByteString
vb; !c :: c
c = Field -> Maybe ByteString -> c
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fc Maybe ByteString
vc
              !d :: d
d = Field -> Maybe ByteString -> d
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fd Maybe ByteString
vd; !e :: e
e = Field -> Maybe ByteString -> e
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fe Maybe ByteString
ve; !f :: f
f = Field -> Maybe ByteString -> f
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
ff Maybe ByteString
vf
              !g :: g
g = Field -> Maybe ByteString -> g
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fg Maybe ByteString
vg; !h :: h
h = Field -> Maybe ByteString -> h
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fh Maybe ByteString
vh; !i :: i
i = Field -> Maybe ByteString -> i
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fi Maybe ByteString
vi
              !j :: j
j = Field -> Maybe ByteString -> j
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fj Maybe ByteString
vj; !k :: k
k = Field -> Maybe ByteString -> k
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fk Maybe ByteString
vk; !l :: l
l = Field -> Maybe ByteString -> l
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fl Maybe ByteString
vl
    convertResults [Field]
fs [Maybe ByteString]
vs  = [Field]
-> [Maybe ByteString]
-> Int
-> (a, b, c, d, e, f, g, h, i, j, k, l)
forall a. [Field] -> [Maybe ByteString] -> Int -> a
convertError [Field]
fs [Maybe ByteString]
vs Int
12

instance (Result a, Result b, Result c, Result d, Result e, Result f,
          Result g, Result h, Result i, Result j, Result k, Result l,
          Result m) =>
    QueryResults (a,b,c,d,e,f,g,h,i,j,k,l,m) where
    convertResults :: [Field]
-> [Maybe ByteString] -> (a, b, c, d, e, f, g, h, i, j, k, l, m)
convertResults [Field
fa,Field
fb,Field
fc,Field
fd,Field
fe,Field
ff,Field
fg,Field
fh,Field
fi,Field
fj,Field
fk,Field
fl,Field
fm]
                   [Maybe ByteString
va,Maybe ByteString
vb,Maybe ByteString
vc,Maybe ByteString
vd,Maybe ByteString
ve,Maybe ByteString
vf,Maybe ByteString
vg,Maybe ByteString
vh,Maybe ByteString
vi,Maybe ByteString
vj,Maybe ByteString
vk,Maybe ByteString
vl,Maybe ByteString
vm] =
        (a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i,j
j,k
k,l
l,m
m)
        where !a :: a
a = Field -> Maybe ByteString -> a
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fa Maybe ByteString
va; !b :: b
b = Field -> Maybe ByteString -> b
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fb Maybe ByteString
vb; !c :: c
c = Field -> Maybe ByteString -> c
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fc Maybe ByteString
vc
              !d :: d
d = Field -> Maybe ByteString -> d
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fd Maybe ByteString
vd; !e :: e
e = Field -> Maybe ByteString -> e
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fe Maybe ByteString
ve; !f :: f
f = Field -> Maybe ByteString -> f
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
ff Maybe ByteString
vf
              !g :: g
g = Field -> Maybe ByteString -> g
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fg Maybe ByteString
vg; !h :: h
h = Field -> Maybe ByteString -> h
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fh Maybe ByteString
vh; !i :: i
i = Field -> Maybe ByteString -> i
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fi Maybe ByteString
vi
              !j :: j
j = Field -> Maybe ByteString -> j
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fj Maybe ByteString
vj; !k :: k
k = Field -> Maybe ByteString -> k
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fk Maybe ByteString
vk; !l :: l
l = Field -> Maybe ByteString -> l
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fl Maybe ByteString
vl
              !m :: m
m = Field -> Maybe ByteString -> m
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fm Maybe ByteString
vm
    convertResults [Field]
fs [Maybe ByteString]
vs  = [Field]
-> [Maybe ByteString]
-> Int
-> (a, b, c, d, e, f, g, h, i, j, k, l, m)
forall a. [Field] -> [Maybe ByteString] -> Int -> a
convertError [Field]
fs [Maybe ByteString]
vs Int
13

instance (Result a, Result b, Result c, Result d, Result e, Result f,
          Result g, Result h, Result i, Result j, Result k, Result l,
          Result m, Result n) =>
    QueryResults (a,b,c,d,e,f,g,h,i,j,k,l,m,n) where
    convertResults :: [Field]
-> [Maybe ByteString] -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n)
convertResults [Field
fa,Field
fb,Field
fc,Field
fd,Field
fe,Field
ff,Field
fg,Field
fh,Field
fi,Field
fj,Field
fk,Field
fl,Field
fm,Field
fn]
                   [Maybe ByteString
va,Maybe ByteString
vb,Maybe ByteString
vc,Maybe ByteString
vd,Maybe ByteString
ve,Maybe ByteString
vf,Maybe ByteString
vg,Maybe ByteString
vh,Maybe ByteString
vi,Maybe ByteString
vj,Maybe ByteString
vk,Maybe ByteString
vl,Maybe ByteString
vm,Maybe ByteString
vn] =
        (a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i,j
j,k
k,l
l,m
m,n
n)
        where !a :: a
a = Field -> Maybe ByteString -> a
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fa Maybe ByteString
va; !b :: b
b = Field -> Maybe ByteString -> b
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fb Maybe ByteString
vb; !c :: c
c = Field -> Maybe ByteString -> c
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fc Maybe ByteString
vc
              !d :: d
d = Field -> Maybe ByteString -> d
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fd Maybe ByteString
vd; !e :: e
e = Field -> Maybe ByteString -> e
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fe Maybe ByteString
ve; !f :: f
f = Field -> Maybe ByteString -> f
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
ff Maybe ByteString
vf
              !g :: g
g = Field -> Maybe ByteString -> g
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fg Maybe ByteString
vg; !h :: h
h = Field -> Maybe ByteString -> h
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fh Maybe ByteString
vh; !i :: i
i = Field -> Maybe ByteString -> i
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fi Maybe ByteString
vi
              !j :: j
j = Field -> Maybe ByteString -> j
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fj Maybe ByteString
vj; !k :: k
k = Field -> Maybe ByteString -> k
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fk Maybe ByteString
vk; !l :: l
l = Field -> Maybe ByteString -> l
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fl Maybe ByteString
vl
              !m :: m
m = Field -> Maybe ByteString -> m
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fm Maybe ByteString
vm; !n :: n
n = Field -> Maybe ByteString -> n
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fn Maybe ByteString
vn
    convertResults [Field]
fs [Maybe ByteString]
vs  = [Field]
-> [Maybe ByteString]
-> Int
-> (a, b, c, d, e, f, g, h, i, j, k, l, m, n)
forall a. [Field] -> [Maybe ByteString] -> Int -> a
convertError [Field]
fs [Maybe ByteString]
vs Int
14

instance (Result a, Result b, Result c, Result d, Result e, Result f,
          Result g, Result h, Result i, Result j, Result k, Result l,
          Result m, Result n, Result o) =>
    QueryResults (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o) where
    convertResults :: [Field]
-> [Maybe ByteString]
-> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o)
convertResults [Field
fa,Field
fb,Field
fc,Field
fd,Field
fe,Field
ff,Field
fg,Field
fh,Field
fi,Field
fj,Field
fk,Field
fl,Field
fm,Field
fn,Field
fo]
                   [Maybe ByteString
va,Maybe ByteString
vb,Maybe ByteString
vc,Maybe ByteString
vd,Maybe ByteString
ve,Maybe ByteString
vf,Maybe ByteString
vg,Maybe ByteString
vh,Maybe ByteString
vi,Maybe ByteString
vj,Maybe ByteString
vk,Maybe ByteString
vl,Maybe ByteString
vm,Maybe ByteString
vn,Maybe ByteString
vo] =
        (a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i,j
j,k
k,l
l,m
m,n
n,o
o)
        where !a :: a
a = Field -> Maybe ByteString -> a
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fa Maybe ByteString
va; !b :: b
b = Field -> Maybe ByteString -> b
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fb Maybe ByteString
vb; !c :: c
c = Field -> Maybe ByteString -> c
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fc Maybe ByteString
vc
              !d :: d
d = Field -> Maybe ByteString -> d
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fd Maybe ByteString
vd; !e :: e
e = Field -> Maybe ByteString -> e
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fe Maybe ByteString
ve; !f :: f
f = Field -> Maybe ByteString -> f
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
ff Maybe ByteString
vf
              !g :: g
g = Field -> Maybe ByteString -> g
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fg Maybe ByteString
vg; !h :: h
h = Field -> Maybe ByteString -> h
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fh Maybe ByteString
vh; !i :: i
i = Field -> Maybe ByteString -> i
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fi Maybe ByteString
vi
              !j :: j
j = Field -> Maybe ByteString -> j
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fj Maybe ByteString
vj; !k :: k
k = Field -> Maybe ByteString -> k
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fk Maybe ByteString
vk; !l :: l
l = Field -> Maybe ByteString -> l
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fl Maybe ByteString
vl
              !m :: m
m = Field -> Maybe ByteString -> m
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fm Maybe ByteString
vm; !n :: n
n = Field -> Maybe ByteString -> n
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fn Maybe ByteString
vn; !o :: o
o = Field -> Maybe ByteString -> o
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fo Maybe ByteString
vo
    convertResults [Field]
fs [Maybe ByteString]
vs  = [Field]
-> [Maybe ByteString]
-> Int
-> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o)
forall a. [Field] -> [Maybe ByteString] -> Int -> a
convertError [Field]
fs [Maybe ByteString]
vs Int
15

instance (Result a, Result b, Result c, Result d, Result e, Result f,
          Result g, Result h, Result i, Result j, Result k, Result l,
          Result m, Result n, Result o, Result p) =>
    QueryResults (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p) where
    convertResults :: [Field]
-> [Maybe ByteString]
-> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p)
convertResults [Field
fa,Field
fb,Field
fc,Field
fd,Field
fe,Field
ff,Field
fg,Field
fh,Field
fi,Field
fj,Field
fk,Field
fl,Field
fm,Field
fn,Field
fo,Field
fp]
                   [Maybe ByteString
va,Maybe ByteString
vb,Maybe ByteString
vc,Maybe ByteString
vd,Maybe ByteString
ve,Maybe ByteString
vf,Maybe ByteString
vg,Maybe ByteString
vh,Maybe ByteString
vi,Maybe ByteString
vj,Maybe ByteString
vk,Maybe ByteString
vl,Maybe ByteString
vm,Maybe ByteString
vn,Maybe ByteString
vo,Maybe ByteString
vp] =
        (a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i,j
j,k
k,l
l,m
m,n
n,o
o,p
p)
        where !a :: a
a = Field -> Maybe ByteString -> a
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fa Maybe ByteString
va; !b :: b
b = Field -> Maybe ByteString -> b
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fb Maybe ByteString
vb; !c :: c
c = Field -> Maybe ByteString -> c
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fc Maybe ByteString
vc
              !d :: d
d = Field -> Maybe ByteString -> d
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fd Maybe ByteString
vd; !e :: e
e = Field -> Maybe ByteString -> e
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fe Maybe ByteString
ve; !f :: f
f = Field -> Maybe ByteString -> f
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
ff Maybe ByteString
vf
              !g :: g
g = Field -> Maybe ByteString -> g
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fg Maybe ByteString
vg; !h :: h
h = Field -> Maybe ByteString -> h
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fh Maybe ByteString
vh; !i :: i
i = Field -> Maybe ByteString -> i
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fi Maybe ByteString
vi
              !j :: j
j = Field -> Maybe ByteString -> j
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fj Maybe ByteString
vj; !k :: k
k = Field -> Maybe ByteString -> k
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fk Maybe ByteString
vk; !l :: l
l = Field -> Maybe ByteString -> l
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fl Maybe ByteString
vl
              !m :: m
m = Field -> Maybe ByteString -> m
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fm Maybe ByteString
vm; !n :: n
n = Field -> Maybe ByteString -> n
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fn Maybe ByteString
vn; !o :: o
o = Field -> Maybe ByteString -> o
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fo Maybe ByteString
vo
              !p :: p
p = Field -> Maybe ByteString -> p
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fp Maybe ByteString
vp;
    convertResults [Field]
fs [Maybe ByteString]
vs  = [Field]
-> [Maybe ByteString]
-> Int
-> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p)
forall a. [Field] -> [Maybe ByteString] -> Int -> a
convertError [Field]
fs [Maybe ByteString]
vs Int
16

instance (Result a, Result b, Result c, Result d, Result e, Result f,
          Result g, Result h, Result i, Result j, Result k, Result l,
          Result m, Result n, Result o, Result p, Result q) =>
    QueryResults (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q) where
    convertResults :: [Field]
-> [Maybe ByteString]
-> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q)
convertResults [Field
fa,Field
fb,Field
fc,Field
fd,Field
fe,Field
ff,Field
fg,Field
fh,Field
fi,Field
fj,Field
fk,Field
fl,Field
fm,Field
fn,Field
fo,Field
fp,Field
fq]
                   [Maybe ByteString
va,Maybe ByteString
vb,Maybe ByteString
vc,Maybe ByteString
vd,Maybe ByteString
ve,Maybe ByteString
vf,Maybe ByteString
vg,Maybe ByteString
vh,Maybe ByteString
vi,Maybe ByteString
vj,Maybe ByteString
vk,Maybe ByteString
vl,Maybe ByteString
vm,Maybe ByteString
vn,Maybe ByteString
vo,Maybe ByteString
vp,Maybe ByteString
vq] =
        (a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i,j
j,k
k,l
l,m
m,n
n,o
o,p
p,q
q)
        where !a :: a
a = Field -> Maybe ByteString -> a
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fa Maybe ByteString
va; !b :: b
b = Field -> Maybe ByteString -> b
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fb Maybe ByteString
vb; !c :: c
c = Field -> Maybe ByteString -> c
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fc Maybe ByteString
vc
              !d :: d
d = Field -> Maybe ByteString -> d
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fd Maybe ByteString
vd; !e :: e
e = Field -> Maybe ByteString -> e
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fe Maybe ByteString
ve; !f :: f
f = Field -> Maybe ByteString -> f
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
ff Maybe ByteString
vf
              !g :: g
g = Field -> Maybe ByteString -> g
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fg Maybe ByteString
vg; !h :: h
h = Field -> Maybe ByteString -> h
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fh Maybe ByteString
vh; !i :: i
i = Field -> Maybe ByteString -> i
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fi Maybe ByteString
vi
              !j :: j
j = Field -> Maybe ByteString -> j
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fj Maybe ByteString
vj; !k :: k
k = Field -> Maybe ByteString -> k
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fk Maybe ByteString
vk; !l :: l
l = Field -> Maybe ByteString -> l
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fl Maybe ByteString
vl
              !m :: m
m = Field -> Maybe ByteString -> m
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fm Maybe ByteString
vm; !n :: n
n = Field -> Maybe ByteString -> n
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fn Maybe ByteString
vn; !o :: o
o = Field -> Maybe ByteString -> o
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fo Maybe ByteString
vo
              !p :: p
p = Field -> Maybe ByteString -> p
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fp Maybe ByteString
vp; !q :: q
q = Field -> Maybe ByteString -> q
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fq Maybe ByteString
vq;
    convertResults [Field]
fs [Maybe ByteString]
vs  = [Field]
-> [Maybe ByteString]
-> Int
-> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q)
forall a. [Field] -> [Maybe ByteString] -> Int -> a
convertError [Field]
fs [Maybe ByteString]
vs Int
17

instance (Result a, Result b, Result c, Result d, Result e, Result f,
          Result g, Result h, Result i, Result j, Result k, Result l,
          Result m, Result n, Result o, Result p, Result q, Result r) =>
    QueryResults (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r) where
    convertResults :: [Field]
-> [Maybe ByteString]
-> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r)
convertResults [Field
fa,Field
fb,Field
fc,Field
fd,Field
fe,Field
ff,Field
fg,Field
fh,Field
fi,Field
fj,Field
fk,Field
fl,Field
fm,Field
fn,Field
fo,Field
fp,Field
fq,Field
fr]
                   [Maybe ByteString
va,Maybe ByteString
vb,Maybe ByteString
vc,Maybe ByteString
vd,Maybe ByteString
ve,Maybe ByteString
vf,Maybe ByteString
vg,Maybe ByteString
vh,Maybe ByteString
vi,Maybe ByteString
vj,Maybe ByteString
vk,Maybe ByteString
vl,Maybe ByteString
vm,Maybe ByteString
vn,Maybe ByteString
vo,Maybe ByteString
vp,Maybe ByteString
vq,Maybe ByteString
vr] =
        (a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i,j
j,k
k,l
l,m
m,n
n,o
o,p
p,q
q,r
r)
        where !a :: a
a = Field -> Maybe ByteString -> a
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fa Maybe ByteString
va; !b :: b
b = Field -> Maybe ByteString -> b
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fb Maybe ByteString
vb; !c :: c
c = Field -> Maybe ByteString -> c
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fc Maybe ByteString
vc
              !d :: d
d = Field -> Maybe ByteString -> d
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fd Maybe ByteString
vd; !e :: e
e = Field -> Maybe ByteString -> e
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fe Maybe ByteString
ve; !f :: f
f = Field -> Maybe ByteString -> f
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
ff Maybe ByteString
vf
              !g :: g
g = Field -> Maybe ByteString -> g
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fg Maybe ByteString
vg; !h :: h
h = Field -> Maybe ByteString -> h
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fh Maybe ByteString
vh; !i :: i
i = Field -> Maybe ByteString -> i
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fi Maybe ByteString
vi
              !j :: j
j = Field -> Maybe ByteString -> j
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fj Maybe ByteString
vj; !k :: k
k = Field -> Maybe ByteString -> k
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fk Maybe ByteString
vk; !l :: l
l = Field -> Maybe ByteString -> l
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fl Maybe ByteString
vl
              !m :: m
m = Field -> Maybe ByteString -> m
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fm Maybe ByteString
vm; !n :: n
n = Field -> Maybe ByteString -> n
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fn Maybe ByteString
vn; !o :: o
o = Field -> Maybe ByteString -> o
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fo Maybe ByteString
vo
              !p :: p
p = Field -> Maybe ByteString -> p
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fp Maybe ByteString
vp; !q :: q
q = Field -> Maybe ByteString -> q
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fq Maybe ByteString
vq; !r :: r
r = Field -> Maybe ByteString -> r
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fr Maybe ByteString
vr
    convertResults [Field]
fs [Maybe ByteString]
vs  = [Field]
-> [Maybe ByteString]
-> Int
-> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r)
forall a. [Field] -> [Maybe ByteString] -> Int -> a
convertError [Field]
fs [Maybe ByteString]
vs Int
18

instance (Result a, Result b, Result c, Result d, Result e, Result f,
          Result g, Result h, Result i, Result j, Result k, Result l,
          Result m, Result n, Result o, Result p, Result q, Result r,
          Result s) =>
    QueryResults (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s) where
    convertResults :: [Field]
-> [Maybe ByteString]
-> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s)
convertResults [Field
fa,Field
fb,Field
fc,Field
fd,Field
fe,Field
ff,Field
fg,Field
fh,Field
fi,Field
fj,Field
fk,Field
fl,Field
fm,Field
fn,Field
fo,Field
fp,Field
fq,Field
fr,Field
fs]
                   [Maybe ByteString
va,Maybe ByteString
vb,Maybe ByteString
vc,Maybe ByteString
vd,Maybe ByteString
ve,Maybe ByteString
vf,Maybe ByteString
vg,Maybe ByteString
vh,Maybe ByteString
vi,Maybe ByteString
vj,Maybe ByteString
vk,Maybe ByteString
vl,Maybe ByteString
vm,Maybe ByteString
vn,Maybe ByteString
vo,Maybe ByteString
vp,Maybe ByteString
vq,Maybe ByteString
vr,Maybe ByteString
vs]
        = (a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i,j
j,k
k,l
l,m
m,n
n,o
o,p
p,q
q,r
r,s
s)
        where !a :: a
a = Field -> Maybe ByteString -> a
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fa Maybe ByteString
va; !b :: b
b = Field -> Maybe ByteString -> b
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fb Maybe ByteString
vb; !c :: c
c = Field -> Maybe ByteString -> c
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fc Maybe ByteString
vc
              !d :: d
d = Field -> Maybe ByteString -> d
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fd Maybe ByteString
vd; !e :: e
e = Field -> Maybe ByteString -> e
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fe Maybe ByteString
ve; !f :: f
f = Field -> Maybe ByteString -> f
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
ff Maybe ByteString
vf
              !g :: g
g = Field -> Maybe ByteString -> g
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fg Maybe ByteString
vg; !h :: h
h = Field -> Maybe ByteString -> h
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fh Maybe ByteString
vh; !i :: i
i = Field -> Maybe ByteString -> i
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fi Maybe ByteString
vi
              !j :: j
j = Field -> Maybe ByteString -> j
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fj Maybe ByteString
vj; !k :: k
k = Field -> Maybe ByteString -> k
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fk Maybe ByteString
vk; !l :: l
l = Field -> Maybe ByteString -> l
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fl Maybe ByteString
vl
              !m :: m
m = Field -> Maybe ByteString -> m
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fm Maybe ByteString
vm; !n :: n
n = Field -> Maybe ByteString -> n
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fn Maybe ByteString
vn; !o :: o
o = Field -> Maybe ByteString -> o
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fo Maybe ByteString
vo
              !p :: p
p = Field -> Maybe ByteString -> p
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fp Maybe ByteString
vp; !q :: q
q = Field -> Maybe ByteString -> q
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fq Maybe ByteString
vq; !r :: r
r = Field -> Maybe ByteString -> r
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fr Maybe ByteString
vr
              !s :: s
s = Field -> Maybe ByteString -> s
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fs Maybe ByteString
vs;
    convertResults [Field]
fs_ [Maybe ByteString]
vs_  = [Field]
-> [Maybe ByteString]
-> Int
-> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s)
forall a. [Field] -> [Maybe ByteString] -> Int -> a
convertError [Field]
fs_ [Maybe ByteString]
vs_ Int
19

instance (Result a, Result b, Result c, Result d, Result e, Result f,
          Result g, Result h, Result i, Result j, Result k, Result l,
          Result m, Result n, Result o, Result p, Result q, Result r,
          Result s, Result t) =>
    QueryResults (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t) where
    convertResults :: [Field]
-> [Maybe ByteString]
-> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t)
convertResults [Field
fa,Field
fb,Field
fc,Field
fd,Field
fe,Field
ff,Field
fg,Field
fh,Field
fi,Field
fj,Field
fk,Field
fl,Field
fm,Field
fn,Field
fo,Field
fp,Field
fq,Field
fr,Field
fs,
                    Field
ft]
                   [Maybe ByteString
va,Maybe ByteString
vb,Maybe ByteString
vc,Maybe ByteString
vd,Maybe ByteString
ve,Maybe ByteString
vf,Maybe ByteString
vg,Maybe ByteString
vh,Maybe ByteString
vi,Maybe ByteString
vj,Maybe ByteString
vk,Maybe ByteString
vl,Maybe ByteString
vm,Maybe ByteString
vn,Maybe ByteString
vo,Maybe ByteString
vp,Maybe ByteString
vq,Maybe ByteString
vr,Maybe ByteString
vs,
                    Maybe ByteString
vt]
        = (a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i,j
j,k
k,l
l,m
m,n
n,o
o,p
p,q
q,r
r,s
s,t
t)
        where !a :: a
a = Field -> Maybe ByteString -> a
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fa Maybe ByteString
va; !b :: b
b = Field -> Maybe ByteString -> b
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fb Maybe ByteString
vb; !c :: c
c = Field -> Maybe ByteString -> c
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fc Maybe ByteString
vc
              !d :: d
d = Field -> Maybe ByteString -> d
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fd Maybe ByteString
vd; !e :: e
e = Field -> Maybe ByteString -> e
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fe Maybe ByteString
ve; !f :: f
f = Field -> Maybe ByteString -> f
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
ff Maybe ByteString
vf
              !g :: g
g = Field -> Maybe ByteString -> g
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fg Maybe ByteString
vg; !h :: h
h = Field -> Maybe ByteString -> h
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fh Maybe ByteString
vh; !i :: i
i = Field -> Maybe ByteString -> i
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fi Maybe ByteString
vi
              !j :: j
j = Field -> Maybe ByteString -> j
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fj Maybe ByteString
vj; !k :: k
k = Field -> Maybe ByteString -> k
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fk Maybe ByteString
vk; !l :: l
l = Field -> Maybe ByteString -> l
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fl Maybe ByteString
vl
              !m :: m
m = Field -> Maybe ByteString -> m
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fm Maybe ByteString
vm; !n :: n
n = Field -> Maybe ByteString -> n
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fn Maybe ByteString
vn; !o :: o
o = Field -> Maybe ByteString -> o
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fo Maybe ByteString
vo
              !p :: p
p = Field -> Maybe ByteString -> p
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fp Maybe ByteString
vp; !q :: q
q = Field -> Maybe ByteString -> q
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fq Maybe ByteString
vq; !r :: r
r = Field -> Maybe ByteString -> r
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fr Maybe ByteString
vr
              !s :: s
s = Field -> Maybe ByteString -> s
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fs Maybe ByteString
vs; !t :: t
t = Field -> Maybe ByteString -> t
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
ft Maybe ByteString
vt
    convertResults [Field]
fs_ [Maybe ByteString]
vs_  = [Field]
-> [Maybe ByteString]
-> Int
-> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t)
forall a. [Field] -> [Maybe ByteString] -> Int -> a
convertError [Field]
fs_ [Maybe ByteString]
vs_ Int
20

instance (Result a, Result b, Result c, Result d, Result e, Result f,
          Result g, Result h, Result i, Result j, Result k, Result l,
          Result m, Result n, Result o, Result p, Result q, Result r,
          Result s, Result t, Result u) =>
    QueryResults (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u) where
    convertResults :: [Field]
-> [Maybe ByteString]
-> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u)
convertResults [Field
fa,Field
fb,Field
fc,Field
fd,Field
fe,Field
ff,Field
fg,Field
fh,Field
fi,Field
fj,Field
fk,Field
fl,Field
fm,Field
fn,Field
fo,Field
fp,Field
fq,Field
fr,Field
fs,
                    Field
ft,Field
fu]
                   [Maybe ByteString
va,Maybe ByteString
vb,Maybe ByteString
vc,Maybe ByteString
vd,Maybe ByteString
ve,Maybe ByteString
vf,Maybe ByteString
vg,Maybe ByteString
vh,Maybe ByteString
vi,Maybe ByteString
vj,Maybe ByteString
vk,Maybe ByteString
vl,Maybe ByteString
vm,Maybe ByteString
vn,Maybe ByteString
vo,Maybe ByteString
vp,Maybe ByteString
vq,Maybe ByteString
vr,Maybe ByteString
vs,
                    Maybe ByteString
vt,Maybe ByteString
vu]
        = (a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i,j
j,k
k,l
l,m
m,n
n,o
o,p
p,q
q,r
r,s
s,t
t,u
u)
        where !a :: a
a = Field -> Maybe ByteString -> a
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fa Maybe ByteString
va; !b :: b
b = Field -> Maybe ByteString -> b
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fb Maybe ByteString
vb; !c :: c
c = Field -> Maybe ByteString -> c
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fc Maybe ByteString
vc
              !d :: d
d = Field -> Maybe ByteString -> d
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fd Maybe ByteString
vd; !e :: e
e = Field -> Maybe ByteString -> e
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fe Maybe ByteString
ve; !f :: f
f = Field -> Maybe ByteString -> f
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
ff Maybe ByteString
vf
              !g :: g
g = Field -> Maybe ByteString -> g
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fg Maybe ByteString
vg; !h :: h
h = Field -> Maybe ByteString -> h
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fh Maybe ByteString
vh; !i :: i
i = Field -> Maybe ByteString -> i
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fi Maybe ByteString
vi
              !j :: j
j = Field -> Maybe ByteString -> j
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fj Maybe ByteString
vj; !k :: k
k = Field -> Maybe ByteString -> k
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fk Maybe ByteString
vk; !l :: l
l = Field -> Maybe ByteString -> l
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fl Maybe ByteString
vl
              !m :: m
m = Field -> Maybe ByteString -> m
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fm Maybe ByteString
vm; !n :: n
n = Field -> Maybe ByteString -> n
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fn Maybe ByteString
vn; !o :: o
o = Field -> Maybe ByteString -> o
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fo Maybe ByteString
vo
              !p :: p
p = Field -> Maybe ByteString -> p
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fp Maybe ByteString
vp; !q :: q
q = Field -> Maybe ByteString -> q
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fq Maybe ByteString
vq; !r :: r
r = Field -> Maybe ByteString -> r
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fr Maybe ByteString
vr
              !s :: s
s = Field -> Maybe ByteString -> s
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fs Maybe ByteString
vs; !t :: t
t = Field -> Maybe ByteString -> t
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
ft Maybe ByteString
vt; !u :: u
u = Field -> Maybe ByteString -> u
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fu Maybe ByteString
vu
    convertResults [Field]
fs_ [Maybe ByteString]
vs_  = [Field]
-> [Maybe ByteString]
-> Int
-> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u)
forall a. [Field] -> [Maybe ByteString] -> Int -> a
convertError [Field]
fs_ [Maybe ByteString]
vs_ Int
21

instance (Result a, Result b, Result c, Result d, Result e, Result f,
          Result g, Result h, Result i, Result j, Result k, Result l,
          Result m, Result n, Result o, Result p, Result q, Result r,
          Result s, Result t, Result u, Result v) =>
    QueryResults (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v) where
    convertResults :: [Field]
-> [Maybe ByteString]
-> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u,
    v)
convertResults [Field
fa,Field
fb,Field
fc,Field
fd,Field
fe,Field
ff,Field
fg,Field
fh,Field
fi,Field
fj,Field
fk,Field
fl,Field
fm,Field
fn,Field
fo,Field
fp,Field
fq,Field
fr,Field
fs,
                    Field
ft,Field
fu,Field
fv]
                   [Maybe ByteString
va,Maybe ByteString
vb,Maybe ByteString
vc,Maybe ByteString
vd,Maybe ByteString
ve,Maybe ByteString
vf,Maybe ByteString
vg,Maybe ByteString
vh,Maybe ByteString
vi,Maybe ByteString
vj,Maybe ByteString
vk,Maybe ByteString
vl,Maybe ByteString
vm,Maybe ByteString
vn,Maybe ByteString
vo,Maybe ByteString
vp,Maybe ByteString
vq,Maybe ByteString
vr,Maybe ByteString
vs,
                    Maybe ByteString
vt,Maybe ByteString
vu,Maybe ByteString
vv]
        = (a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i,j
j,k
k,l
l,m
m,n
n,o
o,p
p,q
q,r
r,s
s,t
t,u
u,v
v)
        where !a :: a
a = Field -> Maybe ByteString -> a
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fa Maybe ByteString
va; !b :: b
b = Field -> Maybe ByteString -> b
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fb Maybe ByteString
vb; !c :: c
c = Field -> Maybe ByteString -> c
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fc Maybe ByteString
vc
              !d :: d
d = Field -> Maybe ByteString -> d
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fd Maybe ByteString
vd; !e :: e
e = Field -> Maybe ByteString -> e
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fe Maybe ByteString
ve; !f :: f
f = Field -> Maybe ByteString -> f
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
ff Maybe ByteString
vf
              !g :: g
g = Field -> Maybe ByteString -> g
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fg Maybe ByteString
vg; !h :: h
h = Field -> Maybe ByteString -> h
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fh Maybe ByteString
vh; !i :: i
i = Field -> Maybe ByteString -> i
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fi Maybe ByteString
vi
              !j :: j
j = Field -> Maybe ByteString -> j
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fj Maybe ByteString
vj; !k :: k
k = Field -> Maybe ByteString -> k
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fk Maybe ByteString
vk; !l :: l
l = Field -> Maybe ByteString -> l
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fl Maybe ByteString
vl
              !m :: m
m = Field -> Maybe ByteString -> m
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fm Maybe ByteString
vm; !n :: n
n = Field -> Maybe ByteString -> n
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fn Maybe ByteString
vn; !o :: o
o = Field -> Maybe ByteString -> o
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fo Maybe ByteString
vo
              !p :: p
p = Field -> Maybe ByteString -> p
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fp Maybe ByteString
vp; !q :: q
q = Field -> Maybe ByteString -> q
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fq Maybe ByteString
vq; !r :: r
r = Field -> Maybe ByteString -> r
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fr Maybe ByteString
vr
              !s :: s
s = Field -> Maybe ByteString -> s
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fs Maybe ByteString
vs; !t :: t
t = Field -> Maybe ByteString -> t
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
ft Maybe ByteString
vt; !u :: u
u = Field -> Maybe ByteString -> u
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fu Maybe ByteString
vu
              !v :: v
v = Field -> Maybe ByteString -> v
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fv Maybe ByteString
vv;
    convertResults [Field]
fs_ [Maybe ByteString]
vs_  = [Field]
-> [Maybe ByteString]
-> Int
-> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u,
    v)
forall a. [Field] -> [Maybe ByteString] -> Int -> a
convertError [Field]
fs_ [Maybe ByteString]
vs_ Int
22

instance (Result a, Result b, Result c, Result d, Result e, Result f,
          Result g, Result h, Result i, Result j, Result k, Result l,
          Result m, Result n, Result o, Result p, Result q, Result r,
          Result s, Result t, Result u, Result v, Result w) =>
    QueryResults (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w) where
    convertResults :: [Field]
-> [Maybe ByteString]
-> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u,
    v, w)
convertResults [Field
fa,Field
fb,Field
fc,Field
fd,Field
fe,Field
ff,Field
fg,Field
fh,Field
fi,Field
fj,Field
fk,Field
fl,Field
fm,Field
fn,Field
fo,Field
fp,Field
fq,Field
fr,Field
fs,
                    Field
ft,Field
fu,Field
fv,Field
fw]
                   [Maybe ByteString
va,Maybe ByteString
vb,Maybe ByteString
vc,Maybe ByteString
vd,Maybe ByteString
ve,Maybe ByteString
vf,Maybe ByteString
vg,Maybe ByteString
vh,Maybe ByteString
vi,Maybe ByteString
vj,Maybe ByteString
vk,Maybe ByteString
vl,Maybe ByteString
vm,Maybe ByteString
vn,Maybe ByteString
vo,Maybe ByteString
vp,Maybe ByteString
vq,Maybe ByteString
vr,Maybe ByteString
vs,
                    Maybe ByteString
vt,Maybe ByteString
vu,Maybe ByteString
vv,Maybe ByteString
vw]
        = (a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i,j
j,k
k,l
l,m
m,n
n,o
o,p
p,q
q,r
r,s
s,t
t,u
u,v
v,w
w)
        where !a :: a
a = Field -> Maybe ByteString -> a
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fa Maybe ByteString
va; !b :: b
b = Field -> Maybe ByteString -> b
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fb Maybe ByteString
vb; !c :: c
c = Field -> Maybe ByteString -> c
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fc Maybe ByteString
vc
              !d :: d
d = Field -> Maybe ByteString -> d
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fd Maybe ByteString
vd; !e :: e
e = Field -> Maybe ByteString -> e
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fe Maybe ByteString
ve; !f :: f
f = Field -> Maybe ByteString -> f
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
ff Maybe ByteString
vf
              !g :: g
g = Field -> Maybe ByteString -> g
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fg Maybe ByteString
vg; !h :: h
h = Field -> Maybe ByteString -> h
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fh Maybe ByteString
vh; !i :: i
i = Field -> Maybe ByteString -> i
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fi Maybe ByteString
vi
              !j :: j
j = Field -> Maybe ByteString -> j
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fj Maybe ByteString
vj; !k :: k
k = Field -> Maybe ByteString -> k
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fk Maybe ByteString
vk; !l :: l
l = Field -> Maybe ByteString -> l
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fl Maybe ByteString
vl
              !m :: m
m = Field -> Maybe ByteString -> m
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fm Maybe ByteString
vm; !n :: n
n = Field -> Maybe ByteString -> n
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fn Maybe ByteString
vn; !o :: o
o = Field -> Maybe ByteString -> o
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fo Maybe ByteString
vo
              !p :: p
p = Field -> Maybe ByteString -> p
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fp Maybe ByteString
vp; !q :: q
q = Field -> Maybe ByteString -> q
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fq Maybe ByteString
vq; !r :: r
r = Field -> Maybe ByteString -> r
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fr Maybe ByteString
vr
              !s :: s
s = Field -> Maybe ByteString -> s
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fs Maybe ByteString
vs; !t :: t
t = Field -> Maybe ByteString -> t
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
ft Maybe ByteString
vt; !u :: u
u = Field -> Maybe ByteString -> u
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fu Maybe ByteString
vu
              !v :: v
v = Field -> Maybe ByteString -> v
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fv Maybe ByteString
vv; !w :: w
w = Field -> Maybe ByteString -> w
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fw Maybe ByteString
vw;
    convertResults [Field]
fs_ [Maybe ByteString]
vs_  = [Field]
-> [Maybe ByteString]
-> Int
-> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u,
    v, w)
forall a. [Field] -> [Maybe ByteString] -> Int -> a
convertError [Field]
fs_ [Maybe ByteString]
vs_ Int
23

instance (Result a, Result b, Result c, Result d, Result e, Result f,
          Result g, Result h, Result i, Result j, Result k, Result l,
          Result m, Result n, Result o, Result p, Result q, Result r,
          Result s, Result t, Result u, Result v, Result w, Result x) =>
    QueryResults (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x) where
    convertResults :: [Field]
-> [Maybe ByteString]
-> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u,
    v, w, x)
convertResults [Field
fa,Field
fb,Field
fc,Field
fd,Field
fe,Field
ff,Field
fg,Field
fh,Field
fi,Field
fj,Field
fk,Field
fl,Field
fm,Field
fn,Field
fo,Field
fp,Field
fq,Field
fr,Field
fs,
                    Field
ft,Field
fu,Field
fv,Field
fw,Field
fx]
                   [Maybe ByteString
va,Maybe ByteString
vb,Maybe ByteString
vc,Maybe ByteString
vd,Maybe ByteString
ve,Maybe ByteString
vf,Maybe ByteString
vg,Maybe ByteString
vh,Maybe ByteString
vi,Maybe ByteString
vj,Maybe ByteString
vk,Maybe ByteString
vl,Maybe ByteString
vm,Maybe ByteString
vn,Maybe ByteString
vo,Maybe ByteString
vp,Maybe ByteString
vq,Maybe ByteString
vr,Maybe ByteString
vs,
                    Maybe ByteString
vt,Maybe ByteString
vu,Maybe ByteString
vv,Maybe ByteString
vw,Maybe ByteString
vx]
        = (a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i,j
j,k
k,l
l,m
m,n
n,o
o,p
p,q
q,r
r,s
s,t
t,u
u,v
v,w
w,x
x)
        where !a :: a
a = Field -> Maybe ByteString -> a
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fa Maybe ByteString
va; !b :: b
b = Field -> Maybe ByteString -> b
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fb Maybe ByteString
vb; !c :: c
c = Field -> Maybe ByteString -> c
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fc Maybe ByteString
vc
              !d :: d
d = Field -> Maybe ByteString -> d
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fd Maybe ByteString
vd; !e :: e
e = Field -> Maybe ByteString -> e
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fe Maybe ByteString
ve; !f :: f
f = Field -> Maybe ByteString -> f
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
ff Maybe ByteString
vf
              !g :: g
g = Field -> Maybe ByteString -> g
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fg Maybe ByteString
vg; !h :: h
h = Field -> Maybe ByteString -> h
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fh Maybe ByteString
vh; !i :: i
i = Field -> Maybe ByteString -> i
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fi Maybe ByteString
vi
              !j :: j
j = Field -> Maybe ByteString -> j
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fj Maybe ByteString
vj; !k :: k
k = Field -> Maybe ByteString -> k
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fk Maybe ByteString
vk; !l :: l
l = Field -> Maybe ByteString -> l
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fl Maybe ByteString
vl
              !m :: m
m = Field -> Maybe ByteString -> m
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fm Maybe ByteString
vm; !n :: n
n = Field -> Maybe ByteString -> n
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fn Maybe ByteString
vn; !o :: o
o = Field -> Maybe ByteString -> o
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fo Maybe ByteString
vo
              !p :: p
p = Field -> Maybe ByteString -> p
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fp Maybe ByteString
vp; !q :: q
q = Field -> Maybe ByteString -> q
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fq Maybe ByteString
vq; !r :: r
r = Field -> Maybe ByteString -> r
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fr Maybe ByteString
vr
              !s :: s
s = Field -> Maybe ByteString -> s
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fs Maybe ByteString
vs; !t :: t
t = Field -> Maybe ByteString -> t
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
ft Maybe ByteString
vt; !u :: u
u = Field -> Maybe ByteString -> u
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fu Maybe ByteString
vu
              !v :: v
v = Field -> Maybe ByteString -> v
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fv Maybe ByteString
vv; !w :: w
w = Field -> Maybe ByteString -> w
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fw Maybe ByteString
vw; !x :: x
x = Field -> Maybe ByteString -> x
forall a. Result a => Field -> Maybe ByteString -> a
convert Field
fx Maybe ByteString
vx;
    convertResults [Field]
fs_ [Maybe ByteString]
vs_  = [Field]
-> [Maybe ByteString]
-> Int
-> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u,
    v, w, x)
forall a. [Field] -> [Maybe ByteString] -> Int -> a
convertError [Field]
fs_ [Maybe ByteString]
vs_ Int
24

-- | Throw a 'ConversionFailed' exception, indicating a mismatch
-- between the number of columns in the 'Field' and row, and the
-- number in the collection to be converted to.
convertError :: [Field]
             -- ^ Descriptors of fields to be converted.
             -> [Maybe ByteString]
             -- ^ Contents of the row to be converted.
             -> Int
             -- ^ Number of columns expected for conversion.  For
             -- instance, if converting to a 3-tuple, the number to
             -- provide here would be 3.
             -> a
convertError :: forall a. [Field] -> [Maybe ByteString] -> Int -> a
convertError [Field]
fs [Maybe ByteString]
vs Int
n = ResultError -> a
forall a e. Exception e => e -> a
throw (ResultError -> a) -> ResultError -> a
forall a b. (a -> b) -> a -> b
$ [Char] -> [Char] -> [Char] -> [Char] -> ResultError
ConversionFailed
    (Int -> [Char]
forall a. Show a => a -> [Char]
show ([Field] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length [Field]
fs) [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
" values: " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [(Type, Maybe ByteString)] -> [Char]
forall a. Show a => a -> [Char]
show ([Type] -> [Maybe ByteString] -> [(Type, Maybe ByteString)]
forall a b. [a] -> [b] -> [(a, b)]
zip ((Field -> Type) -> [Field] -> [Type]
forall a b. (a -> b) -> [a] -> [b]
map Field -> Type
fieldType [Field]
fs)
                                                  ((Maybe ByteString -> Maybe ByteString)
-> [Maybe ByteString] -> [Maybe ByteString]
forall a b. (a -> b) -> [a] -> [b]
map ((ByteString -> ByteString) -> Maybe ByteString -> Maybe ByteString
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ByteString -> ByteString
ellipsis) [Maybe ByteString]
vs)))
    (Int -> [Char]
forall a. Show a => a -> [Char]
show Int
n [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
" slots in target type")
    ([[Char]] -> [Char]
forall a. Show a => a -> [Char]
show ((Field -> [Char]) -> [Field] -> [[Char]]
forall a b. (a -> b) -> [a] -> [b]
map (ByteString -> [Char]
B.unpack (ByteString -> [Char]) -> (Field -> ByteString) -> Field -> [Char]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Field -> ByteString
fieldName) [Field]
fs))
    [Char]
"mismatch between number of columns to convert and number in target type"

ellipsis :: ByteString -> ByteString
ellipsis :: ByteString -> ByteString
ellipsis ByteString
bs
    | ByteString -> Int
B.length ByteString
bs Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
> Int
15 = Int -> ByteString -> ByteString
B.take Int
10 ByteString
bs ByteString -> ByteString -> ByteString
`B.append` ByteString
"[...]"
    | Bool
otherwise        = ByteString
bs