Safe Haskell	None
Language	Haskell2010

Database.Selda.Backend.Internal

Description

Internal backend API. Using anything exported from this module may or may not invalidate any safety guarantees made by Selda; use at your own peril.

Synopsis

newtype StmtID = StmtID Int
data BackendID
- = SQLite
- | PostgreSQL
- | Other Text
type QueryRunner a = Text -> [Param] -> IO a
data SeldaBackend b = SeldaBackend {
- runStmt :: Text -> [Param] -> IO (Int, [[SqlValue]])
- runStmtWithPK :: Text -> [Param] -> IO Int
- prepareStmt :: StmtID -> [SqlTypeRep] -> Text -> IO Dynamic
- runPrepared :: Dynamic -> [Param] -> IO (Int, [[SqlValue]])
- getTableInfo :: TableName -> IO TableInfo
- ppConfig :: PPConfig
- closeConnection :: SeldaConnection b -> IO ()
- backendId :: BackendID
- disableForeignKeys :: Bool -> IO ()
}
data SeldaConnection b = SeldaConnection {
- connBackend :: !(SeldaBackend b)
- connDbId :: Text
- connStmts :: !(IORef (IntMap SeldaStmt))
- connClosed :: !(IORef Bool)
- connLock :: !(MVar ())
}
data SeldaStmt = SeldaStmt {
- stmtHandle :: !Dynamic
- stmtText :: !Text
- stmtParams :: ![Either Int Param]
}
class MonadIO m => MonadSelda m where
- type Backend m
- withConnection :: (SeldaConnection (Backend m) -> m a) -> m a
- transact :: m a -> m a
newtype SeldaT b m a = S {
- unS :: StateT (SeldaConnection b) m a
}
type SeldaM b = SeldaT b IO
data SeldaError
- = DbError String
- | SqlError String
- | UnsafeError String
data Param where
- Param :: !(Lit a) -> Param
data Lit a where
- LText :: !Text -> Lit Text
- LInt :: !Int -> Lit Int
- LDouble :: !Double -> Lit Double
- LBool :: !Bool -> Lit Bool
- LDateTime :: !UTCTime -> Lit UTCTime
- LDate :: !Day -> Lit Day
- LTime :: !TimeOfDay -> Lit TimeOfDay
- LJust :: SqlType a => !(Lit a) -> Lit (Maybe a)
- LBlob :: !ByteString -> Lit ByteString
- LNull :: SqlType a => Lit (Maybe a)
- LCustom :: SqlTypeRep -> Lit a -> Lit b
- LUUID :: !UUID -> Lit UUID
data ColAttr
- = Primary
- | AutoPrimary AutoIncType
- | Required
- | Optional
- | Unique
- | Indexed (Maybe IndexMethod)
data AutoIncType
- = Weak
- | Strong
class Typeable a => SqlType a where
- mkLit :: a -> Lit a
- sqlType :: Proxy a -> SqlTypeRep
- fromSql :: SqlValue -> a
- defaultValue :: Lit a
data SqlValue where
- SqlInt :: !Int -> SqlValue
- SqlFloat :: !Double -> SqlValue
- SqlString :: !Text -> SqlValue
- SqlBool :: !Bool -> SqlValue
- SqlBlob :: !ByteString -> SqlValue
- SqlUTCTime :: !UTCTime -> SqlValue
- SqlTime :: !TimeOfDay -> SqlValue
- SqlDate :: !Day -> SqlValue
- SqlNull :: SqlValue
data SqlTypeRep
- = TText
- | TRowID
- | TInt
- | TFloat
- | TBool
- | TDateTime
- | TDate
- | TTime
- | TBlob
- | TUUID
- | TJSON
data PPConfig = PPConfig {
- ppType :: SqlTypeRep -> Text
- ppTypeHook :: SqlTypeRep -> [ColAttr] -> (SqlTypeRep -> Text) -> Text
- ppTypePK :: SqlTypeRep -> Text
- ppPlaceholder :: Int -> Text
- ppColAttrs :: [ColAttr] -> Text
- ppColAttrsHook :: SqlTypeRep -> [ColAttr] -> ([ColAttr] -> Text) -> Text
- ppAutoIncInsert :: Text
- ppMaxInsertParams :: Maybe Int
- ppIndexMethodHook :: IndexMethod -> Text
}
defPPConfig :: PPConfig
data TableInfo = TableInfo {
- tableColumnInfos :: [ColumnInfo]
- tableUniqueGroups :: [[ColName]]
- tablePrimaryKey :: [ColName]
}
data ColumnInfo = ColumnInfo {
- colName :: ColName
- colType :: Either Text SqlTypeRep
- colIsAutoPrimary :: Bool
- colIsNullable :: Bool
- colHasIndex :: Bool
- colFKs :: [(TableName, ColName)]
}
tableInfo :: Table a -> TableInfo
fromColInfo :: ColInfo -> ColumnInfo
isAutoPrimary :: ColAttr -> Bool
isPrimary :: ColAttr -> Bool
isUnique :: ColAttr -> Bool
sqlDateTimeFormat :: String
sqlDateFormat :: String
sqlTimeFormat :: String
freshStmtId :: MonadIO m => m StmtID
newConnection :: MonadIO m => SeldaBackend b -> Text -> m (SeldaConnection b)
allStmts :: SeldaConnection b -> IO [(StmtID, Dynamic)]
runSeldaT :: (MonadIO m, MonadMask m) => SeldaT b m a -> SeldaConnection b -> m a
withBackend :: MonadSelda m => (SeldaBackend (Backend m) -> m a) -> m a

