Database.Selda

Selda is not LINQ, but they're definitely related.

Selda is a high-level EDSL for interacting with relational databases. All database computations are performed within some monad implementing the MonadSelda type class. The SeldaT monad over any MonadIO is the only pre-defined instance of MonadSelda. SeldaM is provided as a convenient short-hand for SeldaT IO.

To actually execute a database computation, you need one of the database backends: selda-sqlite or selda-postgresql.

All Selda functions may throw SeldaError when something goes wrong. This includes database connection errors, uniqueness constraint errors, etc.

See https://selda.link/tutorial for a tutorial covering the language basics.

Running queries

class MonadIO m => MonadSelda m

Some monad with Selda SQL capabilitites.

Minimal complete definition

withConnection

Instances

(MonadIO m, MonadMask m) => MonadSelda (SeldaT b m)

Defined in Database.Selda.Backend.Internal

Associated Types

type Backend (SeldaT b m) :: Type

Methods

withConnection :: (SeldaConnection (Backend (SeldaT b m)) -> SeldaT b m a) -> SeldaT b m a

transact :: SeldaT b m a -> SeldaT b m a

type family Backend m

Type of database backend used by m.

Instances

type Backend (SeldaT b m)

Defined in Database.Selda.Backend.Internal

type Backend (SeldaT b m) = b

data SeldaError

Thrown by any function in SeldaT if an error occurs.

Constructors

DbError String

Unable to open or connect to database.

SqlError String

An error occurred while executing query.

UnsafeError String

An error occurred due to improper use of an unsafe function.

Instances

Eq SeldaError

Defined in Database.Selda.Backend.Internal

Methods

(==) :: SeldaError -> SeldaError -> Bool

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

Show SeldaError

Defined in Database.Selda.Backend.Internal

Methods

showsPrec :: Int -> SeldaError -> ShowS

show :: SeldaError -> String

showList :: [SeldaError] -> ShowS

Exception SeldaError

Defined in Database.Selda.Backend.Internal

Methods

toException :: SeldaError -> SomeException

fromException :: SomeException -> Maybe SeldaError

displayException :: SeldaError -> String

data ValidationError

An error occurred when validating a database table. If this error is thrown, there is a bug in your database schema, and the particular table that triggered the error is unusable. Since validation is deterministic, this error will be thrown on every consecutive operation over the offending table.

Therefore, it is not meaningful to handle this exception in any way, just fix your bug instead.

Instances

Eq ValidationError

Defined in Database.Selda.Table.Validation

Methods

(==) :: ValidationError -> ValidationError -> Bool

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

Show ValidationError

Defined in Database.Selda.Table.Validation

Methods

showsPrec :: Int -> ValidationError -> ShowS

show :: ValidationError -> String

showList :: [ValidationError] -> ShowS

Exception ValidationError

Defined in Database.Selda.Table.Validation

Methods

toException :: ValidationError -> SomeException

fromException :: SomeException -> Maybe ValidationError

displayException :: ValidationError -> String

data SeldaT b m a

Monad transformer adding Selda SQL capabilities.

Instances

MonadTrans (SeldaT b)

Defined in Database.Selda.Backend.Internal

Methods

lift :: Monad m => m a -> SeldaT b m a

Monad m => Monad (SeldaT b m)

Defined in Database.Selda.Backend.Internal

Methods

(>>=) :: SeldaT b m a -> (a -> SeldaT b m b0) -> SeldaT b m b0

(>>) :: SeldaT b m a -> SeldaT b m b0 -> SeldaT b m b0

return :: a -> SeldaT b m a

fail :: String -> SeldaT b m a

Functor m => Functor (SeldaT b m)

Defined in Database.Selda.Backend.Internal

Methods

fmap :: (a -> b0) -> SeldaT b m a -> SeldaT b m b0

(<$) :: a -> SeldaT b m b0 -> SeldaT b m a

MonadFail m => MonadFail (SeldaT b m)

Defined in Database.Selda.Backend.Internal

Methods

fail :: String -> SeldaT b m a

Monad m => Applicative (SeldaT b m)

Defined in Database.Selda.Backend.Internal

Methods

pure :: a -> SeldaT b m a

(<*>) :: SeldaT b m (a -> b0) -> SeldaT b m a -> SeldaT b m b0

liftA2 :: (a -> b0 -> c) -> SeldaT b m a -> SeldaT b m b0 -> SeldaT b m c

(*>) :: SeldaT b m a -> SeldaT b m b0 -> SeldaT b m b0

(<*) :: SeldaT b m a -> SeldaT b m b0 -> SeldaT b m a

MonadIO m => MonadIO (SeldaT b m)

Defined in Database.Selda.Backend.Internal

Methods

liftIO :: IO a -> SeldaT b m a

MonadThrow m => MonadThrow (SeldaT b m)

Defined in Database.Selda.Backend.Internal

Methods

throwM :: Exception e => e -> SeldaT b m a

MonadCatch m => MonadCatch (SeldaT b m)

Defined in Database.Selda.Backend.Internal

Methods

catch :: Exception e => SeldaT b m a -> (e -> SeldaT b m a) -> SeldaT b m a

MonadMask m => MonadMask (SeldaT b m)

Defined in Database.Selda.Backend.Internal

Methods

mask :: ((forall a. SeldaT b m a -> SeldaT b m a) -> SeldaT b m b0) -> SeldaT b m b0

uninterruptibleMask :: ((forall a. SeldaT b m a -> SeldaT b m a) -> SeldaT b m b0) -> SeldaT b m b0

generalBracket :: SeldaT b m a -> (a -> ExitCase b0 -> SeldaT b m c) -> (a -> SeldaT b m b0) -> SeldaT b m (b0, c)

(MonadIO m, MonadMask m) => MonadSelda (SeldaT b m)

Defined in Database.Selda.Backend.Internal

Associated Types

type Backend (SeldaT b m) :: Type

Methods

withConnection :: (SeldaConnection (Backend (SeldaT b m)) -> SeldaT b m a) -> SeldaT b m a

transact :: SeldaT b m a -> SeldaT b m a

type Backend (SeldaT b m)

Defined in Database.Selda.Backend.Internal

type Backend (SeldaT b m) = b

type SeldaM b = SeldaT b IO

The simplest form of Selda computation; SeldaT specialized to IO.

type Relational a = (Generic a, SqlRow a, GRelation (Rep a))

Any type which has a corresponding relation. To make a Relational instance for some type, simply derive Generic.

Note that only types which have a single data constructor, and where all fields are instances of SqlValue can be used with this module. Attempting to use functions in this module with any type which doesn't obey those constraints will result in a very confusing type error.

newtype Only a

Wrapper for single column tables. Use this when you need a table with only a single column, with table or selectValues.

Constructors

Only a

Instances

Enum a => Enum (Only a)

Defined in Database.Selda

Methods

succ :: Only a -> Only a

pred :: Only a -> Only a

toEnum :: Int -> Only a

fromEnum :: Only a -> Int

enumFrom :: Only a -> [Only a]

enumFromThen :: Only a -> Only a -> [Only a]

enumFromTo :: Only a -> Only a -> [Only a]

enumFromThenTo :: Only a -> Only a -> Only a -> [Only a]

Eq a => Eq (Only a)

Defined in Database.Selda

Methods

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

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

Fractional a => Fractional (Only a)

Defined in Database.Selda

Methods

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

recip :: Only a -> Only a

fromRational :: Rational -> Only a

Integral a => Integral (Only a)

Defined in Database.Selda

Methods

quot :: Only a -> Only a -> Only a

rem :: Only a -> Only a -> Only a

div :: Only a -> Only a -> Only a

mod :: Only a -> Only a -> Only a

quotRem :: Only a -> Only a -> (Only a, Only a)

divMod :: Only a -> Only a -> (Only a, Only a)

toInteger :: Only a -> Integer

Num a => Num (Only a)

Defined in Database.Selda

Methods

(+) :: Only a -> Only a -> Only a

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

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

negate :: Only a -> Only a

abs :: Only a -> Only a

signum :: Only a -> Only a

fromInteger :: Integer -> Only a

Ord a => Ord (Only a)

Defined in Database.Selda

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)

Defined in Database.Selda

Methods

readsPrec :: Int -> ReadS (Only a)

readList :: ReadS [Only a]

readPrec :: ReadPrec (Only a)

readListPrec :: ReadPrec [Only a]

Real a => Real (Only a)

Defined in Database.Selda

Methods

toRational :: Only a -> Rational

Show a => Show (Only a)

Defined in Database.Selda

Methods

showsPrec :: Int -> Only a -> ShowS

show :: Only a -> String

showList :: [Only a] -> ShowS

IsString a => IsString (Only a)

Defined in Database.Selda

Methods

fromString :: String -> Only a

Generic (Only a)

Defined in Database.Selda

Associated Types

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

Methods

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

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

((TypeError (((Text "'Only " :<>: ShowType a) :<>: Text "' is not a proper SQL type.") :$$: Text "Use 'the' to access the value of the column.") :: Constraint), Typeable a) => SqlType (Only a)

Defined in Database.Selda

Methods

mkLit :: Only a -> Lit (Only a)

sqlType :: Proxy (Only a) -> SqlTypeRep

fromSql :: SqlValue -> Only a

defaultValue :: Lit (Only a)

SqlType a => SqlRow (Only a)

Defined in Database.Selda

Methods

nextResult :: ResultReader (Only a)

nestedCols :: Proxy (Only a) -> Int

The (Only a)

Defined in Database.Selda

Associated Types

type TheOnly (Only a) :: Type

Methods

the :: Only a -> TheOnly (Only a)

The (Row s (Only a))

Defined in Database.Selda

Associated Types

type TheOnly (Row s (Only a)) :: Type

Methods

the :: Row s (Only a) -> TheOnly (Row s (Only a))

type Rep (Only a)

Defined in Database.Selda

type Rep (Only a) = D1 (MetaData "Only" "Database.Selda" "selda-0.5.1.0-AKzjAihhRTX3ZzXNm1yjsq" True) (C1 (MetaCons "Only" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a)))

type TheOnly (Only a)

Defined in Database.Selda

type TheOnly (Only a) = a

type TheOnly (Row s (Only a))

Defined in Database.Selda

type TheOnly (Row s (Only a)) = Col s a

class The a where

Associated Types

type TheOnly a

Methods

the :: a -> TheOnly a

Extract the value of a row from a singleton table.

Instances

The (Only a)

Defined in Database.Selda

Associated Types

type TheOnly (Only a) :: Type

Methods

the :: Only a -> TheOnly (Only a)

The (Row s (Only a))

Defined in Database.Selda

Associated Types

type TheOnly (Row s (Only a)) :: Type

Methods

the :: Row s (Only a) -> TheOnly (Row s (Only a))

data Table a

A database table, based on some Haskell data type. Any single constructor type can form the basis of a table, as long as it derives Generic and all of its fields are instances of SqlType.

data Query s a

An SQL query.

Instances

Monad (Query s)

Defined in Database.Selda.Query.Type

Methods

(>>=) :: Query s a -> (a -> Query s b) -> Query s b

(>>) :: Query s a -> Query s b -> Query s b

return :: a -> Query s a

fail :: String -> Query s a

Functor (Query s)

Defined in Database.Selda.Query.Type

Methods

fmap :: (a -> b) -> Query s a -> Query s b

(<$) :: a -> Query s b -> Query s a

Applicative (Query s)

Defined in Database.Selda.Query.Type

Methods

pure :: a -> Query s a

(<*>) :: Query s (a -> b) -> Query s a -> Query s b

liftA2 :: (a -> b -> c) -> Query s a -> Query s b -> Query s c

(*>) :: Query s a -> Query s b -> Query s b

(<*) :: Query s a -> Query s b -> Query s a

Set (Query s)

Defined in Database.Selda

Methods

isIn :: (Same s0 t, SqlType a) => Col s0 a -> Query s (Col t a) -> Col s0 Bool

Result a => Preparable (Query s a)

Defined in Database.Selda.Prepared

Methods

mkQuery :: MonadSelda m => Int -> Query s a -> [SqlTypeRep] -> m CompResult

data Row s a

A database row. A row is a collection of one or more columns.

Instances

(SqlRow a, Columns b) => Columns (Row s a :*: b)

Defined in Database.Selda.Column

Methods

toTup :: [ColName] -> Row s a :*: b

fromTup :: (Row s a :*: b) -> [UntypedCol SQL]

(SqlRow a, Result b) => Result (Row s a :*: b)

Defined in Database.Selda.Compile

Methods

toRes :: Proxy (Row s a :*: b) -> ResultReader (Res (Row s a :*: b))

finalCols :: (Row s a :*: b) -> [SomeCol SQL]

Columns (Row s a)

Defined in Database.Selda.Column

Methods

toTup :: [ColName] -> Row s a

fromTup :: Row s a -> [UntypedCol SQL]

SqlRow a => Result (Row s a)

Defined in Database.Selda.Compile

Methods

toRes :: Proxy (Row s a) -> ResultReader (Res (Row s a))

finalCols :: Row s a -> [SomeCol SQL]

The (Row s (Only a))

Defined in Database.Selda

Associated Types

type TheOnly (Row s (Only a)) :: Type

Methods

the :: Row s (Only a) -> TheOnly (Row s (Only a))

type TheOnly (Row s (Only a))

Defined in Database.Selda

type TheOnly (Row s (Only a)) = Col s a

data Col s a

A database column. A column is often a literal column table, but can also be an expression over such a column or a constant expression.

Instances

Mappable (Col :: Type -> Type -> Type)

Defined in Database.Selda

Associated Types

type Container Col a :: Type

Methods

(.<$>) :: (SqlType a, SqlType b) => (Col s a -> Col s b) -> Col s (Container Col a) -> Col s (Container Col b)

(SqlType a, Columns b) => Columns (Col s a :*: b)

Defined in Database.Selda.Column

Methods

toTup :: [ColName] -> Col s a :*: b

fromTup :: (Col s a :*: b) -> [UntypedCol SQL]

(SqlType a, Result b) => Result (Col s a :*: b)

Defined in Database.Selda.Compile

Methods

toRes :: Proxy (Col s a :*: b) -> ResultReader (Res (Col s a :*: b))

finalCols :: (Col s a :*: b) -> [SomeCol SQL]

(SqlType a, Preparable b) => Preparable (Col s a -> b)

Defined in Database.Selda.Prepared

Methods

mkQuery :: MonadSelda m => Int -> (Col s a -> b) -> [SqlTypeRep] -> m CompResult

Fractional (Col s Int)

Defined in Database.Selda.Column

Methods

(/) :: Col s Int -> Col s Int -> Col s Int

recip :: Col s Int -> Col s Int

