Safe Haskell | None |
---|---|
Language | Haskell2010 |
API for building Selda backends and adding support for more types in queries.
Synopsis
- class (MonadIO m, MonadMask m) => MonadSelda m where
- data SeldaT m a
- type SeldaM = SeldaT IO
- data SeldaError
- data StmtID
- data BackendID
- = SQLite
- | PostgreSQL
- | Other Text
- type QueryRunner a = Text -> [Param] -> IO a
- data SeldaBackend = 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 [ColumnInfo]
- ppConfig :: PPConfig
- closeConnection :: SeldaConnection -> IO ()
- backendId :: BackendID
- disableForeignKeys :: Bool -> IO ()
- data SeldaConnection
- class Typeable a => SqlType a where
- data SqlValue where
- data SqlTypeRep
- data IndexMethod
- data Param where
- data Lit a where
- LText :: !Text -> Lit Text
- LInt :: !Int -> Lit Int
- LDouble :: !Double -> Lit Double
- LBool :: !Bool -> Lit Bool
- LDateTime :: !Text -> Lit UTCTime
- LDate :: !Text -> Lit Day
- LTime :: !Text -> Lit TimeOfDay
- LJust :: SqlType a => !(Lit a) -> Lit (Maybe a)
- LBlob :: !ByteString -> Lit ByteString
- LNull :: SqlType a => Lit (Maybe a)
- LCustom :: Lit a -> Lit b
- data ColAttr
- 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 TableName
- data ColName
- data ColumnInfo = ColumnInfo {
- colName :: ColName
- colType :: Either Text SqlTypeRep
- colIsPK :: Bool
- colIsAutoIncrement :: Bool
- colIsUnique :: Bool
- colIsNullable :: Bool
- colHasIndex :: Bool
- colFKs :: [(TableName, ColName)]
- columnInfo :: Table a -> [ColumnInfo]
- fromColInfo :: ColInfo -> ColumnInfo
- mkTableName :: Text -> TableName
- mkColName :: Text -> ColName
- fromTableName :: TableName -> Text
- fromColName :: ColName -> Text
- rawTableName :: TableName -> Text
- newConnection :: MonadIO m => SeldaBackend -> Text -> m SeldaConnection
- allStmts :: SeldaConnection -> IO [(StmtID, Dynamic)]
- seldaBackend :: MonadSelda m => m SeldaBackend
- runSeldaT :: (MonadIO m, MonadMask m) => SeldaT m a -> SeldaConnection -> m a
- seldaClose :: MonadIO m => SeldaConnection -> m ()
- sqlDateTimeFormat :: String
- sqlDateFormat :: String
- sqlTimeFormat :: String
Documentation
class (MonadIO m, MonadMask m) => MonadSelda m where Source #
Some monad with Selda SQL capabilitites.
Note that the default implementations of invalidateTable
and
wrapTransaction
flush the entire cache and disable caching when
invoked. If you want to use Selda's built-in caching mechanism, you will
need to implement these operations yourself.
seldaConnection :: m SeldaConnection Source #
Get the connection in use by the computation.
invalidateTable :: Table a -> m () Source #
Invalidate the given table as soon as the current transaction finishes. Invalidate the table immediately if no transaction is ongoing.
:: m () | Signal transaction commit to SQL backend. |
-> m () | Signal transaction rollback to SQL backend. |
-> m a | Transaction to perform. |
-> m a |
Safely wrap a transaction. To ensure consistency of the in-process cache, it is important that any cached tables modified during a transaction are invalidated ONLY if that transaction succeeds, AFTER the changes become visible in the database.
In order to be thread-safe in the presence of asynchronous exceptions, instances should:
- Mask async exceptions.
- Start bookkeeping of tables invalidated during the transaction.
- Perform the transaction, with async exceptions restored.
- Commit transaction, invalidate tables, and disable bookkeeping; OR
- If an exception was raised, rollback transaction, disable bookkeeping, and re-throw the exception.
Instances
(MonadIO m, MonadMask m) => MonadSelda (SeldaT m) Source # | |
Defined in Database.Selda.Backend.Internal seldaConnection :: SeldaT m SeldaConnection Source # invalidateTable :: Table a -> SeldaT m () Source # wrapTransaction :: SeldaT m () -> SeldaT m () -> SeldaT m a -> SeldaT m a Source # |
Monad transformer adding Selda SQL capabilities.
Instances
MonadTrans SeldaT Source # | |
Defined in Database.Selda.Backend.Internal | |
Monad m => Monad (SeldaT m) Source # | |
Functor m => Functor (SeldaT m) Source # | |
Monad m => Applicative (SeldaT m) Source # | |
MonadIO m => MonadIO (SeldaT m) Source # | |
Defined in Database.Selda.Backend.Internal | |
MonadThrow m => MonadThrow (SeldaT m) Source # | |
Defined in Database.Selda.Backend.Internal | |
MonadCatch m => MonadCatch (SeldaT m) Source # | |
MonadMask m => MonadMask (SeldaT m) Source # | |
Defined in Database.Selda.Backend.Internal | |
(MonadIO m, MonadMask m) => MonadSelda (SeldaT m) Source # | |
Defined in Database.Selda.Backend.Internal seldaConnection :: SeldaT m SeldaConnection Source # invalidateTable :: Table a -> SeldaT m () Source # wrapTransaction :: SeldaT m () -> SeldaT m () -> SeldaT m a -> SeldaT m a Source # |
data SeldaError Source #
Thrown by any function in SeldaT
if an error occurs.
DbError String | Unable to open or connect to database. |
SqlError String | An error occurred while executing query. |
Instances
Eq SeldaError Source # | |
Defined in Database.Selda.Backend.Internal (==) :: SeldaError -> SeldaError -> Bool # (/=) :: SeldaError -> SeldaError -> Bool # | |
Show SeldaError Source # | |
Defined in Database.Selda.Backend.Internal showsPrec :: Int -> SeldaError -> ShowS # show :: SeldaError -> String # showList :: [SeldaError] -> ShowS # | |
Exception SeldaError Source # | |
Defined in Database.Selda.Backend.Internal toException :: SeldaError -> SomeException # fromException :: SomeException -> Maybe SeldaError # displayException :: SeldaError -> String # |
A prepared statement identifier. Guaranteed to be unique per application.
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.
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 Source #
A collection of functions making up a Selda backend.
SeldaBackend | |
|
data SeldaConnection Source #
class Typeable a => SqlType a where Source #
Any datatype representable in (Selda's subset of) SQL.
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 # | |
SqlType Double Source # | |
SqlType Int Source # | |
SqlType Ordering Source # | |
SqlType ByteString Source # | |
Defined in Database.Selda.SqlType mkLit :: ByteString -> Lit ByteString Source # sqlType :: Proxy ByteString -> SqlTypeRep Source # fromSql :: SqlValue -> ByteString Source # | |
SqlType ByteString Source # | |
Defined in Database.Selda.SqlType mkLit :: ByteString -> Lit ByteString Source # sqlType :: Proxy ByteString -> SqlTypeRep Source # fromSql :: SqlValue -> ByteString Source # | |
SqlType Text Source # | |
SqlType TimeOfDay Source # | |
SqlType UTCTime Source # | |
SqlType Day Source # | |
SqlType RowID Source # | |
SqlType a => SqlType (Maybe a) Source # | |
Typeable a => SqlType (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 # | |
Some value that is representable in SQL.
data SqlTypeRep Source #
Representation of an SQL type.
Instances
Eq SqlTypeRep Source # | |
Defined in Database.Selda.SqlType (==) :: SqlTypeRep -> SqlTypeRep -> Bool # (/=) :: SqlTypeRep -> SqlTypeRep -> Bool # | |
Ord SqlTypeRep Source # | |
Defined in Database.Selda.SqlType 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 # | |
Defined in Database.Selda.SqlType showsPrec :: Int -> SqlTypeRep -> ShowS # show :: SqlTypeRep -> String # showList :: [SqlTypeRep] -> ShowS # |
data IndexMethod Source #
Method to use for indexing with indexedUsing
.
Index methods are ignored by the SQLite backend, as SQLite doesn't support
different index methods.
Instances
Eq IndexMethod Source # | |
Defined in Database.Selda.Table.Type (==) :: IndexMethod -> IndexMethod -> Bool # (/=) :: IndexMethod -> IndexMethod -> Bool # | |
Ord IndexMethod Source # | |
Defined in Database.Selda.Table.Type 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 Source # | |
Defined in Database.Selda.Table.Type showsPrec :: Int -> IndexMethod -> ShowS # show :: IndexMethod -> String # showList :: [IndexMethod] -> ShowS # |
A parameter to a prepared SQL statement.
An SQL literal.
LText :: !Text -> Lit Text | |
LInt :: !Int -> Lit Int | |
LDouble :: !Double -> Lit Double | |
LBool :: !Bool -> Lit Bool | |
LDateTime :: !Text -> Lit UTCTime | |
LDate :: !Text -> Lit Day | |
LTime :: !Text -> Lit TimeOfDay | |
LJust :: SqlType a => !(Lit a) -> Lit (Maybe a) | |
LBlob :: !ByteString -> Lit ByteString | |
LNull :: SqlType a => Lit (Maybe a) | |
LCustom :: Lit a -> Lit b |
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.
Backend-specific configuration for the SQL pretty-printer.
PPConfig | |
|
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.
Name of a database table.
Name of a database column.
data ColumnInfo Source #
Comprehensive information about a column.
ColumnInfo | |
|
Instances
Eq ColumnInfo Source # | |
Defined in Database.Selda.Backend.Internal (==) :: ColumnInfo -> ColumnInfo -> Bool # (/=) :: ColumnInfo -> ColumnInfo -> Bool # | |
Show ColumnInfo Source # | |
Defined in Database.Selda.Backend.Internal showsPrec :: Int -> ColumnInfo -> ShowS # show :: ColumnInfo -> String # showList :: [ColumnInfo] -> ShowS # |
columnInfo :: Table a -> [ColumnInfo] Source #
Get the column information for each column in the given table.
fromColInfo :: ColInfo -> ColumnInfo Source #
Convert a ColInfo
into a ColumnInfo
.
mkTableName :: Text -> TableName Source #
Create a column name.
fromTableName :: TableName -> Text Source #
Convert a table name into a string, with quotes.
fromColName :: ColName -> Text Source #
Convert a column name into a string, with quotes.
rawTableName :: TableName -> Text Source #
Convert a table name into a string, without quotes.
newConnection :: MonadIO m => SeldaBackend -> Text -> m SeldaConnection Source #
Create a new Selda connection for the given backend and database identifier string.
allStmts :: SeldaConnection -> IO [(StmtID, Dynamic)] Source #
Get all statements and their corresponding identifiers for the current connection.
seldaBackend :: MonadSelda m => m SeldaBackend Source #
Get the backend in use by the computation.
runSeldaT :: (MonadIO m, MonadMask m) => SeldaT m a -> SeldaConnection -> m a Source #
Run a Selda transformer. Backends should use this to implement their
withX
functions.
seldaClose :: MonadIO m => SeldaConnection -> m () Source #
Close a reusable Selda connection.
Closing a connection while in use is undefined.
Passing a closed connection to runSeldaT
results in a SeldaError
being thrown. Closing a connection more than once is a no-op.
sqlDateTimeFormat :: String Source #
Format string used to represent date and time when talking to the database backend.
sqlDateFormat :: String Source #
Format string used to represent date when talking to the database backend.
sqlTimeFormat :: String Source #
Format string used to represent time of day when talking to the database backend.