-
Notifications
You must be signed in to change notification settings - Fork 0
/
Statement.hs
127 lines (102 loc) · 4.48 KB
/
Statement.hs
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
module Database.HDBC.Statement
(
Statement(..),
SqlError(..),
-- * Re-exported from "Database.HDBC.SqlValue"; this re-exporting is deprecated
nToSql, iToSql, posixToSql, fromSql, safeFromSql, toSql,
SqlValue(..)
)
where
import Data.Dynamic
import Database.HDBC.ColTypes
import Database.HDBC.SqlValue
import Control.Exception
import Data.ByteString ( ByteString )
data Statement = Statement
{
{- | Execute the prepared statement, passing in the given positional
parameters (that should take the place of the question marks
in the call to 'prepare').
For non-SELECT queries, the return value is the number of
rows modified, if known. If no rows were modified, you get 0.
If the value is unknown, you get -1. All current HDBC drivers
support this function and should never return -1.
For SELECT queries, you will always get 0.
This function should automatically call finish() to finish the previous
execution, if necessary.
-}
execute :: [SqlValue] -> IO Integer,
{- | Execute the statement as-is, without supplying any
positional parameters. This is intended for statements for
which the results aren't interesting or present (e.g., DDL or
DML commands). If your query contains placeholders, this will
certainly fail; use 'execute' instead. -}
executeRaw :: IO (),
{- | Execute the query with many rows.
The return value is the return value from the final row
as if you had called 'execute' on it.
Due to optimizations that are possible due to different
databases and driver designs, this can often be significantly
faster than using 'execute' multiple times since queries
need to be compiled only once.
This is most useful for non-SELECT statements. -}
executeMany :: [[SqlValue]] -> IO (),
{- | Abort a query in progress -- usually not needed. -}
finish :: IO (),
{- | Fetches one row from the DB. Returns 'Nothing' if there
are no more rows. Will automatically call 'finish' when
the last row is read. -}
fetchRow :: IO (Maybe [SqlValue]),
{- | Returns a list of the column names in the result.
For maximum portability, you should not assume that
information is available until after an 'execute' function
has been run.
Information is returned here directly as returned
by the underlying database layer. Note that different
databases have different rules about capitalization
of return values and about representation of names
of columns that are not simple columns. For this reason,
it is suggested that you treat this information for
display purposes only. Failing that, you should convert
to lower (or upper) case, and use @AS@ clauses for
anything other than simple columns.
A simple getColumnNames implementation could simply
apply @map fst@ to the return value of 'describeResult'.
-}
getColumnNames :: IO [ByteString],
{- | The original query that this 'Statement' was prepared
with. -}
originalQuery :: ByteString,
{- | Obtain information about the columns in the result set.
Must be run only after 'execute'. The String in the result
set is the column name.
You should expect this to be returned in the same manner
as a result from 'Database.HDBC.fetchAllRows''.
All results should be converted to lowercase for you
before you see them.
Please see caveats under 'getColumnNames' for information
on the column name field here.
-}
describeResult :: IO [(ByteString, SqlColDesc)]
}
{- | The main HDBC exception object. As much information as possible
is passed from the database through to the application through this object.
Errors generated in the Haskell layer will have seNativeError set to -1.
-}
data SqlError = SqlError {seState :: ByteString,
seNativeError :: Int,
seErrorMsg :: ByteString}
deriving (Eq, Show, Read)
sqlErrorTc :: TyCon
sqlErrorTc = mkTyCon "Database.HDBC.SqlError"
instance Typeable SqlError where
typeOf _ = mkTyConApp sqlErrorTc []
#if __GLASGOW_HASKELL__ >= 610
--data SqlException
instance Exception SqlError where
{-
toException = SomeException
fromException (SomeException e) = Just e
fromException _ = Nothing
-}
#endif