Documentation

newtype StmtID Source #

A prepared statement identifier. Guaranteed to be unique per application.

Constructors

StmtID Int

Instances

Eq StmtID Source #
Instance details Defined in Database.Selda.Backend.Internal Methods (==) :: StmtID -> StmtID -> Bool # (/=) :: StmtID -> StmtID -> Bool #
Ord StmtID Source #
Instance details Defined in Database.Selda.Backend.Internal Methods compare :: StmtID -> StmtID -> Ordering # (<) :: StmtID -> StmtID -> Bool # (<=) :: StmtID -> StmtID -> Bool # (>) :: StmtID -> StmtID -> Bool # (>=) :: StmtID -> StmtID -> Bool # max :: StmtID -> StmtID -> StmtID # min :: StmtID -> StmtID -> StmtID #
Show StmtID Source #
Instance details Defined in Database.Selda.Backend.Internal Methods showsPrec :: Int -> StmtID -> ShowS # show :: StmtID -> String # showList :: [StmtID] -> ShowS #

data BackendID Source #

Uniquely identifies some particular backend.

When publishing a new backend, consider submitting a pull request with a constructor for your backend instead of using the Other constructor.

Constructors

SQLite
PostgreSQL
Other Text

Instances

Eq BackendID Source #
Instance details Defined in Database.Selda.Backend.Internal Methods (==) :: BackendID -> BackendID -> Bool # (/=) :: BackendID -> BackendID -> Bool #
Ord BackendID Source #
Instance details Defined in Database.Selda.Backend.Internal Methods compare :: BackendID -> BackendID -> Ordering # (<) :: BackendID -> BackendID -> Bool # (<=) :: BackendID -> BackendID -> Bool # (>) :: BackendID -> BackendID -> Bool # (>=) :: BackendID -> BackendID -> Bool # max :: BackendID -> BackendID -> BackendID # min :: BackendID -> BackendID -> BackendID #
Show BackendID Source #
Instance details Defined in Database.Selda.Backend.Internal Methods showsPrec :: Int -> BackendID -> ShowS # show :: BackendID -> String # showList :: [BackendID] -> ShowS #

type QueryRunner a = Text -> [Param] -> IO a Source #

A function which executes a query and gives back a list of extensible tuples; one tuple per result row, and one tuple element per column.

data SeldaBackend b Source #

A collection of functions making up a Selda backend.

Constructors

SeldaBackend

Fields

runStmt :: Text -> [Param] -> IO (Int, [[SqlValue]])
Execute an SQL statement.
runStmtWithPK :: Text -> [Param] -> IO Int
Execute an SQL statement and return the last inserted primary key, where the primary key is auto-incrementing. Backends must take special care to make this thread-safe.
prepareStmt :: StmtID -> [SqlTypeRep] -> Text -> IO Dynamic
Prepare a statement using the given statement identifier.
runPrepared :: Dynamic -> [Param] -> IO (Int, [[SqlValue]])
Execute a prepared statement.
getTableInfo :: TableName -> IO TableInfo
Get a list of all columns in the given table, with the type and any modifiers for each column. Return an empty list if the given table does not exist.
ppConfig :: PPConfig
SQL pretty-printer configuration.
closeConnection :: SeldaConnection b -> IO ()
Close the currently open connection.
backendId :: BackendID
Unique identifier for this backend.
disableForeignKeys :: Bool -> IO ()
Turn on or off foreign key checking, and initiate/commit a transaction.
When implementing this function, it is safe to assume that disableForeignKeys True will always be called exactly once before each disableForeignKeys False.