fromRational :: Rational -> Col s Int

Fractional (Col s Double)

Defined in Database.Selda.Column

Methods

(/) :: Col s Double -> Col s Double -> Col s Double

recip :: Col s Double -> Col s Double

fromRational :: Rational -> Col s Double

(SqlType a, Num a) => Num (Col s a)

Defined in Database.Selda.Column

Methods

(+) :: Col s a -> Col s a -> Col s a

(-) :: Col s a -> Col s a -> Col s a

(*) :: Col s a -> Col s a -> Col s a

negate :: Col s a -> Col s a

abs :: Col s a -> Col s a

signum :: Col s a -> Col s a

fromInteger :: Integer -> Col s a

IsString (Col s Text)

Defined in Database.Selda.Column

Methods

fromString :: String -> Col s Text

Columns (Col s a)

Defined in Database.Selda.Column

Methods

toTup :: [ColName] -> Col s a

fromTup :: Col s a -> [UntypedCol SQL]

SqlType a => Result (Col s a)

Defined in Database.Selda.Compile

Methods

toRes :: Proxy (Col s a) -> ResultReader (Res (Col s a))

finalCols :: Col s a -> [SomeCol SQL]

type Container (Col :: Type -> Type -> Type) a

Defined in Database.Selda

type Container (Col :: Type -> Type -> Type) a = Maybe a

type family Res r where ...

Equations

Res (Col s a :*: b) = a :*: Res b

Res (Row s a :*: b) = a :*: Res b

Res (Col s a) = a

Res (Row s a) = a

class Typeable (Res r) => Result r

An acceptable query result type; one or more columns stitched together with :*:.

Minimal complete definition

toRes, finalCols

Instances

(SqlRow a, Result b) => Result (Row s a :*: b)

Defined in Database.Selda.Compile

Methods

toRes :: Proxy (Row s a :*: b) -> ResultReader (Res (Row s a :*: b))

finalCols :: (Row s a :*: b) -> [SomeCol SQL]

(SqlType a, Result b) => Result (Col s a :*: b)

Defined in Database.Selda.Compile

Methods

toRes :: Proxy (Col s a :*: b) -> ResultReader (Res (Col s a :*: b))

finalCols :: (Col s a :*: b) -> [SomeCol SQL]

SqlType a => Result (Col s a)

Defined in Database.Selda.Compile

Methods

toRes :: Proxy (Col s a) -> ResultReader (Res (Col s a))

finalCols :: Col s a -> [SomeCol SQL]

SqlRow a => Result (Row s a)

Defined in Database.Selda.Compile

Methods

toRes :: Proxy (Row s a) -> ResultReader (Res (Row s a))

finalCols :: Row s a -> [SomeCol SQL]

query :: (MonadSelda m, Result a) => Query (Backend m) a -> m [Res a]

Run a query within a Selda monad. In practice, this is often a SeldaT transformer on top of some other monad. Selda transformers are entered using backend-specific withX functions, such as withSQLite from the SQLite backend.

queryInto :: (MonadSelda m, Relational a) => Table a -> Query (Backend m) (Row (Backend m) a) -> m Int

Perform the given query, and insert the result into the given table. Returns the number of inserted rows.

transaction :: (MonadSelda m, MonadMask m) => m a -> m a

Perform the given computation atomically. If an exception is raised during its execution, the entire transaction will be rolled back and the exception re-thrown, even if the exception is caught and handled within the transaction.

withoutForeignKeyEnforcement :: (MonadSelda m, MonadMask m) => m a -> m a

Run the given computation as a transaction without enforcing foreign key constraints.

If the computation finishes with the database in an inconsistent state with regards to foreign keys, the resulting behavior is undefined. Use with extreme caution, preferably only for migrations.

On the PostgreSQL backend, at least PostgreSQL 9.6 is required.

Using this should be avoided in favor of deferred foreign key constraints. See SQL backend documentation for deferred constraints.

newUuid :: MonadIO m => m UUID

Generate a new random UUID using the system's random number generator. UUIDs generated this way are (astronomically likely to be) unique, but not necessarily unpredictable.

For applications where unpredictability is crucial, take care to use a proper cryptographic PRNG to generate your UUIDs.

Constructing queries

class Typeable a => SqlType a where

Any datatype representable in (Selda's subset of) SQL.

Minimal complete definition

Nothing

Methods

mkLit :: a -> Lit a

Create a literal of this type.

mkLit :: (Typeable a, SqlEnum a) => a -> Lit a

Create a literal of this type.

sqlType :: Proxy a -> SqlTypeRep

The SQL representation for this type.

fromSql :: SqlValue -> a

Convert an SqlValue into this type.

fromSql :: (Typeable a, SqlEnum a) => SqlValue -> a

Convert an SqlValue into this type.

defaultValue :: Lit a

Default value when using def at this type.

defaultValue :: (Typeable a, SqlEnum a) => Lit a

Default value when using def at this type.

Instances

SqlType Bool

Defined in Database.Selda.SqlType

Methods

mkLit :: Bool -> Lit Bool

sqlType :: Proxy Bool -> SqlTypeRep

fromSql :: SqlValue -> Bool

defaultValue :: Lit Bool

SqlType Double

Defined in Database.Selda.SqlType

Methods

mkLit :: Double -> Lit Double

sqlType :: Proxy Double -> SqlTypeRep

fromSql :: SqlValue -> Double

defaultValue :: Lit Double

SqlType Int

Defined in Database.Selda.SqlType

Methods

mkLit :: Int -> Lit Int

sqlType :: Proxy Int -> SqlTypeRep

fromSql :: SqlValue -> Int

defaultValue :: Lit Int

SqlType Ordering

Defined in Database.Selda.SqlType

Methods

mkLit :: Ordering -> Lit Ordering

sqlType :: Proxy Ordering -> SqlTypeRep

fromSql :: SqlValue -> Ordering

defaultValue :: Lit Ordering

SqlType ByteString

Defined in Database.Selda.SqlType

Methods

mkLit :: ByteString -> Lit ByteString

sqlType :: Proxy ByteString -> SqlTypeRep

fromSql :: SqlValue -> ByteString

defaultValue :: Lit ByteString

SqlType ByteString

Defined in Database.Selda.SqlType

Methods

mkLit :: ByteString -> Lit ByteString

sqlType :: Proxy ByteString -> SqlTypeRep

fromSql :: SqlValue -> ByteString

defaultValue :: Lit ByteString

SqlType Text

Defined in Database.Selda.SqlType

Methods

mkLit :: Text -> Lit Text

sqlType :: Proxy Text -> SqlTypeRep

fromSql :: SqlValue -> Text

defaultValue :: Lit Text

SqlType TimeOfDay

Defined in Database.Selda.SqlType

Methods

mkLit :: TimeOfDay -> Lit TimeOfDay

sqlType :: Proxy TimeOfDay -> SqlTypeRep

fromSql :: SqlValue -> TimeOfDay

defaultValue :: Lit TimeOfDay

SqlType UTCTime

Defined in Database.Selda.SqlType

Methods

mkLit :: UTCTime -> Lit UTCTime

sqlType :: Proxy UTCTime -> SqlTypeRep

fromSql :: SqlValue -> UTCTime

defaultValue :: Lit UTCTime

SqlType Day

Defined in Database.Selda.SqlType

Methods

mkLit :: Day -> Lit Day

sqlType :: Proxy Day -> SqlTypeRep

fromSql :: SqlValue -> Day

defaultValue :: Lit Day

SqlType UUID

defaultValue for UUIDs is the all-zero RFC4122 nil UUID.

Defined in Database.Selda.SqlType

Methods

mkLit :: UUID -> Lit UUID

sqlType :: Proxy UUID -> SqlTypeRep

fromSql :: SqlValue -> UUID

defaultValue :: Lit UUID

SqlType RowID

Defined in Database.Selda.SqlType

Methods

mkLit :: RowID -> Lit RowID

sqlType :: Proxy RowID -> SqlTypeRep

fromSql :: SqlValue -> RowID

defaultValue :: Lit RowID

SqlType a => SqlType (Maybe a)

Defined in Database.Selda.SqlType

Methods

mkLit :: Maybe a -> Lit (Maybe a)

sqlType :: Proxy (Maybe a) -> SqlTypeRep

fromSql :: SqlValue -> Maybe a

defaultValue :: Lit (Maybe a)

Typeable a => SqlType (ID a)

Defined in Database.Selda.SqlType

Methods

mkLit :: ID a -> Lit (ID a)

sqlType :: Proxy (ID a) -> SqlTypeRep

fromSql :: SqlValue -> ID a

defaultValue :: Lit (ID a)

((TypeError (((Text "'Only " :<>: ShowType a) :<>: Text "' is not a proper SQL type.") :$$: Text "Use 'the' to access the value of the column.") :: Constraint), Typeable a) => SqlType (Only a)

Defined in Database.Selda

Methods

mkLit :: Only a -> Lit (Only a)

sqlType :: Proxy (Only a) -> SqlTypeRep

fromSql :: SqlValue -> Only a

defaultValue :: Lit (Only a)

class Typeable a => SqlRow a where

Minimal complete definition

Nothing

Methods

nextResult :: ResultReader a

Read the next, potentially composite, result from a stream of columns.

nextResult :: (Generic a, GSqlRow (Rep a)) => ResultReader a

Read the next, potentially composite, result from a stream of columns.

nestedCols :: Proxy a -> Int

The number of nested columns contained in this type.

nestedCols :: (Generic a, GSqlRow (Rep a)) => Proxy a -> Int

The number of nested columns contained in this type.

Instances

SqlRow a => SqlRow (Maybe a)

Defined in Database.Selda.SqlRow

Methods

nextResult :: ResultReader (Maybe a)

nestedCols :: Proxy (Maybe a) -> Int

SqlType a => SqlRow (Only a)

Defined in Database.Selda

Methods

nextResult :: ResultReader (Only a)

nestedCols :: Proxy (Only a) -> Int

(Typeable (a, b), GSqlRow (Rep (a, b))) => SqlRow (a, b)

Defined in Database.Selda.SqlRow

Methods

nextResult :: ResultReader (a, b)

nestedCols :: Proxy (a, b) -> Int

(Typeable (a, b, c), GSqlRow (Rep (a, b, c))) => SqlRow (a, b, c)

Defined in Database.Selda.SqlRow

Methods

nextResult :: ResultReader (a, b, c)

nestedCols :: Proxy (a, b, c) -> Int

(Typeable (a, b, c, d), GSqlRow (Rep (a, b, c, d))) => SqlRow (a, b, c, d)

Defined in Database.Selda.SqlRow

Methods

nextResult :: ResultReader (a, b, c, d)

nestedCols :: Proxy (a, b, c, d) -> Int

(Typeable (a, b, c, d, e), GSqlRow (Rep (a, b, c, d, e))) => SqlRow (a, b, c, d, e)

Defined in Database.Selda.SqlRow

Methods

nextResult :: ResultReader (a, b, c, d, e)

nestedCols :: Proxy (a, b, c, d, e) -> Int

(Typeable (a, b, c, d, e, f), GSqlRow (Rep (a, b, c, d, e, f))) => SqlRow (a, b, c, d, e, f)

Defined in Database.Selda.SqlRow

Methods

nextResult :: ResultReader (a, b, c, d, e, f)

nestedCols :: Proxy (a, b, c, d, e, f) -> Int

(Typeable (a, b, c, d, e, f, g), GSqlRow (Rep (a, b, c, d, e, f, g))) => SqlRow (a, b, c, d, e, f, g)

Defined in Database.Selda.SqlRow

Methods

nextResult :: ResultReader (a, b, c, d, e, f, g)

nestedCols :: Proxy (a, b, c, d, e, f, g) -> Int

class (Typeable a, Bounded a, Enum a) => SqlEnum a where

Any type that's bounded, enumerable and has a text representation, and thus representable as a Selda enumerable.

While it would be more efficient to store enumerables as integers, this makes hand-rolled SQL touching the values inscrutable, and will break if the user a) derives Enum and b) changes the order of their constructors. Long-term, this should be implemented in PostgreSQL as a proper enum anyway, which mostly renders the performance argument moot.

Methods

toText :: a -> Text

fromText :: Text -> a

Instances

(Typeable a, Bounded a, Enum a, Show a, Read a) => SqlEnum a

Defined in Database.Selda.SqlType

Methods

toText :: a -> Text

fromText :: Text -> a

class Columns a

Any column tuple.

Minimal complete definition

toTup, fromTup

Instances

(SqlRow a, Columns b) => Columns (Row s a :*: b)

Defined in Database.Selda.Column

Methods

toTup :: [ColName] -> Row s a :*: b

fromTup :: (Row s a :*: b) -> [UntypedCol SQL]

(SqlType a, Columns b) => Columns (Col s a :*: b)

Defined in Database.Selda.Column

Methods

toTup :: [ColName] -> Col s a :*: b

fromTup :: (Col s a :*: b) -> [UntypedCol SQL]

Columns (Col s a)

Defined in Database.Selda.Column

Methods

toTup :: [ColName] -> Col s a

fromTup :: Col s a -> [UntypedCol SQL]

Columns (Row s a)

Defined in Database.Selda.Column

Methods

toTup :: [ColName] -> Row s a

fromTup :: Row s a -> [UntypedCol SQL]

class s ~ t => Same s t

Denotes that scopes s and t are identical.

Instances

(s ~ t, (TypeError (Text "An identifier from an outer scope may not be used in an inner query.") :: Constraint)) => Same (s :: k) (t :: k)

Defined in Database.Selda.Column

Methods

liftC2 :: (Exp SQL a -> Exp SQL b -> Exp SQL c) -> Col s a -> Col t b -> Col s c

Same (s :: k) (s :: k)

Defined in Database.Selda.Column

Methods

liftC2 :: (Exp SQL a -> Exp SQL b -> Exp SQL c) -> Col s a -> Col s b -> Col s c

data Order

The order in which to sort result rows.

Constructors

Asc

Desc

Instances

Eq Order

Defined in Database.Selda.SQL

Methods

(==) :: Order -> Order -> Bool

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

Ord Order

Defined in Database.Selda.SQL

Methods

compare :: Order -> Order -> Ordering

(<) :: Order -> Order -> Bool

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

(>) :: Order -> Order -> Bool

(>=) :: Order -> Order -> Bool

max :: Order -> Order -> Order

min :: Order -> Order -> Order

Show Order

Defined in Database.Selda.SQL

Methods

showsPrec :: Int -> Order -> ShowS

show :: Order -> String

showList :: [Order] -> ShowS

data a :*: b where infixr 1

An inductively defined "tuple", or heterogeneous, non-empty list.

Constructors

