Documentation

See query for details.

See query_ for details.

See execute for details.

See execute_ for details.

See executeMany for details.

See 'M.insertID ' for details.

See 'M.autocommit ' for details.

See 'M.commit ' for details.

See 'M.rollback ' for details.

See formatMany for details.

See formatQuery for details.

Run the MySQL effect. In case of exceptions it will not close the connection. (That will still be done by the GC at one point.)

Run the MySQL effect with a given Connection.

Wrap a list of values for use in an IN clause. Replaces a single "?" character with a parenthesized list of rendered values.

Example:

 query c "select * from whatever where id in ?" (In [3,4,5]) 

A single-value "collection".

This is useful if you need to supply a single parameter to a SQL query, or extract a single column from a SQL result.

Parameter example:

query c "select x from scores where x > ?" (Only (42::Int))

Result example:

xs <- query_ c "select id from users" forM_ xs $ \(Only id) -> {- ... -}

A query string. This type is intended to make it difficult to construct a SQL query by concatenating string fragments, as that is an extremely common way to accidentally introduce SQL injection vulnerabilities into an application.

This type is an instance of IsString, so the easiest way to construct a query is to enable the OverloadedStrings language extension and then simply write the query in double quotes.

 {-# LANGUAGE OverloadedStrings #-} import Database.MySQL.Simple q :: Query q = "select ?" 

The underlying type is a ByteString, and literal Haskell strings that contain Unicode characters will be correctly transformed to UTF-8.

A collection type that can be turned into a list of rendering Actions.

Instances should use the render method of the Param class to perform conversion of each element of the collection.

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 

Default information for setting up a connection.

Defaults are as follows:

• Server on localhost
• User root
• No password
• Database test
• Character set utf8

Use as in the following example:

 connect defaultConnectInfo { connectHost = "db.example.com" }