data SeldaConnection b Source #

Constructors

SeldaConnection

Fields

connBackend :: !(SeldaBackend b)
The backend used by the current connection.
connDbId :: Text
A string uniquely identifying the database used by this connection. This could be, for instance, a PostgreSQL connection string or the absolute path to an SQLite file.
connStmts :: !(IORef (IntMap SeldaStmt))
All statements prepared for this connection.
connClosed :: !(IORef Bool)
Is the connection closed?
connLock :: !(MVar ())
Lock to prevent this connection from being used concurrently by multiple invocations of runSeldaT.

data SeldaStmt Source #

A prepared statement.

Constructors

SeldaStmt
Fields stmtHandle :: !Dynamic Backend-specific handle to the prepared statement. stmtText :: !Text The SQL code for the statement. stmtParams :: ![Either Int Param] All parameters to be passed to the prepared statement. Parameters that are unique to each invocation are specified as indices starting at 0. Backends implementing `runPrepared` should probably ignore this field.

class MonadIO m => MonadSelda m where Source #

Some monad with Selda SQL capabilitites.

Minimal complete definition

withConnection

Associated Types

type Backend m Source #

Type of database backend used by m.

Methods

withConnection :: (SeldaConnection (Backend m) -> m a) -> m a Source #

Pass a Selda connection to the given computation and execute it. After the computation finishes, withConnection is free to do anything it likes to the connection, including closing it or giving it to another Selda computation. Thus, the computation must take care never to return or otherwise access the connection after returning.

transact :: m a -> m a Source #

Perform the given computation as a transaction. Implementations must ensure that subsequent calls to withConnection within the same transaction always passes the same connection to its argument.

Instances

(MonadIO m, MonadMask m) => MonadSelda (SeldaT b m) Source #
Instance details Defined in Database.Selda.Backend.Internal Associated Types type Backend (SeldaT b m) :: Type Source # Methods withConnection :: (SeldaConnection (Backend (SeldaT b m)) -> SeldaT b m a) -> SeldaT b m a Source # transact :: SeldaT b m a -> SeldaT b m a Source #

newtype SeldaT b m a Source #

Monad transformer adding Selda SQL capabilities.

Constructors

S
Fields unS :: StateT (SeldaConnection b) m a

Instances

MonadTrans (SeldaT b) Source #
Instance details Defined in Database.Selda.Backend.Internal Methods lift :: Monad m => m a -> SeldaT b m a #
Monad m => Monad (SeldaT b m) Source #
Instance details 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) Source #
Instance details 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) Source #
Instance details Defined in Database.Selda.Backend.Internal Methods fail :: String -> SeldaT b m a #
Monad m => Applicative (SeldaT b m) Source #
Instance details 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) Source #
Instance details Defined in Database.Selda.Backend.Internal Methods liftIO :: IO a -> SeldaT b m a #
MonadThrow m => MonadThrow (SeldaT b m) Source #
Instance details Defined in Database.Selda.Backend.Internal Methods throwM :: Exception e => e -> SeldaT b m a #
MonadCatch m => MonadCatch (SeldaT b m) Source #
Instance details 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) Source #
Instance details 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) Source #
Instance details Defined in Database.Selda.Backend.Internal Associated Types type Backend (SeldaT b m) :: Type Source # Methods withConnection :: (SeldaConnection (Backend (SeldaT b m)) -> SeldaT b m a) -> SeldaT b m a Source # transact :: SeldaT b m a -> SeldaT b m a Source #
type Backend (SeldaT b m) Source #
Instance details Defined in Database.Selda.Backend.Internal type Backend (SeldaT b m) = b

type SeldaM b = SeldaT b IO Source #

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