(:*:) :: a -> b -> a :*: b infixr 1

Instances

(Eq a, Eq b) => Eq (a :*: b)

Defined in Database.Selda.Types

Methods

(==) :: (a :*: b) -> (a :*: b) -> Bool

(/=) :: (a :*: b) -> (a :*: b) -> Bool

(Ord a, Ord b) => Ord (a :*: b)

Defined in Database.Selda.Types

Methods

compare :: (a :*: b) -> (a :*: b) -> Ordering

(<) :: (a :*: b) -> (a :*: b) -> Bool

(<=) :: (a :*: b) -> (a :*: b) -> Bool

(>) :: (a :*: b) -> (a :*: b) -> Bool

(>=) :: (a :*: b) -> (a :*: b) -> Bool

max :: (a :*: b) -> (a :*: b) -> a :*: b

min :: (a :*: b) -> (a :*: b) -> a :*: b

(Show a, Show b) => Show (a :*: b)

Defined in Database.Selda.Types

Methods

showsPrec :: Int -> (a :*: b) -> ShowS

show :: (a :*: b) -> String

showList :: [a :*: b] -> ShowS

Generic (a :*: b)

Defined in Database.Selda.Types

Associated Types

type Rep (a :*: b) :: Type -> Type

Methods

from :: (a :*: b) -> Rep (a :*: b) x

to :: Rep (a :*: b) x -> a :*: b

Tup (a :*: b)

Defined in Database.Selda.Types

Methods

tupHead :: (a :*: b) -> Head (a :*: b)

(SqlRow a, Columns b) => Columns (Row s a :*: b)

Defined in Database.Selda.Column

Methods

toTup :: [ColName] -> Row s a :*: b

fromTup :: (Row s a :*: b) -> [UntypedCol SQL]

(SqlType a, Columns b) => Columns (Col s a :*: b)

Defined in Database.Selda.Column

Methods

toTup :: [ColName] -> Col s a :*: b

fromTup :: (Col s a :*: b) -> [UntypedCol SQL]

Aggregates b => Aggregates (Aggr (Inner s) a :*: b)

Defined in Database.Selda.Inner

Methods

unAggrs :: (Aggr (Inner s) a :*: b) -> [UntypedCol SQL]

(SqlRow a, Result b) => Result (Row s a :*: b)

Defined in Database.Selda.Compile

Methods

toRes :: Proxy (Row s a :*: b) -> ResultReader (Res (Row s a :*: b))

finalCols :: (Row s a :*: b) -> [SomeCol SQL]

(SqlType a, Result b) => Result (Col s a :*: b)

Defined in Database.Selda.Compile

Methods

toRes :: Proxy (Col s a :*: b) -> ResultReader (Res (Col s a :*: b))

finalCols :: (Col s a :*: b) -> [SomeCol SQL]

type Rep (a :*: b)

Defined in Database.Selda.Types

type Rep (a :*: b) = D1 (MetaData ":*:" "Database.Selda.Types" "selda-0.5.1.0-AKzjAihhRTX3ZzXNm1yjsq" False) (C1 (MetaCons ":*:" (InfixI RightAssociative 1) False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 b)))

select :: Relational a => Table a -> Query s (Row s a)

Query the given table.

selectValues :: forall s a. Relational a => [a] -> Query s (Row s a)

Query an ad hoc table of type a. Each element in the given list represents one row in the ad hoc table.

from :: (Typeable t, SqlType a) => Selector t a -> Query s (Row s t) -> Query s (Col s a) infixr 7

Convenient shorthand for fmap (! sel) q. The following two queries are quivalent:

q1 = name `from` select people
q2 = do
  person <- select people
  return (person ! name)

distinct :: (Columns a, Columns (OuterCols a)) => Query (Inner s) a -> Query s (OuterCols a)

Remove all duplicates from the result set.

restrict :: Same s t => Col s Bool -> Query t ()

Restrict the query somehow. Roughly equivalent to WHERE.

limit :: Same s t => Int -> Int -> Query (Inner s) a -> Query t (OuterCols a)

Drop the first m rows, then get at most n of the remaining rows from the given subquery.

order :: (Same s t, SqlType a) => Col s a -> Order -> Query t ()

Sort the result rows in ascending or descending order on the given row.

If multiple order directives are given, later directives are given precedence but do not cancel out earlier ordering directives. To get a list of persons sorted primarily on age and secondarily on name:

peopleInAgeAndNameOrder = do
  person <- select people
  order (person ! name) ascending
  order (person ! age) ascending
  return (person ! name)

For a table [(Alice, 20), (Bob, 20), (Eve, 18)], this query will always return [Eve, Alice, Bob].

The reason for later orderings taking precedence and not the other way around is composability: order should always sort the current result set to avoid weird surprises when a previous order directive is buried somewhere deep in an earlier query. However, the ordering must always be stable, to ensure that previous calls to order are not simply erased.

ascending :: Order

Ordering for order.

descending :: Order

Ordering for order.

orderRandom :: Query s ()

Sort the result rows in random order.

inner :: (Columns a, Columns (OuterCols a)) => Query (Inner s) a -> Query s (OuterCols a)

Explicitly create an inner query. Equivalent to innerJoin (const true).

Sometimes it's handy, for performance reasons and otherwise, to perform a subquery and restrict only that query before adding the result of the query to the result set, instead of first adding the query to the result set and restricting the whole result set afterwards.

suchThat :: (Columns a, Columns (OuterCols a)) => Query (Inner s) a -> (a -> Col (Inner s) Bool) -> Query s (OuterCols a) infixr 7

Create and filter an inner query, before adding it to the current result set.

q suchThat p is generally more efficient than select q >>= x -> restrict (p x) >> pure x.

Working with selectors

data Selector t a

A column selector. Column selectors can be used together with the ! and with functions to get and set values on rows, or to specify foreign keys.

Instances

SelectorLike Selector

Defined in Database.Selda.Table

Methods

indices :: Selector t a -> [Int]

(Relational t, HasField name t, FieldType name t ~ a) => IsLabel name (Selector t a)

Defined in Database.Selda.FieldSelectors

Methods

fromLabel :: Selector t a

type family Coalesce a where ...

Coalesce nested nullable column into a single level of nesting.

Equations

Coalesce (Maybe (Maybe a)) = Coalesce (Maybe a)

Coalesce a = a

class (Relational t, SqlType (FieldType name t), GRSel name (Rep t), NonError (FieldType name t)) => HasField (name :: Symbol) t

Any table type t, which has a field named name.

Instances

(Relational t, SqlType (FieldType name t), GRSel name (Rep t), NonError (FieldType name t)) => HasField name t

Defined in Database.Selda.FieldSelectors

type FieldType name t = GFieldType (Rep t) (NoSuchSelector t name) name

The type of the name field, in the record type t.

class IsLabel (x :: Symbol) a

Minimal complete definition

fromLabel

Instances

IsLabel x (Selector t a) => IsLabel x (Group t a)

Defined in Database.Selda.Table

Methods

fromLabel :: Group t a

(Relational t, HasField name t, FieldType name t ~ a) => IsLabel name (Selector t a)

Defined in Database.Selda.FieldSelectors

Methods

fromLabel :: Selector t a

(!) :: SqlType a => Row s t -> Selector t a -> Col s a infixl 9

Extract the given column from the given row.

(?) :: SqlType a => Row s (Maybe t) -> Selector t a -> Col s (Coalesce (Maybe a)) infixl 9

Extract the given column from the given nullable row. Nullable rows usually result from left joins. If a nullable column is extracted from a nullable row, the resulting nested Maybes will be squashed into a single level of nesting.

data Assignment s a where

A selector-value assignment pair.

Constructors

(:=) :: Selector t a -> Col s a -> Assignment s t infixl 2

Set the given column to the given value.

with :: Row s a -> [Assignment s a] -> Row s a

For each selector-value pair in the given list, on the given tuple, update the field pointed out by the selector with the corresponding value.

(+=) :: (SqlType a, Num (Col s a)) => Selector t a -> Col s a -> Assignment s t infixl 2

Add the given column to the column pointed to by the given selector.

(-=) :: (SqlType a, Num (Col s a)) => Selector t a -> Col s a -> Assignment s t infixl 2

Subtract the given column from the column pointed to by the given selector.

(*=) :: (SqlType a, Num (Col s a)) => Selector t a -> Col s a -> Assignment s t infixl 2

Multiply the column pointed to by the given selector, by the given column.

(||=) :: Selector t Bool -> Col s Bool -> Assignment s t infixl 2

Logically OR the column pointed to by the given selector with the given column.

(&&=) :: Selector t Bool -> Col s Bool -> Assignment s t infixl 2

Logically AND the column pointed to by the given selector with the given column.

($=) :: Selector t a -> (Col s a -> Col s a) -> Assignment s t infixl 2

Apply the given function to the given column.

Expressions over columns

class Set set where

Any container type for which we can check object membership.

Methods

isIn :: (Same s t, SqlType a) => Col s a -> set (Col t a) -> Col s Bool infixl 4

Is the given column contained in the given set?

Instances

Set []

Defined in Database.Selda

Methods

isIn :: (Same s t, SqlType a) => Col s a -> [Col t a] -> Col s Bool

Set (Query s)

Defined in Database.Selda

Methods

isIn :: (Same s0 t, SqlType a) => Col s0 a -> Query s (Col t a) -> Col s0 Bool

data ID a

A typed row identifier. Generic tables should use this instead of RowID. Use untyped to erase the type of a row identifier, and cast from the Database.Selda.Unsafe module if you for some reason need to add a type to a row identifier.

Instances

Eq (ID a)

Defined in Database.Selda.SqlType

Methods

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

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

Ord (ID a)

Defined in Database.Selda.SqlType

Methods

compare :: ID a -> ID a -> Ordering

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

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

(>) :: ID a -> ID a -> Bool

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

max :: ID a -> ID a -> ID a

min :: ID a -> ID a -> ID a

Show (ID a)

Defined in Database.Selda.SqlType

Methods

showsPrec :: Int -> ID a -> ShowS

show :: ID a -> String

showList :: [ID a] -> ShowS

Generic (ID a)

Defined in Database.Selda.SqlType

Associated Types

type Rep (ID a) :: Type -> Type

Methods

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

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

Typeable a => SqlType (ID a)

Defined in Database.Selda.SqlType

Methods

mkLit :: ID a -> Lit (ID a)

sqlType :: Proxy (ID a) -> SqlTypeRep

fromSql :: SqlValue -> ID a

defaultValue :: Lit (ID a)

Typeable a => SqlOrd (ID a)

Defined in Database.Selda

type Rep (ID a)

Defined in Database.Selda.SqlType

type Rep (ID a) = D1 (MetaData "ID" "Database.Selda.SqlType" "selda-0.5.1.0-AKzjAihhRTX3ZzXNm1yjsq" True) (C1 (MetaCons "ID" PrefixI True) (S1 (MetaSel (Just "untyped") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 RowID)))

invalidId :: ID a

A typed row identifier which is guaranteed to not match any row in any table.

isInvalidId :: ID a -> Bool

Is the given typed row identifier invalid? I.e. is it guaranteed to not match any row in any table?

untyped :: ID a -> RowID

fromId :: ID a -> Int

Create a typed row identifier from an integer. Use with caution, preferably only when reading user input.

toId :: Int -> ID a

Create a typed row identifier from an integer. Use with caution, preferably only when reading user input.

data RowID

A row identifier for some table. This is the type of auto-incrementing primary keys.

Instances

Eq RowID

Defined in Database.Selda.SqlType

Methods

(==) :: RowID -> RowID -> Bool

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

Ord RowID

Defined in Database.Selda.SqlType

Methods

compare :: RowID -> RowID -> Ordering

(<) :: RowID -> RowID -> Bool

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

(>) :: RowID -> RowID -> Bool

(>=) :: RowID -> RowID -> Bool

max :: RowID -> RowID -> RowID

min :: RowID -> RowID -> RowID

Show RowID

Defined in Database.Selda.SqlType

Methods

showsPrec :: Int -> RowID -> ShowS

show :: RowID -> String

showList :: [RowID] -> ShowS

Generic RowID

Defined in Database.Selda.SqlType

Associated Types

type Rep RowID :: Type -> Type

Methods

from :: RowID -> Rep RowID x

to :: Rep RowID x -> RowID

SqlType RowID

Defined in Database.Selda.SqlType

Methods

mkLit :: RowID -> Lit RowID

sqlType :: Proxy RowID -> SqlTypeRep

fromSql :: SqlValue -> RowID

defaultValue :: Lit RowID

SqlOrd RowID

Defined in Database.Selda

type Rep RowID

Defined in Database.Selda.SqlType

type Rep RowID = D1 (MetaData "RowID" "Database.Selda.SqlType" "selda-0.5.1.0-AKzjAihhRTX3ZzXNm1yjsq" True) (C1 (MetaCons "RowID" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Int)))

invalidRowId :: RowID

A row identifier which is guaranteed to not match any row in any table.

isInvalidRowId :: RowID -> Bool

Is the given row identifier invalid? I.e. is it guaranteed to not match any row in any table?

fromRowId :: RowID -> Int

Inspect a row identifier.

toRowId :: Int -> RowID

Create a row identifier from an integer. Use with caution, preferably only when reading user input.

(.==) :: (Same s t, SqlType a) => Col s a -> Col t a -> Col s Bool infixl 4

Comparisons over columns. Note that when comparing nullable (i.e. Maybe) columns, SQL NULL semantics are used. This means that comparing to a NULL field will remove the row in question from the current set. To test for NULL, use isNull instead of .== literal Nothing.

(./=) :: (Same s t, SqlType a) => Col s a -> Col t a -> Col s Bool infixl 4

Comparisons over columns. Note that when comparing nullable (i.e. Maybe) columns, SQL NULL semantics are used. This means that comparing to a NULL field will remove the row in question from the current set. To test for NULL, use isNull instead of .== literal Nothing.

(.>) :: (Same s t, SqlOrd a) => Col s a -> Col t a -> Col s Bool infixl 4

(.<) :: (Same s t, SqlOrd a) => Col s a -> Col t a -> Col s Bool infixl 4

(.>=) :: (Same s t, SqlOrd a) => Col s a -> Col t a -> Col s Bool infixl 4

(.<=) :: (Same s t, SqlOrd a) => Col s a -> Col t a -> Col s Bool infixl 4

like :: Same s t => Col s Text -> Col t Text -> Col s Bool infixl 4

The SQL LIKE operator; matches strings with % wildcards. For instance:

"%gon" `like` "dragon" .== true

(.&&) :: Same s t => Col s Bool -> Col t Bool -> Col s Bool infixr 3

