Database.SQLite.Simple.Types

Top-level module for sqlite-simple.

Documentation

data Null

A placeholder for the SQL NULL value.

Constructors

Null

Instances

Eq Null

Methods

(==) :: Null -> Null -> Bool

(/=) :: Null -> Null -> Bool

Read Null

Methods

readsPrec :: Int -> ReadS Null

readList :: ReadS [Null]

readPrec :: ReadPrec Null

readListPrec :: ReadPrec [Null]

Show Null

Methods

showsPrec :: Int -> Null -> ShowS

show :: Null -> String

showList :: [Null] -> ShowS

ToField Null

Methods

toField :: Null -> SQLData

FromField Null

Methods

fromField :: FieldParser Null

newtype Only a :: * -> *

The 1-tuple type or single-value "collection".

This type is structurally equivalent to the Identity type, but its intent is more about serving as the anonymous 1-tuple type missing from Haskell for attaching typeclass instances.

Parameter usage example:

encodeSomething (Only (42::Int))

Result usage example:

xs <- decodeSomething
forM_ xs $ \(Only id) -> {- ... -}

Constructors

Only

Fields

• fromOnly :: a

Instances

Functor Only

Methods

fmap :: (a -> b) -> Only a -> Only b

(<$) :: a -> Only b -> Only a

Eq a => Eq (Only a)

Methods

(==) :: Only a -> Only a -> Bool

(/=) :: Only a -> Only a -> Bool

Data a => Data (Only a)

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Only a -> c (Only a)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Only a)

toConstr :: Only a -> Constr

dataTypeOf :: Only a -> DataType

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (Only a))

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Only a))

gmapT :: (forall b. Data b => b -> b) -> Only a -> Only a

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Only a -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Only a -> r

gmapQ :: (forall d. Data d => d -> u) -> Only a -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> Only a -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Only a -> m (Only a)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Only a -> m (Only a)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Only a -> m (Only a)

Ord a => Ord (Only a)

Methods

compare :: Only a -> Only a -> Ordering

(<) :: Only a -> Only a -> Bool

(<=) :: Only a -> Only a -> Bool

(>) :: Only a -> Only a -> Bool

(>=) :: Only a -> Only a -> Bool

max :: Only a -> Only a -> Only a

min :: Only a -> Only a -> Only a

Read a => Read (Only a)

Methods

readsPrec :: Int -> ReadS (Only a)

readList :: ReadS [Only a]

readPrec :: ReadPrec (Only a)

readListPrec :: ReadPrec [Only a]

Show a => Show (Only a)

Methods

showsPrec :: Int -> Only a -> ShowS

show :: Only a -> String

showList :: [Only a] -> ShowS

Generic (Only a)

Associated Types

type Rep (Only a) :: * -> *

Methods

from :: Only a -> Rep (Only a) x

to :: Rep (Only a) x -> Only a

NFData a => NFData (Only a)

Methods

rnf :: Only a -> ()

ToField a => ToRow (Only a)

Methods

toRow :: Only a -> [SQLData]

FromField a => FromRow (Only a)

Methods

fromRow :: RowParser (Only a)

type Rep (Only a)

type Rep (Only a) = D1 * (MetaData "Only" "Data.Tuple.Only" "Only-0.1-K3HSyq2koL8JtFXn0ZkrT6" True) (C1 * (MetaCons "Only" PrefixI True) (S1 * (MetaSel (Just Symbol "fromOnly") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * a)))

newtype Query

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.SQLite.Simple

q :: Query
q = "select ?"

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

Constructors

Query

Fields

• fromQuery :: Text

Instances

Eq Query

Methods

(==) :: Query -> Query -> Bool

(/=) :: Query -> Query -> Bool

Ord Query

Methods

compare :: Query -> Query -> Ordering

(<) :: Query -> Query -> Bool

(<=) :: Query -> Query -> Bool

(>) :: Query -> Query -> Bool

(>=) :: Query -> Query -> Bool

max :: Query -> Query -> Query

min :: Query -> Query -> Query

Read Query

Methods

readsPrec :: Int -> ReadS Query

readList :: ReadS [Query]

readPrec :: ReadPrec Query

readListPrec :: ReadPrec [Query]

Show Query

Methods

showsPrec :: Int -> Query -> ShowS

show :: Query -> String

showList :: [Query] -> ShowS

IsString Query

Methods

fromString :: String -> Query

Semigroup Query

Methods

(<>) :: Query -> Query -> Query

sconcat :: NonEmpty Query -> Query

stimes :: Integral b => b -> Query -> Query

Monoid Query

Methods

mempty :: Query

mappend :: Query -> Query -> Query

mconcat :: [Query] -> Query

data h :. t infixr 3

A composite type to parse your custom data structures without having to define dummy newtype wrappers every time.

instance FromRow MyData where ...

instance FromRow MyData2 where ...

then I can do the following for free:

res <- query' c "..."
forM res $ \(MyData{..} :. MyData2{..}) -> do
  ....

Constructors

h :. t infixr 3

Instances

(Eq t, Eq h) => Eq ((:.) h t)

Methods

(==) :: (h :. t) -> (h :. t) -> Bool

(/=) :: (h :. t) -> (h :. t) -> Bool

(Ord t, Ord h) => Ord ((:.) h t)

Methods

compare :: (h :. t) -> (h :. t) -> Ordering

(<) :: (h :. t) -> (h :. t) -> Bool

(<=) :: (h :. t) -> (h :. t) -> Bool

(>) :: (h :. t) -> (h :. t) -> Bool

(>=) :: (h :. t) -> (h :. t) -> Bool

max :: (h :. t) -> (h :. t) -> h :. t

min :: (h :. t) -> (h :. t) -> h :. t

(Read t, Read h) => Read ((:.) h t)

Methods

readsPrec :: Int -> ReadS (h :. t)

readList :: ReadS [h :. t]

readPrec :: ReadPrec (h :. t)

readListPrec :: ReadPrec [h :. t]

(Show t, Show h) => Show ((:.) h t)

Methods

showsPrec :: Int -> (h :. t) -> ShowS

show :: (h :. t) -> String

showList :: [h :. t] -> ShowS

(ToRow a, ToRow b) => ToRow ((:.) a b)

Methods

toRow :: (a :. b) -> [SQLData]

(FromRow a, FromRow b) => FromRow ((:.) a b)

Methods

fromRow :: RowParser (a :. b)