data SeldaError Source #

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 Source #
Instance details Defined in Database.Selda.Backend.Internal Methods (==) :: SeldaError -> SeldaError -> Bool # (/=) :: SeldaError -> SeldaError -> Bool #
Show SeldaError Source #
Instance details Defined in Database.Selda.Backend.Internal Methods showsPrec :: Int -> SeldaError -> ShowS # show :: SeldaError -> String # showList :: [SeldaError] -> ShowS #
Exception SeldaError Source #
Instance details Defined in Database.Selda.Backend.Internal Methods toException :: SeldaError -> SomeException # fromException :: SomeException -> Maybe SeldaError # displayException :: SeldaError -> String #

data Param where Source #

A parameter to a prepared SQL statement.

Constructors

Param :: !(Lit a) -> Param

Instances

Eq Param Source #
Instance details Defined in Database.Selda.SQL Methods (==) :: Param -> Param -> Bool # (/=) :: Param -> Param -> Bool #
Ord Param Source #
Instance details Defined in Database.Selda.SQL Methods compare :: Param -> Param -> Ordering # (<) :: Param -> Param -> Bool # (<=) :: Param -> Param -> Bool # (>) :: Param -> Param -> Bool # (>=) :: Param -> Param -> Bool # max :: Param -> Param -> Param # min :: Param -> Param -> Param #
Show Param Source #
Instance details Defined in Database.Selda.SQL Methods showsPrec :: Int -> Param -> ShowS # show :: Param -> String # showList :: [Param] -> ShowS #

data Lit a where Source #

An SQL literal.

Constructors

LText :: !Text -> Lit Text
LInt :: !Int -> Lit Int
LDouble :: !Double -> Lit Double
LBool :: !Bool -> Lit Bool
LDateTime :: !UTCTime -> Lit UTCTime
LDate :: !Day -> Lit Day
LTime :: !TimeOfDay -> Lit TimeOfDay
LJust :: SqlType a => !(Lit a) -> Lit (Maybe a)
LBlob :: !ByteString -> Lit ByteString
LNull :: SqlType a => Lit (Maybe a)
LCustom :: SqlTypeRep -> Lit a -> Lit b
LUUID :: !UUID -> Lit UUID

Instances

Eq (Lit a) Source #
Instance details Defined in Database.Selda.SqlType Methods (==) :: Lit a -> Lit a -> Bool # (/=) :: Lit a -> Lit a -> Bool #
Ord (Lit a) Source #
Instance details Defined in Database.Selda.SqlType Methods compare :: Lit a -> Lit a -> Ordering # (<) :: Lit a -> Lit a -> Bool # (<=) :: Lit a -> Lit a -> Bool # (>) :: Lit a -> Lit a -> Bool # (>=) :: Lit a -> Lit a -> Bool # max :: Lit a -> Lit a -> Lit a # min :: Lit a -> Lit a -> Lit a #
Show (Lit a) Source #
Instance details Defined in Database.Selda.SqlType Methods showsPrec :: Int -> Lit a -> ShowS # show :: Lit a -> String # showList :: [Lit a] -> ShowS #

data ColAttr Source #

Column attributes such as nullability, auto increment, etc. When adding elements, make sure that they are added in the order required by SQL syntax, as this list is only sorted before being pretty-printed.

Constructors

Primary
AutoPrimary AutoIncType
Required
Optional
Unique
Indexed (Maybe IndexMethod)

Instances

Eq ColAttr Source #
Instance details Defined in Database.Selda.Table.Type Methods (==) :: ColAttr -> ColAttr -> Bool # (/=) :: ColAttr -> ColAttr -> Bool #
Ord ColAttr Source #
Instance details Defined in Database.Selda.Table.Type Methods compare :: ColAttr -> ColAttr -> Ordering # (<) :: ColAttr -> ColAttr -> Bool # (<=) :: ColAttr -> ColAttr -> Bool # (>) :: ColAttr -> ColAttr -> Bool # (>=) :: ColAttr -> ColAttr -> Bool # max :: ColAttr -> ColAttr -> ColAttr # min :: ColAttr -> ColAttr -> ColAttr #
Show ColAttr Source #
Instance details Defined in Database.Selda.Table.Type Methods showsPrec :: Int -> ColAttr -> ShowS # show :: ColAttr -> String # showList :: [ColAttr] -> ShowS #

data AutoIncType Source #

Strongly or weakly auto-incrementing primary key?

Constructors

Weak
Strong

Instances