(.||) :: Same s t => Col s Bool -> Col t Bool -> Col s Bool infixr 2

not_ :: Col s Bool -> Col s Bool

Boolean negation.

literal :: SqlType a => a -> Col s a

A literal expression.

is :: forall r s c. SqlType c => Selector r c -> c -> Row s r -> Col s Bool

Returns true if the given field in the given row is equal to the given literal.

int :: Int -> Col s Int

Specialization of literal for integers.

float :: Double -> Col s Double

Specialization of literal for doubles.

text :: Text -> Col s Text

Specialization of literal for text.

true :: Col s Bool

True and false boolean literals.

false :: Col s Bool

True and false boolean literals.

null_ :: SqlType a => Col s (Maybe a)

SQL NULL, at any type you like.

roundTo :: Col s Int -> Col s Double -> Col s Double

Round a column to the given number of decimals places.

length_ :: Col s Text -> Col s Int

Calculate the length of a string column.

isNull :: SqlType a => Col s (Maybe a) -> Col s Bool

Is the given column null?

ifThenElse :: (Same s t, Same t u, SqlType a) => Col s Bool -> Col t a -> Col u a -> Col s a

Perform a conditional on a column

ifNull :: (Same s t, SqlType a) => Col s a -> Col t (Maybe a) -> Col s a

If the second value is Nothing, return the first value. Otherwise return the second value.

matchNull :: (SqlType a, SqlType b, Same s t) => Col s b -> (Col s a -> Col s b) -> Col t (Maybe a) -> Col s b

Applies the given function to the given nullable column where it isn't null, and returns the given default value where it is.

This is the Selda equivalent of maybe.

new :: forall s a. Relational a => [Assignment s a] -> Row s a

Create a new column with the given fields. Any unassigned fields will contain their default values.

only :: SqlType a => Col s a -> Row s (Only a)

Create a singleton table column from an appropriate value.

class Mappable f where

Any container type which can be mapped over. Sort of like Functor, if you squint a bit.

Associated Types

type Container f a

Methods

(.<$>) :: (SqlType a, SqlType b) => (Col s a -> Col s b) -> f s (Container f a) -> f s (Container f b) infixl 4

Instances

Mappable Aggr

Defined in Database.Selda

Associated Types

type Container Aggr a :: Type

Methods

(.<$>) :: (SqlType a, SqlType b) => (Col s a -> Col s b) -> Aggr s (Container Aggr a) -> Aggr s (Container Aggr b)

Mappable (Col :: Type -> Type -> Type)

Defined in Database.Selda

Associated Types

type Container Col a :: Type

Methods

(.<$>) :: (SqlType a, SqlType b) => (Col s a -> Col s b) -> Col s (Container Col a) -> Col s (Container Col b)

Converting between column types

round_ :: forall s a. (SqlType a, Num a) => Col s Double -> Col s a

Round a value to the nearest integer. Equivalent to roundTo 0.

just :: SqlType a => Col s a -> Col s (Maybe a)

Lift a non-nullable column to a nullable one. Useful for creating expressions over optional columns:

data Person = Person {name :: Text, age :: Int, pet :: Maybe Text}
  deriving Generic
instance SqlRow Person

people :: Table Person
people = table "people" []