Eq AutoIncType Source #
Instance details Defined in Database.Selda.Table.Type Methods (==) :: AutoIncType -> AutoIncType -> Bool # (/=) :: AutoIncType -> AutoIncType -> Bool #
Ord AutoIncType Source #
Instance details Defined in Database.Selda.Table.Type Methods compare :: AutoIncType -> AutoIncType -> Ordering # (<) :: AutoIncType -> AutoIncType -> Bool # (<=) :: AutoIncType -> AutoIncType -> Bool # (>) :: AutoIncType -> AutoIncType -> Bool # (>=) :: AutoIncType -> AutoIncType -> Bool # max :: AutoIncType -> AutoIncType -> AutoIncType # min :: AutoIncType -> AutoIncType -> AutoIncType #
Show AutoIncType Source #
Instance details Defined in Database.Selda.Table.Type Methods showsPrec :: Int -> AutoIncType -> ShowS # show :: AutoIncType -> String # showList :: [AutoIncType] -> ShowS #

class Typeable a => SqlType a where Source #

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

Minimal complete definition

Nothing

Methods

mkLit :: a -> Lit a Source #

Create a literal of this type.

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

Create a literal of this type.

sqlType :: Proxy a -> SqlTypeRep Source #

The SQL representation for this type.

fromSql :: SqlValue -> a Source #

Convert an SqlValue into this type.

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

Convert an SqlValue into this type.

defaultValue :: Lit a Source #

Default value when using def at this type.

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

Default value when using def at this type.

Instances

SqlType Bool Source #
Instance details Defined in Database.Selda.SqlType Methods mkLit :: Bool -> Lit Bool Source # sqlType :: Proxy Bool -> SqlTypeRep Source # fromSql :: SqlValue -> Bool Source # defaultValue :: Lit Bool Source #
SqlType Double Source #
Instance details Defined in Database.Selda.SqlType Methods mkLit :: Double -> Lit Double Source # sqlType :: Proxy Double -> SqlTypeRep Source # fromSql :: SqlValue -> Double Source # defaultValue :: Lit Double Source #
SqlType Int Source #
Instance details Defined in Database.Selda.SqlType Methods mkLit :: Int -> Lit Int Source # sqlType :: Proxy Int -> SqlTypeRep Source # fromSql :: SqlValue -> Int Source # defaultValue :: Lit Int Source #
SqlType Ordering Source #
Instance details Defined in Database.Selda.SqlType Methods mkLit :: Ordering -> Lit Ordering Source # sqlType :: Proxy Ordering -> SqlTypeRep Source # fromSql :: SqlValue -> Ordering Source # defaultValue :: Lit Ordering Source #
SqlType ByteString Source #
Instance details Defined in Database.Selda.SqlType Methods mkLit :: ByteString -> Lit ByteString Source # sqlType :: Proxy ByteString -> SqlTypeRep Source # fromSql :: SqlValue -> ByteString Source # defaultValue :: Lit ByteString Source #
SqlType ByteString Source #
Instance details Defined in Database.Selda.SqlType Methods mkLit :: ByteString -> Lit ByteString Source # sqlType :: Proxy ByteString -> SqlTypeRep Source # fromSql :: SqlValue -> ByteString Source # defaultValue :: Lit ByteString Source #
SqlType Text Source #
Instance details Defined in Database.Selda.SqlType Methods mkLit :: Text -> Lit Text Source # sqlType :: Proxy Text -> SqlTypeRep Source # fromSql :: SqlValue -> Text Source # defaultValue :: Lit Text Source #
SqlType TimeOfDay Source #
Instance details Defined in Database.Selda.SqlType Methods mkLit :: TimeOfDay -> Lit TimeOfDay Source # sqlType :: Proxy TimeOfDay -> SqlTypeRep Source # fromSql :: SqlValue -> TimeOfDay Source # defaultValue :: Lit TimeOfDay Source #
SqlType UTCTime Source #
Instance details Defined in Database.Selda.SqlType Methods mkLit :: UTCTime -> Lit UTCTime Source # sqlType :: Proxy UTCTime -> SqlTypeRep Source # fromSql :: SqlValue -> UTCTime Source # defaultValue :: Lit UTCTime Source #
SqlType Day Source #
Instance details Defined in Database.Selda.SqlType Methods mkLit :: Day -> Lit Day Source # sqlType :: Proxy Day -> SqlTypeRep Source # fromSql :: SqlValue -> Day Source # defaultValue :: Lit Day Source #
SqlType UUID Source #	`defaultValue` for UUIDs is the all-zero RFC4122 nil UUID.
Instance details Defined in Database.Selda.SqlType Methods mkLit :: UUID -> Lit UUID Source # sqlType :: Proxy UUID -> SqlTypeRep Source # fromSql :: SqlValue -> UUID Source # defaultValue :: Lit UUID Source #
SqlType RowID Source #
Instance details Defined in Database.Selda.SqlType Methods mkLit :: RowID -> Lit RowID Source # sqlType :: Proxy RowID -> SqlTypeRep Source # fromSql :: SqlValue -> RowID Source # defaultValue :: Lit RowID Source #
SqlType a => SqlType (Maybe a) Source #
Instance details Defined in Database.Selda.SqlType Methods mkLit :: Maybe a -> Lit (Maybe a) Source # sqlType :: Proxy (Maybe a) -> SqlTypeRep Source # fromSql :: SqlValue -> Maybe a Source # defaultValue :: Lit (Maybe a) Source #
Typeable a => SqlType (ID a) Source #
Instance details Defined in Database.Selda.SqlType Methods mkLit :: ID a -> Lit (ID a) Source # sqlType :: Proxy (ID a) -> SqlTypeRep Source # fromSql :: SqlValue -> ID a Source # defaultValue :: Lit (ID a) Source #
((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) Source #
Instance details Defined in Database.Selda Methods mkLit :: Only a -> Lit (Only a) Source # sqlType :: Proxy (Only a) -> SqlTypeRep Source # fromSql :: SqlValue -> Only a Source # defaultValue :: Lit (Only a) Source #

data SqlValue where Source #

Some value that is representable in SQL.

Constructors

SqlInt :: !Int -> SqlValue
SqlFloat :: !Double -> SqlValue
SqlString :: !Text -> SqlValue
SqlBool :: !Bool -> SqlValue
SqlBlob :: !ByteString -> SqlValue
SqlUTCTime :: !UTCTime -> SqlValue
SqlTime :: !TimeOfDay -> SqlValue
SqlDate :: !Day -> SqlValue
SqlNull :: SqlValue

Instances

Show SqlValue Source #
Instance details Defined in Database.Selda.SqlType Methods showsPrec :: Int -> SqlValue -> ShowS # show :: SqlValue -> String # showList :: [SqlValue] -> ShowS #

data SqlTypeRep Source #

Representation of an SQL type.

Constructors

TText
TRowID
TInt
TFloat
TBool
TDateTime
TDate
TTime
TBlob
TUUID
TJSON

Instances

Eq SqlTypeRep Source #
Instance details Defined in Database.Selda.SqlType Methods (==) :: SqlTypeRep -> SqlTypeRep -> Bool # (/=) :: SqlTypeRep -> SqlTypeRep -> Bool #
Ord SqlTypeRep Source #
Instance details Defined in Database.Selda.SqlType Methods compare :: SqlTypeRep -> SqlTypeRep -> Ordering # (<) :: SqlTypeRep -> SqlTypeRep -> Bool # (<=) :: SqlTypeRep -> SqlTypeRep -> Bool # (>) :: SqlTypeRep -> SqlTypeRep -> Bool # (>=) :: SqlTypeRep -> SqlTypeRep -> Bool # max :: SqlTypeRep -> SqlTypeRep -> SqlTypeRep # min :: SqlTypeRep -> SqlTypeRep -> SqlTypeRep #
Show SqlTypeRep Source #
Instance details Defined in Database.Selda.SqlType Methods showsPrec :: Int -> SqlTypeRep -> ShowS # show :: SqlTypeRep -> String # showList :: [SqlTypeRep] -> ShowS #

data PPConfig Source #

Backend-specific configuration for the SQL pretty-printer.

Constructors

PPConfig

Fields

ppType :: SqlTypeRep -> Text
The SQL type name of the given type.
This function should be used everywhere a type is needed to be printed but in primary keys position. This is due to the fact that some backends might have a special representation of primary keys (using sequences are such). If you have such a need, please use the ppTypePK record instead.
ppTypeHook :: SqlTypeRep -> [ColAttr] -> (SqlTypeRep -> Text) -> Text
Hook that allows you to modify ppType output.
ppTypePK :: SqlTypeRep -> Text
The SQL type name of the given type for primary keys uses.
ppPlaceholder :: Int -> Text
Parameter placeholder for the nth parameter.
ppColAttrs :: [ColAttr] -> Text
List of column attributes.
ppColAttrsHook :: SqlTypeRep -> [ColAttr] -> ([ColAttr] -> Text) -> Text
Hook that allows you to modify ppColAttrs output.
ppAutoIncInsert :: Text
The value used for the next value for an auto-incrementing column. For instance, DEFAULT for PostgreSQL, and NULL for SQLite.
ppMaxInsertParams :: Maybe Int
Insert queries may have at most this many parameters; if an insertion has more parameters than this, it will be chunked.
Note that only insertions of multiple rows are chunked. If your table has more than this many columns, you should really rethink your database design.
ppIndexMethodHook :: IndexMethod -> Text
CREATE INDEX suffix to indicate that the index should use the given index method.

defPPConfig :: PPConfig Source #

Default settings for pretty-printing. Geared towards SQLite.

The default definition of ppTypePK is 'defType, so that you don’t have to do anything special if you don’t use special types for primary keys.

data TableInfo Source #

Comprehensive information about a table.

Constructors

TableInfo
Fields tableColumnInfos :: [ColumnInfo] Ordered information about each table column. tableUniqueGroups :: [[ColName]] Unordered list of all (non-PK) uniqueness constraints on this table. tablePrimaryKey :: [ColName] Unordered list of all primary key constraints on this table.

Instances

Eq TableInfo Source #
Instance details Defined in Database.Selda.Backend.Internal Methods (==) :: TableInfo -> TableInfo -> Bool # (/=) :: TableInfo -> TableInfo -> Bool #
Show TableInfo Source #
Instance details Defined in Database.Selda.Backend.Internal Methods showsPrec :: Int -> TableInfo -> ShowS # show :: TableInfo -> String # showList :: [TableInfo] -> ShowS #

data ColumnInfo Source #

Comprehensive information about a column.

Constructors

ColumnInfo

Fields

colName :: ColName
Name of the column.
colType :: Either Text SqlTypeRep
Selda type of the column, or the type name given by the database if Selda couldn't make sense of the type.
colIsAutoPrimary :: Bool
Is the given column auto-incrementing?
colIsNullable :: Bool
Can the column be NULL?
colHasIndex :: Bool
Is the column explicitly indexed (i.e. using indexed)?
colFKs :: [(TableName, ColName)]
Any foreign key (table, column) pairs referenced by this column.

Instances

Eq ColumnInfo Source #
Instance details Defined in Database.Selda.Backend.Internal Methods (==) :: ColumnInfo -> ColumnInfo -> Bool # (/=) :: ColumnInfo -> ColumnInfo -> Bool #
Show ColumnInfo Source #
Instance details Defined in Database.Selda.Backend.Internal Methods showsPrec :: Int -> ColumnInfo -> ShowS # show :: ColumnInfo -> String # showList :: [ColumnInfo] -> ShowS #

tableInfo :: Table a -> TableInfo Source #

Get the column information for each column in the given table.

fromColInfo :: ColInfo -> ColumnInfo Source #

Convert a ColInfo into a ColumnInfo.

isAutoPrimary :: ColAttr -> Bool Source #

isPrimary :: ColAttr -> Bool Source #

isUnique :: ColAttr -> Bool Source #

sqlDateTimeFormat :: String Source #

Format string used to represent date and time when representing timestamps as text. If at all possible, use SqlUTCTime instead.

sqlDateFormat :: String Source #

Format string used to represent date when representing dates as text. If at all possible, use SqlDate instead.

sqlTimeFormat :: String Source #

Format string used to represent time of day when representing time as text. If at all possible, use SqlTime instead.

freshStmtId :: MonadIO m => m StmtID Source #

Generate a fresh statement identifier, guaranteed to be unique per process.

newConnection :: MonadIO m => SeldaBackend b -> Text -> m (SeldaConnection b) Source #

Create a new Selda connection for the given backend and database identifier string.

allStmts :: SeldaConnection b -> IO [(StmtID, Dynamic)] Source #

Get all statements and their corresponding identifiers for the current connection.

runSeldaT :: (MonadIO m, MonadMask m) => SeldaT b m a -> SeldaConnection b -> m a Source #

Run a Selda transformer. Backends should use this to implement their withX functions.

withBackend :: MonadSelda m => (SeldaBackend (Backend m) -> m a) -> m a Source #

Get the backend in use by the computation.