peopleWithCats = do
  person <- select people
  restrict (person ! #pet .== just "cat")
  return (person ! #name)

fromBool :: (SqlType a, Num a) => Col s Bool -> Col s a

Convert a boolean column to any numeric type.

fromInt :: (SqlType a, Num a) => Col s Int -> Col s a

Convert an integer column to any numeric type.

toString :: SqlType a => Col s a -> Col s Text

Convert any SQL type to a string.

Inner queries

data Aggr s a

A single aggregate column. Aggregate columns may not be used to restrict queries. When returned from an aggregate subquery, an aggregate column is converted into a non-aggregate column.

Instances

Mappable Aggr

Defined in Database.Selda

Associated Types

type Container Aggr a :: Type

Methods

(.<$>) :: (SqlType a, SqlType b) => (Col s a -> Col s b) -> Aggr s (Container Aggr a) -> Aggr s (Container Aggr b)

Aggregates b => Aggregates (Aggr (Inner s) a :*: b)

Defined in Database.Selda.Inner

Methods

unAggrs :: (Aggr (Inner s) a :*: b) -> [UntypedCol SQL]

Aggregates (Aggr (Inner s) a)

Defined in Database.Selda.Inner

Methods

unAggrs :: Aggr (Inner s) a -> [UntypedCol SQL]

type Container Aggr a

Defined in Database.Selda

type Container Aggr a = a

class Aggregates a

One or more aggregate columns.

Minimal complete definition

unAggrs

Instances

Aggregates b => Aggregates (Aggr (Inner s) a :*: b)

Defined in Database.Selda.Inner

Methods

unAggrs :: (Aggr (Inner s) a :*: b) -> [UntypedCol SQL]

Aggregates (Aggr (Inner s) a)

Defined in Database.Selda.Inner

Methods

unAggrs :: Aggr (Inner s) a -> [UntypedCol SQL]

type family OuterCols a where ...

Convert one or more inner column to equivalent columns in the outer query. OuterCols (Aggr (Inner s) a :*: Aggr (Inner s) b) = Col s a :*: Col s b, for instance.

Equations

OuterCols (Col (Inner s) a :*: b) = Col s a :*: OuterCols b

OuterCols (Col (Inner s) a) = Col s a

OuterCols (Row (Inner s) a :*: b) = Row s a :*: OuterCols b

OuterCols (Row (Inner s) a) = Row s a

OuterCols (Col s a) = TypeError (Text "An inner query can only return rows and columns from its own scope.")

OuterCols (Row s a) = TypeError (Text "An inner query can only return rows and columns from its own scope.")

OuterCols a = TypeError (Text "Only (inductive tuples of) row and columns can be returned from" :$$: Text "an inner query.")

type family AggrCols a where ...

Equations

AggrCols (Aggr (Inner s) a :*: b) = Col s a :*: AggrCols b

AggrCols (Aggr (Inner s) a) = Col s a

AggrCols (Aggr s a) = TypeError (Text "An aggregate query can only return columns from its own" :$$: Text "scope.")

AggrCols a = TypeError (Text "Only (inductive tuples of) aggregates can be returned from" :$$: Text "an aggregate query.")

type family LeftCols a where ...

The results of a left join are always nullable, as there is no guarantee that all joined columns will be non-null. JoinCols a where a is an extensible tuple is that same tuple, but in the outer query and with all elements nullable. For instance:

 LeftCols (Col (Inner s) Int :*: Col (Inner s) Text)
   = Col s (Maybe Int) :*: Col s (Maybe Text)

Equations

LeftCols (Col (Inner s) (Maybe a) :*: b) = Col s (Maybe a) :*: LeftCols b

LeftCols (Col (Inner s) a :*: b) = Col s (Maybe a) :*: LeftCols b

LeftCols (Col (Inner s) (Maybe a)) = Col s (Maybe a)

LeftCols (Col (Inner s) a) = Col s (Maybe a)

LeftCols (Row (Inner s) (Maybe a) :*: b) = Row s (Maybe a) :*: LeftCols b

LeftCols (Row (Inner s) a :*: b) = Row s (Maybe a) :*: LeftCols b

LeftCols (Row (Inner s) (Maybe a)) = Row s (Maybe a)

LeftCols (Row (Inner s) a) = Row s (Maybe a)

LeftCols a = TypeError (Text "Only (inductive tuples of) rows and columns can be returned" :$$: Text "from a join.")

data Inner s

Denotes an inner query. For aggregation, treating sequencing as the cartesian product of queries does not work well. Instead, we treat the sequencing of aggregate with other queries as the cartesian product of the aggregated result of the query, a small but important difference.

However, for this to work, the aggregate query must not depend on any columns in the outer product. Therefore, we let the aggregate query be parameterized over Inner s if the parent query is parameterized over s, to enforce this separation.

Instances

Aggregates b => Aggregates (Aggr (Inner s) a :*: b)

Defined in Database.Selda.Inner

Methods

unAggrs :: (Aggr (Inner s) a :*: b) -> [UntypedCol SQL]

Aggregates (Aggr (Inner s) a)

Defined in Database.Selda.Inner

Methods

unAggrs :: Aggr (Inner s) a -> [UntypedCol SQL]

class SqlType a => SqlOrd a

Any column type that can be used with the min_ and max_ functions.

Instances

(SqlType a, Num a) => SqlOrd a

Defined in Database.Selda

SqlOrd Text

Defined in Database.Selda

SqlOrd TimeOfDay

Defined in Database.Selda

SqlOrd UTCTime

Defined in Database.Selda

SqlOrd Day

Defined in Database.Selda

SqlOrd RowID

Defined in Database.Selda

SqlOrd a => SqlOrd (Maybe a)

Defined in Database.Selda

Typeable a => SqlOrd (ID a)

Defined in Database.Selda

innerJoin

Arguments

:: (Columns a, Columns (OuterCols a))

=> (OuterCols a -> Col s Bool)

Predicate determining which lines to join. | Right-hand query to join.

-> Query (Inner s) a

-> Query s (OuterCols a)

Perform an INNER JOIN with the current result set and the given query.

leftJoin

Arguments

:: (Columns a, Columns (OuterCols a), Columns (LeftCols a))

=> (OuterCols a -> Col s Bool)

Predicate determining which lines to join. | Right-hand query to join.

-> Query (Inner s) a

-> Query s (LeftCols a)

Perform a LEFT JOIN with the current result set (i.e. the outer query) as the left hand side, and the given query as the right hand side. Like with aggregate, the inner (or right) query must not depend on the outer (or right) one.

The given predicate over the values returned by the inner query determines for each row whether to join or not. This predicate may depend on any values from the outer query.

For instance, the following will list everyone in the people table together with their address if they have one; if they don't, the address field will be NULL.

getAddresses :: Query s (Col s Text :*: Col s (Maybe Text))
getAddresses = do
  (name :*: _) <- select people
  (_ :*: address) <- leftJoin (\(n :*: _) -> n .== name)
                              (select addresses)
  return (name :*: address)

aggregate :: (Columns (AggrCols a), Aggregates a) => Query (Inner s) a -> Query s (AggrCols a)

Execute a query, returning an aggregation of its results. The query must return an inductive tuple of Aggregate columns. When aggregate returns, those columns are converted into non-aggregate columns, which may then be used to further restrict the query.

Note that aggregate queries must not depend on outer queries, nor must they return any non-aggregate columns. Attempting to do either results in a type error.

The SQL HAVING keyword can be implemented by combining aggregate and restrict:

-- Find the number of people living on every address, for all addresses
-- with more than one tenant:
-- SELECT COUNT(name) AS c, address FROM housing GROUP BY name HAVING c > 1

numPpl = do
  (num_tenants :*: theAddress) <- aggregate $ do
    h <- select housing
    theAddress <- groupBy (h ! address)
    return (count (h ! address) :*: theAddress)
 restrict (num_tenants .> 1)
 return (num_tenants :*: theAddress)

groupBy :: (Same s t, SqlType a) => Col (Inner s) a -> Query (Inner t) (Aggr (Inner t) a)

Group an aggregate query by a column. Attempting to group a non-aggregate query is a type error. An aggregate representing the grouped-by column is returned, which can be returned from the aggregate query. For instance, if you want to find out how many people have a pet at home:

aggregate $ do
  person <- select people
  name' <- groupBy (person ! name)
  return (name' :*: count(person ! pet_name) .> 0)

count :: SqlType a => Col s a -> Aggr s Int

The number of non-null values in the given column.

avg :: (SqlType a, Num a) => Col s a -> Aggr s (Maybe a)

The average of all values in the given column.

sum_ :: forall a b s. (SqlType a, SqlType b, Num a, Num b) => Col s a -> Aggr s b

Sum all values in the given column.

max_ :: SqlOrd a => Col s a -> Aggr s (Maybe a)

The greatest value in the given column. Texts are compared lexically.

min_ :: SqlOrd a => Col s a -> Aggr s (Maybe a)

The smallest value in the given column. Texts are compared lexically.

Modifying tables

insert :: (MonadSelda m, Relational a) => Table a -> [a] -> m Int

Insert the given values into the given table. All columns of the table must be present. If your table has an auto-incrementing primary key, use the special value def for that column to get the auto-incrementing behavior. Returns the number of rows that were inserted.

To insert a list of tuples into a table with auto-incrementing primary key:

data Person = Person
  { id :: ID Person
  , name :: Text
  , age :: Int
  , pet :: Maybe Text
  } deriving Generic
instance SqlResult Person

people :: Table Person
people = table "people" [autoPrimary :- id]

main = withSQLite "my_database.sqlite" $ do
  insert_ people
    [ Person def "Link" 125 (Just "horse")
    , Person def "Zelda" 119 Nothing
    , ...
    ]

Note that if one or more of the inserted rows would cause a constraint violation, NO rows will be inserted; the whole insertion fails atomically.

insert_ :: (MonadSelda m, Relational a) => Table a -> [a] -> m ()

Like insert, but does not return anything. Use this when you really don't care about how many rows were inserted.

insertWithPK :: (MonadSelda m, Relational a) => Table a -> [a] -> m (ID a)

Like insert, but returns the primary key of the last inserted row. Attempting to run this operation on a table without an auto-incrementing primary key will always return a row identifier that is guaranteed to not match any row in any table.

tryInsert :: (MonadSelda m, MonadCatch m, Relational a) => Table a -> [a] -> m Bool

Attempt to insert a list of rows into a table, but don't raise an error if the insertion fails. Returns True if the insertion succeeded, otherwise False.

Like insert, if even one of the inserted rows would cause a constraint violation, the whole insert operation fails.

insertUnless :: (MonadSelda m, MonadMask m, Relational a) => Table a -> (Row (Backend m) a -> Col (Backend m) Bool) -> [a] -> m (Maybe (ID a))

Perform the given insert, if no rows already present in the table match the given predicate. Returns the primary key of the last inserted row, if the insert was performed. If called on a table which doesn't have an auto-incrementing primary key, Just id is always returned on successful insert, where id is a row identifier guaranteed to not match any row in any table.

insertWhen :: (MonadSelda m, MonadMask m, Relational a) => Table a -> (Row (Backend m) a -> Col (Backend m) Bool) -> [a] -> m (Maybe (ID a))

Like insertUnless, but performs the insert when at least one row matches the predicate.

def :: SqlType a => a

The default value for a column during insertion. For an auto-incrementing primary key, the default value is the next key.

Using def in any other context than insertion results in a runtime error.

update

Arguments

:: (MonadSelda m, Relational a)

=> Table a

Table to update.

-> (Row (Backend m) a -> Col (Backend m) Bool)

Predicate.

-> (Row (Backend m) a -> Row (Backend m) a)

Update function.

-> m Int

Update the given table using the given update function, for all rows matching the given predicate. Returns the number of updated rows.

update_ :: (MonadSelda m, Relational a) => Table a -> (Row (Backend m) a -> Col (Backend m) Bool) -> (Row (Backend m) a -> Row (Backend m) a) -> m ()

Like update, but doesn't return the number of updated rows.

upsert :: (MonadSelda m, MonadMask m, Relational a) => Table a -> (Row (Backend m) a -> Col (Backend m) Bool) -> (Row (Backend m) a -> Row (Backend m) a) -> [a] -> m (Maybe (ID a))

Attempt to perform the given update. If no rows were updated, insert the given row. Returns the primary key of the inserted row, if the insert was performed. Calling this function on a table which does not have a primary key will return Just id on a successful insert, where id is a row identifier guaranteed to not match any row in any table.

Note that this may perform two separate queries: one update, potentially followed by one insert.

deleteFrom :: (MonadSelda m, Relational a) => Table a -> (Row (Backend m) a -> Col (Backend m) Bool) -> m Int

From the given table, delete all rows matching the given predicate. Returns the number of deleted rows.

deleteFrom_ :: (MonadSelda m, Relational a) => Table a -> (Row (Backend m) a -> Col (Backend m) Bool) -> m ()

Like deleteFrom, but does not return the number of deleted rows.

Prepared statements

class Preparable q

Minimal complete definition

mkQuery

Instances

(SqlType a, Preparable b) => Preparable (Col s a -> b)

Defined in Database.Selda.Prepared

Methods

mkQuery :: MonadSelda m => Int -> (Col s a -> b) -> [SqlTypeRep] -> m CompResult

Result a => Preparable (Query s a)

Defined in Database.Selda.Prepared

Methods

mkQuery :: MonadSelda m => Int -> Query s a -> [SqlTypeRep] -> m CompResult

class Prepare q f

Some parameterized query q that can be prepared into a function f in some MonadSelda.

Minimal complete definition

mkFun

Instances

(Typeable a, MonadSelda m, a ~ Res (ResultT q), Result (ResultT q)) => Prepare q (m [a])

Defined in Database.Selda.Prepared

Methods

mkFun :: IORef (Maybe (BackendID, CompResult)) -> StmtID -> q -> [Param] -> m [a]

(SqlType a, Prepare q b) => Prepare q (a -> b)

Defined in Database.Selda.Prepared

Methods

mkFun :: IORef (Maybe (BackendID, CompResult)) -> StmtID -> q -> [Param] -> a -> b

prepared :: (Preparable q, Prepare q f, Equiv q f) => q -> f

Create a prepared Selda function. A prepared function has zero or more arguments, and will get compiled into a prepared statement by the first backend to execute it. Any subsequent calls to the function for the duration of the connection to the database will reuse the prepared statement.

Preparable functions are of the form (SqlType a, SqlType b, ...) => Col s a -> Col s b -> ... -> Query s r. The resulting prepared function will be of the form MonadSelda m => a -> b -> ... -> m [Res r]. Note, however, that when using prepared, you must give a concrete type for m due to how Haskell's type class resolution works.

Prepared functions rely on memoization for just-in-time preparation and caching. This means that if GHC accidentally inlines your prepared function, it may get prepared twice. While this does not affect the correctness of your program, and is fairly unlikely to happen, if you want to be absolutely sure that your queries aren't re-prepared more than absolutely necessary, consider adding a NOINLINE annotation to each prepared function.

Note that when using a constrained backend type variable (i.e. foo :: Bar b => SeldaM b [Int]), optimizations must be enabled for prepared statements to be effective.

A usage example:

persons :: Table (Text, Int)
(persons, name :*: age) = tableWithSelectors "ages" [name :- primary]

{-# NOINLINE ageOf #-}
ageOf :: Text -> SeldaM [Int]
ageOf = prepared $ \n -> do
  person <- select ages
  restrict $ (person!name .== n)
  return age

Defining schemas

class Generic a

Representable types of kind *. This class is derivable in GHC with the DeriveGeneric flag on.

A Generic instance must satisfy the following laws:

from . to ≡ id
to . from ≡ id

Minimal complete definition

from, to

Instances

Generic Bool

Defined in GHC.Generics

Associated Types

type Rep Bool :: Type -> Type

Methods

from :: Bool -> Rep Bool x

to :: Rep Bool x -> Bool

Generic Ordering

Defined in GHC.Generics

Associated Types

type Rep Ordering :: Type -> Type

Methods

from :: Ordering -> Rep Ordering x

to :: Rep Ordering x -> Ordering

Generic Exp

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep Exp :: Type -> Type

Methods

from :: Exp -> Rep Exp x

to :: Rep Exp x -> Exp

Generic Match

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep Match :: Type -> Type

Methods

from :: Match -> Rep Match x

to :: Rep Match x -> Match

Generic Clause

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep Clause :: Type -> Type

Methods

from :: Clause -> Rep Clause x

to :: Rep Clause x -> Clause

Generic Pat

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep Pat :: Type -> Type

Methods

from :: Pat -> Rep Pat x

to :: Rep Pat x -> Pat

Generic Type

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep Type :: Type -> Type

Methods

from :: Type -> Rep Type x

to :: Rep Type x -> Type

Generic Dec

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep Dec :: Type -> Type

Methods

from :: Dec -> Rep Dec x

to :: Rep Dec x -> Dec

Generic Name

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep Name :: Type -> Type

Methods

from :: Name -> Rep Name x

to :: Rep Name x -> Name

Generic FunDep

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep FunDep :: Type -> Type

Methods

from :: FunDep -> Rep FunDep x

to :: Rep FunDep x -> FunDep

Generic InjectivityAnn

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep InjectivityAnn :: Type -> Type

Methods

from :: InjectivityAnn -> Rep InjectivityAnn x

to :: Rep InjectivityAnn x -> InjectivityAnn

Generic Overlap

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep Overlap :: Type -> Type

Methods

from :: Overlap -> Rep Overlap x

to :: Rep Overlap x -> Overlap

Generic ()

Defined in GHC.Generics

Associated Types

type Rep () :: Type -> Type

Methods

from :: () -> Rep () x

to :: Rep () x -> ()

Generic Void

Defined in Data.Void

Associated Types

type Rep Void :: Type -> Type

Methods

from :: Void -> Rep Void x

to :: Rep Void x -> Void

Generic Version

Defined in Data.Version

Associated Types

type Rep Version :: Type -> Type

Methods

from :: Version -> Rep Version x

to :: Rep Version x -> Version

Generic ExitCode

Defined in GHC.IO.Exception

Associated Types

type Rep ExitCode :: Type -> Type

Methods

from :: ExitCode -> Rep ExitCode x

to :: Rep ExitCode x -> ExitCode

Generic All

Defined in Data.Semigroup.Internal

Associated Types

type Rep All :: Type -> Type

Methods

from :: All -> Rep All x

to :: Rep All x -> All

Generic Any

Defined in Data.Semigroup.Internal

Associated Types

type Rep Any :: Type -> Type

Methods

from :: Any -> Rep Any x

to :: Rep Any x -> Any

Generic Fixity

Defined in GHC.Generics

Associated Types

type Rep Fixity :: Type -> Type

Methods

from :: Fixity -> Rep Fixity x

to :: Rep Fixity x -> Fixity

Generic Associativity

Defined in GHC.Generics

Associated Types

type Rep Associativity :: Type -> Type

Methods

from :: Associativity -> Rep Associativity x

to :: Rep Associativity x -> Associativity

Generic SourceUnpackedness

Defined in GHC.Generics

Associated Types

type Rep SourceUnpackedness :: Type -> Type

Methods

from :: SourceUnpackedness -> Rep SourceUnpackedness x

to :: Rep SourceUnpackedness x -> SourceUnpackedness

Generic SourceStrictness

Defined in GHC.Generics

Associated Types

type Rep SourceStrictness :: Type -> Type

Methods

from :: SourceStrictness -> Rep SourceStrictness x

to :: Rep SourceStrictness x -> SourceStrictness

Generic DecidedStrictness

Defined in GHC.Generics

Associated Types

type Rep DecidedStrictness :: Type -> Type

Methods

from :: DecidedStrictness -> Rep DecidedStrictness x

to :: Rep DecidedStrictness x -> DecidedStrictness

Generic Extension

Defined in GHC.LanguageExtensions.Type

Associated Types

type Rep Extension :: Type -> Type

Methods

from :: Extension -> Rep Extension x

to :: Rep Extension x -> Extension

Generic ForeignSrcLang

Defined in GHC.ForeignSrcLang.Type

Associated Types

type Rep ForeignSrcLang :: Type -> Type

Methods

from :: ForeignSrcLang -> Rep ForeignSrcLang x

to :: Rep ForeignSrcLang x -> ForeignSrcLang

Generic ModName

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep ModName :: Type -> Type

Methods

from :: ModName -> Rep ModName x

to :: Rep ModName x -> ModName

Generic PkgName

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep PkgName :: Type -> Type

Methods

from :: PkgName -> Rep PkgName x

to :: Rep PkgName x -> PkgName

Generic Module

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep Module :: Type -> Type

Methods

from :: Module -> Rep Module x

to :: Rep Module x -> Module

Generic OccName

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep OccName :: Type -> Type

Methods

from :: OccName -> Rep OccName x

to :: Rep OccName x -> OccName

Generic NameFlavour

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep NameFlavour :: Type -> Type

Methods

from :: NameFlavour -> Rep NameFlavour x

to :: Rep NameFlavour x -> NameFlavour

Generic NameSpace

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep NameSpace :: Type -> Type

Methods

from :: NameSpace -> Rep NameSpace x

to :: Rep NameSpace x -> NameSpace

Generic Loc

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep Loc :: Type -> Type

Methods

from :: Loc -> Rep Loc x

to :: Rep Loc x -> Loc

Generic Info

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep Info :: Type -> Type

Methods

from :: Info -> Rep Info x

to :: Rep Info x -> Info

Generic ModuleInfo

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep ModuleInfo :: Type -> Type

Methods

from :: ModuleInfo -> Rep ModuleInfo x

to :: Rep ModuleInfo x -> ModuleInfo

Generic Fixity

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep Fixity :: Type -> Type

Methods

from :: Fixity -> Rep Fixity x

to :: Rep Fixity x -> Fixity

Generic FixityDirection

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep FixityDirection :: Type -> Type

Methods

from :: FixityDirection -> Rep FixityDirection x

to :: Rep FixityDirection x -> FixityDirection

Generic Lit

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep Lit :: Type -> Type

Methods

from :: Lit -> Rep Lit x

to :: Rep Lit x -> Lit

Generic Body

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep Body :: Type -> Type

Methods

from :: Body -> Rep Body x

to :: Rep Body x -> Body

Generic Guard

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep Guard :: Type -> Type

Methods

from :: Guard -> Rep Guard x

to :: Rep Guard x -> Guard

Generic Stmt

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep Stmt :: Type -> Type

Methods

from :: Stmt -> Rep Stmt x

to :: Rep Stmt x -> Stmt

Generic Range

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep Range :: Type -> Type

Methods

from :: Range -> Rep Range x

to :: Rep Range x -> Range

Generic DerivClause

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep DerivClause :: Type -> Type

Methods

from :: DerivClause -> Rep DerivClause x

to :: Rep DerivClause x -> DerivClause

Generic DerivStrategy

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep DerivStrategy :: Type -> Type

Methods

from :: DerivStrategy -> Rep DerivStrategy x

to :: Rep DerivStrategy x -> DerivStrategy

Generic TypeFamilyHead

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep TypeFamilyHead :: Type -> Type

Methods

from :: TypeFamilyHead -> Rep TypeFamilyHead x

to :: Rep TypeFamilyHead x -> TypeFamilyHead

Generic TySynEqn

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep TySynEqn :: Type -> Type

Methods

from :: TySynEqn -> Rep TySynEqn x

to :: Rep TySynEqn x -> TySynEqn

Generic Foreign

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep Foreign :: Type -> Type

Methods

from :: Foreign -> Rep Foreign x

to :: Rep Foreign x -> Foreign

Generic Callconv

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep Callconv :: Type -> Type

Methods

from :: Callconv -> Rep Callconv x

to :: Rep Callconv x -> Callconv

Generic Safety

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep Safety :: Type -> Type

Methods

from :: Safety -> Rep Safety x

to :: Rep Safety x -> Safety

Generic Pragma

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep Pragma :: Type -> Type

Methods

from :: Pragma -> Rep Pragma x

to :: Rep Pragma x -> Pragma

Generic Inline

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep Inline :: Type -> Type

Methods

from :: Inline -> Rep Inline x

to :: Rep Inline x -> Inline

Generic RuleMatch

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep RuleMatch :: Type -> Type

Methods

from :: RuleMatch -> Rep RuleMatch x

to :: Rep RuleMatch x -> RuleMatch

Generic Phases

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep Phases :: Type -> Type

Methods

from :: Phases -> Rep Phases x

to :: Rep Phases x -> Phases

Generic RuleBndr

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep RuleBndr :: Type -> Type

Methods

from :: RuleBndr -> Rep RuleBndr x

to :: Rep RuleBndr x -> RuleBndr

Generic AnnTarget

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep AnnTarget :: Type -> Type

Methods

from :: AnnTarget -> Rep AnnTarget x

to :: Rep AnnTarget x -> AnnTarget

Generic SourceUnpackedness

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep SourceUnpackedness :: Type -> Type

Methods

from :: SourceUnpackedness -> Rep SourceUnpackedness x

to :: Rep SourceUnpackedness x -> SourceUnpackedness

Generic SourceStrictness

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep SourceStrictness :: Type -> Type

Methods

from :: SourceStrictness -> Rep SourceStrictness x

to :: Rep SourceStrictness x -> SourceStrictness

Generic DecidedStrictness

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep DecidedStrictness :: Type -> Type

Methods

from :: DecidedStrictness -> Rep DecidedStrictness x

to :: Rep DecidedStrictness x -> DecidedStrictness

Generic Con

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep Con :: Type -> Type

Methods

from :: Con -> Rep Con x

to :: Rep Con x -> Con

Generic Bang

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep Bang :: Type -> Type

Methods

from :: Bang -> Rep Bang x

to :: Rep Bang x -> Bang

Generic PatSynDir

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep PatSynDir :: Type -> Type

Methods

from :: PatSynDir -> Rep PatSynDir x

to :: Rep PatSynDir x -> PatSynDir

Generic PatSynArgs

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep PatSynArgs :: Type -> Type

Methods

from :: PatSynArgs -> Rep PatSynArgs x

to :: Rep PatSynArgs x -> PatSynArgs

Generic TyVarBndr

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep TyVarBndr :: Type -> Type

Methods

from :: TyVarBndr -> Rep TyVarBndr x

to :: Rep TyVarBndr x -> TyVarBndr

Generic FamilyResultSig

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep FamilyResultSig :: Type -> Type

Methods

from :: FamilyResultSig -> Rep FamilyResultSig x

to :: Rep FamilyResultSig x -> FamilyResultSig

Generic TyLit

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep TyLit :: Type -> Type

Methods

from :: TyLit -> Rep TyLit x

to :: Rep TyLit x -> TyLit

Generic Role

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep Role :: Type -> Type

Methods

from :: Role -> Rep Role x

to :: Rep Role x -> Role

Generic AnnLookup

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep AnnLookup :: Type -> Type

Methods

from :: AnnLookup -> Rep AnnLookup x

to :: Rep AnnLookup x -> AnnLookup

Generic RowID

Defined in Database.Selda.SqlType

Associated Types

type Rep RowID :: Type -> Type

Methods

from :: RowID -> Rep RowID x

to :: Rep RowID x -> RowID

Generic [a]

Defined in GHC.Generics

Associated Types

type Rep [a] :: Type -> Type

Methods

from :: [a] -> Rep [a] x

to :: Rep [a] x -> [a]

Generic (Maybe a)

Defined in GHC.Generics

Associated Types

type Rep (Maybe a) :: Type -> Type

Methods

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

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

Generic (Par1 p)

Defined in GHC.Generics

Associated Types

type Rep (Par1 p) :: Type -> Type

Methods

from :: Par1 p -> Rep (Par1 p) x

to :: Rep (Par1 p) x -> Par1 p

Generic (Complex a)

Defined in Data.Complex

Associated Types

type Rep (Complex a) :: Type -> Type

Methods

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

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

Generic (Min a)

Defined in Data.Semigroup

Associated Types

type Rep (Min a) :: Type -> Type

Methods

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

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

Generic (Max a)

Defined in Data.Semigroup

Associated Types

type Rep (Max a) :: Type -> Type

Methods

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

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

Generic (First a)

Defined in Data.Semigroup

Associated Types

type Rep (First a) :: Type -> Type

Methods

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

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

Generic (Last a)

Defined in Data.Semigroup

Associated Types

type Rep (Last a) :: Type -> Type

Methods

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

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

Generic (WrappedMonoid m)

Defined in Data.Semigroup

Associated Types

type Rep (WrappedMonoid m) :: Type -> Type

Methods

from :: WrappedMonoid m -> Rep (WrappedMonoid m) x

to :: Rep (WrappedMonoid m) x -> WrappedMonoid m

Generic (Option a)

Defined in Data.Semigroup

Associated Types

type Rep (Option a) :: Type -> Type

Methods

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

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

Generic (ZipList a)

Defined in Control.Applicative

Associated Types

type Rep (ZipList a) :: Type -> Type

Methods

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

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

Generic (Identity a)

Defined in Data.Functor.Identity

Associated Types

type Rep (Identity a) :: Type -> Type

Methods

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

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

Generic (First a)

Defined in Data.Monoid

Associated Types

type Rep (First a) :: Type -> Type

Methods

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

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

Generic (Last a)

Defined in Data.Monoid

Associated Types

type Rep (Last a) :: Type -> Type

Methods

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

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

Generic (Dual a)

Defined in Data.Semigroup.Internal

Associated Types

type Rep (Dual a) :: Type -> Type

Methods

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

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

Generic (Endo a)

Defined in Data.Semigroup.Internal

Associated Types

type Rep (Endo a) :: Type -> Type

Methods

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

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

Generic (Sum a)

Defined in Data.Semigroup.Internal

Associated Types

type Rep (Sum a) :: Type -> Type

Methods

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

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

Generic (Product a)

Defined in Data.Semigroup.Internal

Associated Types

type Rep (Product a) :: Type -> Type

Methods

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

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

Generic (Down a)

Defined in GHC.Generics

Associated Types

type Rep (Down a) :: Type -> Type

Methods

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

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

Generic (NonEmpty a)

Defined in GHC.Generics

Associated Types

type Rep (NonEmpty a) :: Type -> Type

Methods

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

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

Generic (Tree a)

Defined in Data.Tree

Associated Types

type Rep (Tree a) :: Type -> Type

Methods

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

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

Generic (FingerTree a)

Defined in Data.Sequence.Internal

Associated Types

type Rep (FingerTree a) :: Type -> Type

Methods

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

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

Generic (Digit a)

Defined in Data.Sequence.Internal

Associated Types

type Rep (Digit a) :: Type -> Type

Methods

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

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

Generic (Node a)

Defined in Data.Sequence.Internal

Associated Types

type Rep (Node a) :: Type -> Type

Methods

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

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

Generic (Elem a)

Defined in Data.Sequence.Internal

Associated Types

type Rep (Elem a) :: Type -> Type

Methods

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

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

Generic (ViewL a)

Defined in Data.Sequence.Internal

Associated Types

type Rep (ViewL a) :: Type -> Type

Methods

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

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

Generic (ViewR a)

Defined in Data.Sequence.Internal

Associated Types

type Rep (ViewR a) :: Type -> Type

Methods

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

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

Generic (ID a)

Defined in Database.Selda.SqlType

Associated Types

type Rep (ID a) :: Type -> Type

Methods

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

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

Generic (Only a)

Defined in Database.Selda

Associated Types

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

Methods

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

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

Generic (Either a b)

Defined in GHC.Generics

Associated Types

type Rep (Either a b) :: Type -> Type

Methods

from :: Either a b -> Rep (Either a b) x

to :: Rep (Either a b) x -> Either a b

Generic (V1 p)

Defined in GHC.Generics

Associated Types

type Rep (V1 p) :: Type -> Type

Methods

from :: V1 p -> Rep (V1 p) x

to :: Rep (V1 p) x -> V1 p

Generic (U1 p)

Defined in GHC.Generics

Associated Types

type Rep (U1 p) :: Type -> Type

Methods

from :: U1 p -> Rep (U1 p) x

to :: Rep (U1 p) x -> U1 p

Generic (a, b)

Defined in GHC.Generics

Associated Types

type Rep (a, b) :: Type -> Type

Methods

from :: (a, b) -> Rep (a, b) x

to :: Rep (a, b) x -> (a, b)

Generic (Arg a b)

Defined in Data.Semigroup

Associated Types

type Rep (Arg a b) :: Type -> Type

Methods

from :: Arg a b -> Rep (Arg a b) x

to :: Rep (Arg a b) x -> Arg a b

Generic (WrappedMonad m a)

Defined in Control.Applicative

Associated Types

type Rep (WrappedMonad m a) :: Type -> Type

Methods

from :: WrappedMonad m a -> Rep (WrappedMonad m a) x

to :: Rep (WrappedMonad m a) x -> WrappedMonad m a

Generic (Proxy t)

Defined in GHC.Generics

Associated Types

type Rep (Proxy t) :: Type -> Type

Methods

from :: Proxy t -> Rep (Proxy t) x

to :: Rep (Proxy t) x -> Proxy t

Generic (a :*: b)

Defined in Database.Selda.Types

Associated Types

type Rep (a :*: b) :: Type -> Type

Methods

from :: (a :*: b) -> Rep (a :*: b) x

to :: Rep (a :*: b) x -> a :*: b

Generic (Rec1 f p)

Defined in GHC.Generics

Associated Types

type Rep (Rec1 f p) :: Type -> Type

Methods

from :: Rec1 f p -> Rep (Rec1 f p) x

to :: Rep (Rec1 f p) x -> Rec1 f p

Generic (URec (Ptr ()) p)

Defined in GHC.Generics

Associated Types

type Rep (URec (Ptr ()) p) :: Type -> Type

Methods

from :: URec (Ptr ()) p -> Rep (URec (Ptr ()) p) x

to :: Rep (URec (Ptr ()) p) x -> URec (Ptr ()) p

Generic (URec Char p)

Defined in GHC.Generics

Associated Types

type Rep (URec Char p) :: Type -> Type

Methods

from :: URec Char p -> Rep (URec Char p) x

to :: Rep (URec Char p) x -> URec Char p

Generic (URec Double p)

Defined in GHC.Generics

Associated Types

type Rep (URec Double p) :: Type -> Type

Methods

from :: URec Double p -> Rep (URec Double p) x

to :: Rep (URec Double p) x -> URec Double p

Generic (URec Float p)

Defined in GHC.Generics

Associated Types

type Rep (URec Float p) :: Type -> Type

Methods

from :: URec Float p -> Rep (URec Float p) x

to :: Rep (URec Float p) x -> URec Float p

Generic (URec Int p)

Defined in GHC.Generics

Associated Types

type Rep (URec Int p) :: Type -> Type

Methods

from :: URec Int p -> Rep (URec Int p) x

to :: Rep (URec Int p) x -> URec Int p

Generic (URec Word p)

Defined in GHC.Generics

Associated Types

type Rep (URec Word p) :: Type -> Type

Methods

from :: URec Word p -> Rep (URec Word p) x

to :: Rep (URec Word p) x -> URec Word p

Generic (a, b, c)

Defined in GHC.Generics

Associated Types

type Rep (a, b, c) :: Type -> Type

Methods

from :: (a, b, c) -> Rep (a, b, c) x

to :: Rep (a, b, c) x -> (a, b, c)

Generic (WrappedArrow a b c)

Defined in Control.Applicative

Associated Types

type Rep (WrappedArrow a b c) :: Type -> Type

Methods

from :: WrappedArrow a b c -> Rep (WrappedArrow a b c) x

to :: Rep (WrappedArrow a b c) x -> WrappedArrow a b c

Generic (Const a b)

Defined in Data.Functor.Const

Associated Types

type Rep (Const a b) :: Type -> Type

Methods

from :: Const a b -> Rep (Const a b) x

to :: Rep (Const a b) x -> Const a b

Generic (Ap f a)

Defined in Data.Monoid

Associated Types

type Rep (Ap f a) :: Type -> Type

Methods

from :: Ap f a -> Rep (Ap f a) x

to :: Rep (Ap f a) x -> Ap f a

Generic (Alt f a)

Defined in Data.Semigroup.Internal

Associated Types

type Rep (Alt f a) :: Type -> Type

Methods

from :: Alt f a -> Rep (Alt f a) x

to :: Rep (Alt f a) x -> Alt f a

Generic (K1 i c p)

Defined in GHC.Generics

Associated Types

type Rep (K1 i c p) :: Type -> Type

Methods

from :: K1 i c p -> Rep (K1 i c p) x

to :: Rep (K1 i c p) x -> K1 i c p

Generic ((f :+: g) p)

Defined in GHC.Generics

Associated Types

type Rep ((f :+: g) p) :: Type -> Type

Methods

from :: (f :+: g) p -> Rep ((f :+: g) p) x

to :: Rep ((f :+: g) p) x -> (f :+: g) p

Generic ((f :*: g) p)

Defined in GHC.Generics

Associated Types

type Rep ((f :*: g) p) :: Type -> Type

Methods

from :: (f :*: g) p -> Rep ((f :*: g) p) x

to :: Rep ((f :*: g) p) x -> (f :*: g) p

Generic (a, b, c, d)

Defined in GHC.Generics

Associated Types

type Rep (a, b, c, d) :: Type -> Type

Methods

from :: (a, b, c, d) -> Rep (a, b, c, d) x

to :: Rep (a, b, c, d) x -> (a, b, c, d)

Generic (Product f g a)

Defined in Data.Functor.Product

Associated Types

type Rep (Product f g a) :: Type -> Type

Methods

from :: Product f g a -> Rep (Product f g a) x

to :: Rep (Product f g a) x -> Product f g a

Generic (Sum f g a)

Defined in Data.Functor.Sum

Associated Types

type Rep (Sum f g a) :: Type -> Type

Methods

from :: Sum f g a -> Rep (Sum f g a) x

to :: Rep (Sum f g a) x -> Sum f g a

Generic (M1 i c f p)

Defined in GHC.Generics

Associated Types

type Rep (M1 i c f p) :: Type -> Type

Methods

from :: M1 i c f p -> Rep (M1 i c f p) x

to :: Rep (M1 i c f p) x -> M1 i c f p

Generic ((f :.: g) p)

Defined in GHC.Generics

Associated Types

type Rep ((f :.: g) p) :: Type -> Type

Methods

from :: (f :.: g) p -> Rep ((f :.: g) p) x

to :: Rep ((f :.: g) p) x -> (f :.: g) p

Generic (a, b, c, d, e)

Defined in GHC.Generics

Associated Types

type Rep (a, b, c, d, e) :: Type -> Type

Methods

from :: (a, b, c, d, e) -> Rep (a, b, c, d, e) x

to :: Rep (a, b, c, d, e) x -> (a, b, c, d, e)

Generic (Compose f g a)

Defined in Data.Functor.Compose

Associated Types

type Rep (Compose f g a) :: Type -> Type

Methods

from :: Compose f g a -> Rep (Compose f g a) x

to :: Rep (Compose f g a) x -> Compose f g a

Generic (a, b, c, d, e, f)

Defined in GHC.Generics

Associated Types

type Rep (a, b, c, d, e, f) :: Type -> Type

Methods

from :: (a, b, c, d, e, f) -> Rep (a, b, c, d, e, f) x

to :: Rep (a, b, c, d, e, f) x -> (a, b, c, d, e, f)

Generic (a, b, c, d, e, f, g)

Defined in GHC.Generics

Associated Types

type Rep (a, b, c, d, e, f, g) :: Type -> Type

Methods

from :: (a, b, c, d, e, f, g) -> Rep (a, b, c, d, e, f, g) x

to :: Rep (a, b, c, d, e, f, g) x -> (a, b, c, d, e, f, g)

data TableName

Name of a database table.

Instances

Eq TableName

Defined in Database.Selda.Types

Methods

(==) :: TableName -> TableName -> Bool

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

Ord TableName

Defined in Database.Selda.Types

Methods

compare :: TableName -> TableName -> Ordering

(<) :: TableName -> TableName -> Bool

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

(>) :: TableName -> TableName -> Bool

(>=) :: TableName -> TableName -> Bool

max :: TableName -> TableName -> TableName

min :: TableName -> TableName -> TableName

Show TableName

Defined in Database.Selda.Types

Methods

showsPrec :: Int -> TableName -> ShowS

show :: TableName -> String

showList :: [TableName] -> ShowS

IsString TableName

Defined in Database.Selda.Types

Methods

fromString :: String -> TableName

data ColName

Name of a database column.

Instances

Eq ColName

Defined in Database.Selda.Types

Methods

(==) :: ColName -> ColName -> Bool

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

Ord ColName

Defined in Database.Selda.Types

Methods

compare :: ColName -> ColName -> Ordering

(<) :: ColName -> ColName -> Bool

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

(>) :: ColName -> ColName -> Bool

(>=) :: ColName -> ColName -> Bool

max :: ColName -> ColName -> ColName

min :: ColName -> ColName -> ColName

Show ColName

Defined in Database.Selda.Types

Methods

showsPrec :: Int -> ColName -> ShowS

show :: ColName -> String

showList :: [ColName] -> ShowS

IsString ColName

Defined in Database.Selda.Types

Methods

fromString :: String -> ColName

data Attr a where

A generic column attribute. Essentially a pair or a record selector over the type a and a column attribute. An attribute may be either a Group attribute, meaning that it can span multiple columns, or a Selector -- single column -- attribute.

Constructors

(:-) :: SelectorLike g => g t a -> Attribute g t a -> Attr t infixl 0

data Attribute (g :: * -> * -> *) t c

Some attribute that may be set on a column of type c, in a table of type t.

class ForeignKey a b where

Methods

foreignKey :: Table t -> Selector t a -> Attribute Selector self b

A foreign key constraint referencing the given table and column.

Instances

ForeignKey a a

Defined in Database.Selda.Table

Methods

foreignKey :: Table t -> Selector t a -> Attribute Selector self a

ForeignKey a (Maybe a)

Defined in Database.Selda.Table

Methods

foreignKey :: Table t -> Selector t a -> Attribute Selector self (Maybe a)

ForeignKey (Maybe a) a

Defined in Database.Selda.Table

Methods

foreignKey :: Table t -> Selector t (Maybe a) -> Attribute Selector self a

class SelectorLike g

Minimal complete definition

indices

Instances

SelectorLike Selector

Defined in Database.Selda.Table

Methods

indices :: Selector t a -> [Int]

SelectorLike Group

Defined in Database.Selda.Table

Methods

indices :: Group t a -> [Int]

data Group t a where

A non-empty list of selectors, where the element selectors need not have the same type. Used to specify constraints, such as uniqueness or primary key, potentially spanning multiple columns.

Constructors

(:+) :: Selector t a -> Group t b -> Group t (a :*: b) infixr 1

Single :: Selector t a -> Group t a

Instances

SelectorLike Group

Defined in Database.Selda.Table

Methods

indices :: Group t a -> [Int]

IsLabel x (Selector t a) => IsLabel x (Group t a)

Defined in Database.Selda.Table

Methods

fromLabel :: Group t a

sel :: Selector t a -> Selector t a

Annotation to force the type of a polymorphic label (i.e. #foo) to be a selector. This is useful, for instance, when defining unique constraints: sel #foo :- unique.

table :: forall a. Relational a => TableName -> [Attr a] -> Table a

Generate a table from the given table name and list of column attributes. All Maybe fields in the table's type will be represented by nullable columns, and all non-Maybe fields fill be represented by required columns. For example:

data Person = Person
  { id   :: ID Person
  , name :: Text
  , age  :: Int
  , pet  :: Maybe Text
  }
  deriving Generic

people :: Table Person
people = table "people" [#id :- autoPrimary]

This will result in a table of Persons, with an auto-incrementing primary key.

If the given type does not have record selectors, the column names will be col_1, col_2, etc.

tableFieldMod :: forall a. Relational a => TableName -> [Attr a] -> (Text -> Text) -> Table a

Generate a table from the given table name, a list of column attributes and a function that maps from field names to column names. Ex.:

data Person = Person
  { personId   :: Int
  , personName :: Text
  , personAge  :: Int
  , personPet  :: Maybe Text
  }
  deriving Generic

people :: Table Person
people = tableFieldMod "people"
  [#personName :- autoPrimaryGen]
  (fromJust . stripPrefix "person")

This will create a table with the columns named Id, Name, Age and Pet.

primary :: Attribute Group t a

A primary key which does not auto-increment.

autoPrimary :: Attribute Selector t (ID t)

An auto-incrementing primary key.

weakAutoPrimary :: Attribute Selector t (ID t)

A "weakly auto-incrementing" primary key. Behaves like autoPrimary, but the sequence of generated keys is not guaranteed to be monotonically increasing.

This gives better performance on some backends, but means that the relation a > b = a was inserted at a later point in time than b does not hold.

untypedAutoPrimary :: Attribute Selector t RowID

An untyped auto-incrementing primary key. You should really only use this for ad hoc tables, such as tuples.

weakUntypedAutoPrimary :: Attribute Selector t RowID

Like weakAutoPrimary, but for untyped IDs.

unique :: Attribute Group t a

A table-unique value.

data IndexMethod

Method to use for indexing with indexedUsing. Index methods are ignored by the SQLite backend, as SQLite doesn't support different index methods.

Constructors

BTreeIndex

HashIndex

Instances

Eq IndexMethod

Defined in Database.Selda.Table.Type

Methods

(==) :: IndexMethod -> IndexMethod -> Bool

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

Ord IndexMethod

Defined in Database.Selda.Table.Type

Methods

compare :: IndexMethod -> IndexMethod -> Ordering

(<) :: IndexMethod -> IndexMethod -> Bool

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

(>) :: IndexMethod -> IndexMethod -> Bool

(>=) :: IndexMethod -> IndexMethod -> Bool

max :: IndexMethod -> IndexMethod -> IndexMethod

min :: IndexMethod -> IndexMethod -> IndexMethod

Show IndexMethod

Defined in Database.Selda.Table.Type

Methods

showsPrec :: Int -> IndexMethod -> ShowS

show :: IndexMethod -> String

showList :: [IndexMethod] -> ShowS

index :: Attribute Group t c

Create an index on these column(s).

indexUsing :: IndexMethod -> Attribute Group t c

Create an index using the given index method on this column.

Creating and dropping tables

createTable :: MonadSelda m => Table a -> m ()

Create a table from the given schema.

tryCreateTable :: MonadSelda m => Table a -> m ()

Create a table from the given schema, unless it already exists.

dropTable :: MonadSelda m => Table a -> m ()

Drop the given table.

tryDropTable :: MonadSelda m => Table a -> m ()

Drop the given table, if it exists.

Tuple convenience functions

class Tup a

Minimal complete definition

tupHead

Instances

Head a ~ a => Tup a

Defined in Database.Selda.Types

Methods

tupHead :: a -> Head a

Tup (a :*: b)

Defined in Database.Selda.Types

Methods

tupHead :: (a :*: b) -> Head (a :*: b)

type family Head a where ...

Equations

Head (a :*: b) = a

Head a = a

first :: Tup a => a -> Head a

Get the first element of an inductive tuple.

second :: Tup b => (a :*: b) -> Head b

Get the second element of an inductive tuple.

third :: Tup c => (a :*: (b :*: c)) -> Head c

Get the third element of an inductive tuple.

fourth :: Tup d => (a :*: (b :*: (c :*: d))) -> Head d

Get the fourth element of an inductive tuple.

fifth :: Tup e => (a :*: (b :*: (c :*: (d :*: e)))) -> Head e

Get the fifth element of an inductive tuple.

Useful re-exports

class Monad m => MonadIO (m :: Type -> Type)

Monads in which IO computations may be embedded. Any monad built by applying a sequence of monad transformers to the IO monad will be an instance of this class.

Instances should satisfy the following laws, which state that liftIO is a transformer of monads:

• liftIO . return = return

• liftIO (m >>= f) = liftIO m >>= (liftIO . f)

Minimal complete definition

liftIO

Instances

MonadIO IO

Since: base-4.9.0.0

Defined in Control.Monad.IO.Class

Methods

liftIO :: IO a -> IO a

MonadIO Q

Defined in Language.Haskell.TH.Syntax

Methods

liftIO :: IO a -> Q a

MonadIO m => MonadIO (MaybeT m)

Defined in Control.Monad.Trans.Maybe

Methods

liftIO :: IO a -> MaybeT m a

MonadIO m => MonadIO (ListT m)

Defined in Control.Monad.Trans.List

Methods

liftIO :: IO a -> ListT m a

MonadIO m => MonadIO (ExceptT e m)

Defined in Control.Monad.Trans.Except

Methods

liftIO :: IO a -> ExceptT e m a

MonadIO m => MonadIO (IdentityT m)

Defined in Control.Monad.Trans.Identity

Methods

liftIO :: IO a -> IdentityT m a

(Error e, MonadIO m) => MonadIO (ErrorT e m)

Defined in Control.Monad.Trans.Error

Methods

liftIO :: IO a -> ErrorT e m a

MonadIO m => MonadIO (StateT s m)

Defined in Control.Monad.Trans.State.Lazy

Methods

liftIO :: IO a -> StateT s m a

MonadIO m => MonadIO (StateT s m)

Defined in Control.Monad.Trans.State.Strict

Methods

liftIO :: IO a -> StateT s m a

(Monoid w, MonadIO m) => MonadIO (WriterT w m)

Defined in Control.Monad.Trans.Writer.Lazy

Methods

liftIO :: IO a -> WriterT w m a

(Monoid w, MonadIO m) => MonadIO (WriterT w m)

Defined in Control.Monad.Trans.Writer.Strict

Methods

liftIO :: IO a -> WriterT w m a

MonadIO m => MonadIO (SeldaT b m)

Defined in Database.Selda.Backend.Internal

Methods

liftIO :: IO a -> SeldaT b m a

MonadIO m => MonadIO (ContT r m)

Defined in Control.Monad.Trans.Cont

Methods

liftIO :: IO a -> ContT r m a

MonadIO m => MonadIO (ReaderT r m)

Defined in Control.Monad.Trans.Reader

Methods

liftIO :: IO a -> ReaderT r m a

(Monoid w, MonadIO m) => MonadIO (RWST r w s m)

Defined in Control.Monad.Trans.RWS.Lazy

Methods

liftIO :: IO a -> RWST r w s m a

(Monoid w, MonadIO m) => MonadIO (RWST r w s m)

Defined in Control.Monad.Trans.RWS.Strict

Methods

liftIO :: IO a -> RWST r w s m a

class MonadCatch m => MonadMask (m :: Type -> Type)

A class for monads which provide for the ability to account for all possible exit points from a computation, and to mask asynchronous exceptions. Continuation-based monads are invalid instances of this class.

Instances should ensure that, in the following code:

fg = f `finally` g

The action g is called regardless of what occurs within f, including async exceptions. Some monads allow f to abort the computation via other effects than throwing an exception. For simplicity, we will consider aborting and throwing an exception to be two forms of "throwing an error".

If f and g both throw an error, the error thrown by fg depends on which errors we're talking about. In a monad transformer stack, the deeper layers override the effects of the inner layers; for example, ExceptT e1 (Except e2) a represents a value of type Either e2 (Either e1 a), so throwing both an e1 and an e2 will result in Left e2. If f and g both throw an error from the same layer, instances should ensure that the error from g wins.

Effects other than throwing an error are also overriden by the deeper layers. For example, StateT s Maybe a represents a value of type s -> Maybe (a, s), so if an error thrown from f causes this function to return Nothing, any changes to the state which f also performed will be erased. As a result, g will see the state as it was before f. Once g completes, f's error will be rethrown, so g' state changes will be erased as well. This is the normal interaction between effects in a monad transformer stack.

By contrast, lifted-base's version of finally always discards all of g's non-IO effects, and g never sees any of f's non-IO effects, regardless of the layer ordering and regardless of whether f throws an error. This is not the result of interacting effects, but a consequence of MonadBaseControl's approach.

Minimal complete definition

mask, uninterruptibleMask, generalBracket

Instances

MonadMask IO

Defined in Control.Monad.Catch

Methods

mask :: ((forall a. IO a -> IO a) -> IO b) -> IO b

uninterruptibleMask :: ((forall a. IO a -> IO a) -> IO b) -> IO b

generalBracket :: IO a -> (a -> ExitCase b -> IO c) -> (a -> IO b) -> IO (b, c)

e ~ SomeException => MonadMask (Either e)

Since: exceptions-0.8.3

Defined in Control.Monad.Catch

Methods

mask :: ((forall a. Either e a -> Either e a) -> Either e b) -> Either e b

uninterruptibleMask :: ((forall a. Either e a -> Either e a) -> Either e b) -> Either e b

generalBracket :: Either e a -> (a -> ExitCase b -> Either e c) -> (a -> Either e b) -> Either e (b, c)

MonadMask m => MonadMask (MaybeT m)

Since: exceptions-0.10.0

Defined in Control.Monad.Catch

Methods

mask :: ((forall a. MaybeT m a -> MaybeT m a) -> MaybeT m b) -> MaybeT m b

uninterruptibleMask :: ((forall a. MaybeT m a -> MaybeT m a) -> MaybeT m b) -> MaybeT m b

generalBracket :: MaybeT m a -> (a -> ExitCase b -> MaybeT m c) -> (a -> MaybeT m b) -> MaybeT m (b, c)

MonadMask m => MonadMask (ExceptT e m)

Since: exceptions-0.9.0

Defined in Control.Monad.Catch

Methods

mask :: ((forall a. ExceptT e m a -> ExceptT e m a) -> ExceptT e m b) -> ExceptT e m b

uninterruptibleMask :: ((forall a. ExceptT e m a -> ExceptT e m a) -> ExceptT e m b) -> ExceptT e m b

generalBracket :: ExceptT e m a -> (a -> ExitCase b -> ExceptT e m c) -> (a -> ExceptT e m b) -> ExceptT e m (b, c)

MonadMask m => MonadMask (IdentityT m)

Defined in Control.Monad.Catch

Methods

mask :: ((forall a. IdentityT m a -> IdentityT m a) -> IdentityT m b) -> IdentityT m b

uninterruptibleMask :: ((forall a. IdentityT m a -> IdentityT m a) -> IdentityT m b) -> IdentityT m b

generalBracket :: IdentityT m a -> (a -> ExitCase b -> IdentityT m c) -> (a -> IdentityT m b) -> IdentityT m (b, c)

(Error e, MonadMask m) => MonadMask (ErrorT e m)

Defined in Control.Monad.Catch

Methods

mask :: ((forall a. ErrorT e m a -> ErrorT e m a) -> ErrorT e m b) -> ErrorT e m b

uninterruptibleMask :: ((forall a. ErrorT e m a -> ErrorT e m a) -> ErrorT e m b) -> ErrorT e m b

generalBracket :: ErrorT e m a -> (a -> ExitCase b -> ErrorT e m c) -> (a -> ErrorT e m b) -> ErrorT e m (b, c)

MonadMask m => MonadMask (StateT s m)

Defined in Control.Monad.Catch

Methods

mask :: ((forall a. StateT s m a -> StateT s m a) -> StateT s m b) -> StateT s m b

uninterruptibleMask :: ((forall a. StateT s m a -> StateT s m a) -> StateT s m b) -> StateT s m b

generalBracket :: StateT s m a -> (a -> ExitCase b -> StateT s m c) -> (a -> StateT s m b) -> StateT s m (b, c)

MonadMask m => MonadMask (StateT s m)

Defined in Control.Monad.Catch

Methods

mask :: ((forall a. StateT s m a -> StateT s m a) -> StateT s m b) -> StateT s m b

uninterruptibleMask :: ((forall a. StateT s m a -> StateT s m a) -> StateT s m b) -> StateT s m b

generalBracket :: StateT s m a -> (a -> ExitCase b -> StateT s m c) -> (a -> StateT s m b) -> StateT s m (b, c)

(MonadMask m, Monoid w) => MonadMask (WriterT w m)

Defined in Control.Monad.Catch

Methods

mask :: ((forall a. WriterT w m a -> WriterT w m a) -> WriterT w m b) -> WriterT w m b

uninterruptibleMask :: ((forall a. WriterT w m a -> WriterT w m a) -> WriterT w m b) -> WriterT w m b

generalBracket :: WriterT w m a -> (a -> ExitCase b -> WriterT w m c) -> (a -> WriterT w m b) -> WriterT w m (b, c)

(MonadMask m, Monoid w) => MonadMask (WriterT w m)

Defined in Control.Monad.Catch

Methods

mask :: ((forall a. WriterT w m a -> WriterT w m a) -> WriterT w m b) -> WriterT w m b

uninterruptibleMask :: ((forall a. WriterT w m a -> WriterT w m a) -> WriterT w m b) -> WriterT w m b

generalBracket :: WriterT w m a -> (a -> ExitCase b -> WriterT w m c) -> (a -> WriterT w m b) -> WriterT w m (b, c)

MonadMask m => MonadMask (SeldaT b m)

Defined in Database.Selda.Backend.Internal

Methods

mask :: ((forall a. SeldaT b m a -> SeldaT b m a) -> SeldaT b m b0) -> SeldaT b m b0

uninterruptibleMask :: ((forall a. SeldaT b m a -> SeldaT b m a) -> SeldaT b m b0) -> SeldaT b m b0

generalBracket :: SeldaT b m a -> (a -> ExitCase b0 -> SeldaT b m c) -> (a -> SeldaT b m b0) -> SeldaT b m (b0, c)

MonadMask m => MonadMask (ReaderT r m)

Defined in Control.Monad.Catch

Methods

mask :: ((forall a. ReaderT r m a -> ReaderT r m a) -> ReaderT r m b) -> ReaderT r m b

uninterruptibleMask :: ((forall a. ReaderT r m a -> ReaderT r m a) -> ReaderT r m b) -> ReaderT r m b

generalBracket :: ReaderT r m a -> (a -> ExitCase b -> ReaderT r m c) -> (a -> ReaderT r m b) -> ReaderT r m (b, c)

(MonadMask m, Monoid w) => MonadMask (RWST r w s m)

Defined in Control.Monad.Catch

Methods

mask :: ((forall a. RWST r w s m a -> RWST r w s m a) -> RWST r w s m b) -> RWST r w s m b

uninterruptibleMask :: ((forall a. RWST r w s m a -> RWST r w s m a) -> RWST r w s m b) -> RWST r w s m b

generalBracket :: RWST r w s m a -> (a -> ExitCase b -> RWST r w s m c) -> (a -> RWST r w s m b) -> RWST r w s m (b, c)

(MonadMask m, Monoid w) => MonadMask (RWST r w s m)

Defined in Control.Monad.Catch

Methods

mask :: ((forall a. RWST r w s m a -> RWST r w s m a) -> RWST r w s m b) -> RWST r w s m b

uninterruptibleMask :: ((forall a. RWST r w s m a -> RWST r w s m a) -> RWST r w s m b) -> RWST r w s m b

generalBracket :: RWST r w s m a -> (a -> ExitCase b -> RWST r w s m c) -> (a -> RWST r w s m b) -> RWST r w s m (b, c)

liftIO :: MonadIO m => IO a -> m a

Lift a computation from the IO monad.

data Text

A space efficient, packed, unboxed Unicode text type.

Instances

Hashable Text

Defined in Data.Hashable.Class

Methods

hashWithSalt :: Int -> Text -> Int

hash :: Text -> Int

SqlType Text

Defined in Database.Selda.SqlType

Methods

mkLit :: Text -> Lit Text

sqlType :: Proxy Text -> SqlTypeRep

fromSql :: SqlValue -> Text

defaultValue :: Lit Text

SqlOrd Text

Defined in Database.Selda

IsString (Col s Text)

Defined in Database.Selda.Column

Methods

fromString :: String -> Col s Text

type Item Text

Defined in Data.Text

type Item Text = Char

data Day

The Modified Julian Day is a standard count of days, with zero being the day 1858-11-17.

Instances

Enum Day

Defined in Data.Time.Calendar.Days

Methods

succ :: Day -> Day

pred :: Day -> Day

toEnum :: Int -> Day

fromEnum :: Day -> Int

enumFrom :: Day -> [Day]

enumFromThen :: Day -> Day -> [Day]

enumFromTo :: Day -> Day -> [Day]

enumFromThenTo :: Day -> Day -> Day -> [Day]

Eq Day

Defined in Data.Time.Calendar.Days

Methods

(==) :: Day -> Day -> Bool

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

Data Day

Defined in Data.Time.Calendar.Days

Methods

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

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

toConstr :: Day -> Constr

dataTypeOf :: Day -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Day)

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

gmapT :: (forall b. Data b => b -> b) -> Day -> Day

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

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

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

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

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

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

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

Ord Day

Defined in Data.Time.Calendar.Days

Methods

compare :: Day -> Day -> Ordering

(<) :: Day -> Day -> Bool

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

(>) :: Day -> Day -> Bool

(>=) :: Day -> Day -> Bool

max :: Day -> Day -> Day

min :: Day -> Day -> Day

Ix Day

Defined in Data.Time.Calendar.Days

Methods

range :: (Day, Day) -> [Day]

index :: (Day, Day) -> Day -> Int

unsafeIndex :: (Day, Day) -> Day -> Int

inRange :: (Day, Day) -> Day -> Bool

rangeSize :: (Day, Day) -> Int

unsafeRangeSize :: (Day, Day) -> Int

NFData Day

Defined in Data.Time.Calendar.Days

Methods

rnf :: Day -> ()

FormatTime Day

Defined in Data.Time.Format

Methods

formatCharacter :: Char -> Maybe (TimeLocale -> Maybe NumericPadOption -> Maybe Int -> Day -> String)

ParseTime Day

Defined in Data.Time.Format.Parse

Methods

buildTime :: TimeLocale -> [(Char, String)] -> Maybe Day

SqlType Day

Defined in Database.Selda.SqlType

Methods

mkLit :: Day -> Lit Day

sqlType :: Proxy Day -> SqlTypeRep

fromSql :: SqlValue -> Day

defaultValue :: Lit Day

SqlOrd Day

Defined in Database.Selda

data TimeOfDay

Time of day as represented in hour, minute and second (with picoseconds), typically used to express local time of day.

Instances

Eq TimeOfDay

Defined in Data.Time.LocalTime.Internal.TimeOfDay

Methods

(==) :: TimeOfDay -> TimeOfDay -> Bool

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

Data TimeOfDay

Defined in Data.Time.LocalTime.Internal.TimeOfDay

Methods

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

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

toConstr :: TimeOfDay -> Constr

dataTypeOf :: TimeOfDay -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c TimeOfDay)

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

gmapT :: (forall b. Data b => b -> b) -> TimeOfDay -> TimeOfDay

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

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

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

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

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

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

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

Ord TimeOfDay

Defined in Data.Time.LocalTime.Internal.TimeOfDay

Methods

compare :: TimeOfDay -> TimeOfDay -> Ordering

(<) :: TimeOfDay -> TimeOfDay -> Bool

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

(>) :: TimeOfDay -> TimeOfDay -> Bool

(>=) :: TimeOfDay -> TimeOfDay -> Bool

max :: TimeOfDay -> TimeOfDay -> TimeOfDay

min :: TimeOfDay -> TimeOfDay -> TimeOfDay

Show TimeOfDay

Defined in Data.Time.LocalTime.Internal.TimeOfDay

Methods

showsPrec :: Int -> TimeOfDay -> ShowS

show :: TimeOfDay -> String

showList :: [TimeOfDay] -> ShowS

NFData TimeOfDay

Defined in Data.Time.LocalTime.Internal.TimeOfDay

Methods

rnf :: TimeOfDay -> ()

FormatTime TimeOfDay

Defined in Data.Time.Format

Methods

formatCharacter :: Char -> Maybe (TimeLocale -> Maybe NumericPadOption -> Maybe Int -> TimeOfDay -> String)

ParseTime TimeOfDay

Defined in Data.Time.Format.Parse

Methods

buildTime :: TimeLocale -> [(Char, String)] -> Maybe TimeOfDay

SqlType TimeOfDay

Defined in Database.Selda.SqlType

Methods

mkLit :: TimeOfDay -> Lit TimeOfDay

sqlType :: Proxy TimeOfDay -> SqlTypeRep

fromSql :: SqlValue -> TimeOfDay

defaultValue :: Lit TimeOfDay

SqlOrd TimeOfDay

Defined in Database.Selda

data UTCTime

This is the simplest representation of UTC. It consists of the day number, and a time offset from midnight. Note that if a day has a leap second added to it, it will have 86401 seconds.

Instances

Eq UTCTime

Defined in Data.Time.Clock.Internal.UTCTime

Methods

(==) :: UTCTime -> UTCTime -> Bool

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

Data UTCTime

Defined in Data.Time.Clock.Internal.UTCTime

Methods

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

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

toConstr :: UTCTime -> Constr

dataTypeOf :: UTCTime -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c UTCTime)

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

gmapT :: (forall b. Data b => b -> b) -> UTCTime -> UTCTime

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

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

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

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

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

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

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

Ord UTCTime

Defined in Data.Time.Clock.Internal.UTCTime

Methods

compare :: UTCTime -> UTCTime -> Ordering

(<) :: UTCTime -> UTCTime -> Bool

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

(>) :: UTCTime -> UTCTime -> Bool

(>=) :: UTCTime -> UTCTime -> Bool

max :: UTCTime -> UTCTime -> UTCTime

min :: UTCTime -> UTCTime -> UTCTime

NFData UTCTime

Defined in Data.Time.Clock.Internal.UTCTime

Methods

rnf :: UTCTime -> ()

FormatTime UTCTime

Defined in Data.Time.Format

Methods

formatCharacter :: Char -> Maybe (TimeLocale -> Maybe NumericPadOption -> Maybe Int -> UTCTime -> String)

ParseTime UTCTime

Defined in Data.Time.Format.Parse

Methods

buildTime :: TimeLocale -> [(Char, String)] -> Maybe UTCTime

SqlType UTCTime

Defined in Database.Selda.SqlType

Methods

mkLit :: UTCTime -> Lit UTCTime

sqlType :: Proxy UTCTime -> SqlTypeRep

fromSql :: SqlValue -> UTCTime

defaultValue :: Lit UTCTime

SqlOrd UTCTime

Defined in Database.Selda

data UUID

The UUID type. A Random instance is provided which produces version 4 UUIDs as specified in RFC 4122. The Storable and Binary instances are compatible with RFC 4122, storing the fields in network order as 16 bytes.

Instances

Eq UUID

Defined in Data.UUID.Types.Internal

Methods

(==) :: UUID -> UUID -> Bool

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

Data UUID

Defined in Data.UUID.Types.Internal

Methods

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

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

toConstr :: UUID -> Constr

dataTypeOf :: UUID -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c UUID)

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

gmapT :: (forall b. Data b => b -> b) -> UUID -> UUID

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

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

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

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

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

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

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

Ord UUID

Defined in Data.UUID.Types.Internal

Methods

compare :: UUID -> UUID -> Ordering

(<) :: UUID -> UUID -> Bool

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

(>) :: UUID -> UUID -> Bool

(>=) :: UUID -> UUID -> Bool

max :: UUID -> UUID -> UUID

min :: UUID -> UUID -> UUID

Read UUID

Defined in Data.UUID.Types.Internal

Methods

readsPrec :: Int -> ReadS UUID

readList :: ReadS [UUID]

readPrec :: ReadPrec UUID

readListPrec :: ReadPrec [UUID]

Show UUID

Defined in Data.UUID.Types.Internal

Methods

showsPrec :: Int -> UUID -> ShowS

show :: UUID -> String

showList :: [UUID] -> ShowS

Storable UUID

Defined in Data.UUID.Types.Internal

Methods

sizeOf :: UUID -> Int

alignment :: UUID -> Int

peekElemOff :: Ptr UUID -> Int -> IO UUID

pokeElemOff :: Ptr UUID -> Int -> UUID -> IO ()

peekByteOff :: Ptr b -> Int -> IO UUID

pokeByteOff :: Ptr b -> Int -> UUID -> IO ()

peek :: Ptr UUID -> IO UUID

poke :: Ptr UUID -> UUID -> IO ()

Binary UUID

Defined in Data.UUID.Types.Internal

Methods

put :: UUID -> Put

get :: Get UUID

putList :: [UUID] -> Put

NFData UUID

Defined in Data.UUID.Types.Internal

Methods

rnf :: UUID -> ()

Hashable UUID

Defined in Data.UUID.Types.Internal

Methods

hashWithSalt :: Int -> UUID -> Int

hash :: UUID -> Int

Random UUID

Defined in Data.UUID.Types.Internal

Methods

randomR :: RandomGen g => (UUID, UUID) -> g -> (UUID, g)

random :: RandomGen g => g -> (UUID, g)

randomRs :: RandomGen g => (UUID, UUID) -> g -> [UUID]

randoms :: RandomGen g => g -> [UUID]

randomRIO :: (UUID, UUID) -> IO UUID

randomIO :: IO UUID

SqlType UUID

defaultValue for UUIDs is the all-zero RFC4122 nil UUID.

Defined in Database.Selda.SqlType

Methods

mkLit :: UUID -> Lit UUID

sqlType :: Proxy UUID -> SqlTypeRep

fromSql :: SqlValue -> UUID

defaultValue :: Lit UUID