| Safe Haskell | None |
|---|---|
| Language | Haskell2010 |
Database.Groundhog.Core
Description
This module defines the functions and datatypes used throughout the framework. Most of them are for the internal use
Synopsis
- class (PurePersistField (AutoKey v), PurePersistField (DefaultKey v)) => PersistEntity v where
- data Field v :: ((Type -> Type) -> Type) -> Type -> Type
- data Key v :: Type -> Type
- type AutoKey v
- type DefaultKey v
- type IsSumType v
- entityDef :: DbDescriptor db => proxy db -> v -> EntityDef
- toEntityPersistValues :: PersistBackend m => v -> m ([PersistValue] -> [PersistValue])
- fromEntityPersistValues :: PersistBackend m => [PersistValue] -> m (v, [PersistValue])
- getUniques :: v -> (Int, [(String, [PersistValue] -> [PersistValue])])
- entityFieldChain :: DbDescriptor db => proxy db -> Field v c a -> FieldChain
- data PersistValue
- class PersistField a where
- persistName :: a -> String
- toPersistValues :: PersistBackend m => a -> m ([PersistValue] -> [PersistValue])
- fromPersistValues :: PersistBackend m => [PersistValue] -> m (a, [PersistValue])
- dbType :: DbDescriptor db => proxy db -> a -> DbType
- class PersistField a => SinglePersistField a where
- toSinglePersistValue :: PersistBackend m => a -> m PersistValue
- fromSinglePersistValue :: PersistBackend m => PersistValue -> m a
- class PersistField a => PurePersistField a where
- toPurePersistValues :: a -> [PersistValue] -> [PersistValue]
- fromPurePersistValues :: [PersistValue] -> (a, [PersistValue])
- class PersistField a => PrimitivePersistField a where
- toPrimitivePersistValue :: a -> PersistValue
- fromPrimitivePersistValue :: PersistValue -> a
- class PersistField v => Embedded v where
- class Projection p a | p -> a where
- type ProjectionDb p db :: Constraint
- type ProjectionRestriction p r :: Constraint
- projectionExprs :: (DbDescriptor db, ProjectionDb p db, ProjectionRestriction p r) => p -> [UntypedExpr db r] -> [UntypedExpr db r]
- projectionResult :: PersistBackend m => p -> [PersistValue] -> m (a, [PersistValue])
- class (Projection p a, ProjectionDb p db, ProjectionRestriction p r) => Projection' p db r a
- data RestrictionHolder v (c :: (Type -> Type) -> Type)
- data Unique (u :: (Type -> Type) -> Type)
- data KeyForBackend db v = (DbDescriptor db, PersistEntity v) => KeyForBackend (AutoKeyType db)
- data BackendSpecific
- data ConstructorMarker v a
- data UniqueMarker v a
- data HFalse
- data HTrue
- newtype ZT = ZT ZonedTime
- newtype Utf8 = Utf8 Builder
- fromUtf8 :: Utf8 -> ByteString
- delim :: Char
- data Cond db r
- = And (Cond db r) (Cond db r)
- | Or (Cond db r) (Cond db r)
- | Not (Cond db r)
- | Compare ExprRelation (UntypedExpr db r) (UntypedExpr db r)
- | CondRaw (QueryRaw db r)
- | CondEmpty
- data ExprRelation
- data Update db r = forall f a.(Assignable f a, Projection' f db r a) => Update f (UntypedExpr db r)
- (~>) :: (EntityConstr v c, FieldLike f a, DbDescriptor db, Projection' f db (RestrictionHolder v c) a, Embedded a) => f -> Selector a a' -> SubField db v c a'
- class Assignable f a => FieldLike f a | f -> a where
- fieldChain :: (DbDescriptor db, ProjectionDb f db) => proxy db -> f -> FieldChain
- class Projection f a => Assignable f a | f -> a
- newtype SubField db v (c :: (Type -> Type) -> Type) a = SubField FieldChain
- data AutoKeyField v (c :: (Type -> Type) -> Type) where
- AutoKeyField :: AutoKeyField v c
- type FieldChain = ((String, DbType), [(String, EmbeddedDef)])
- class NeverNull a
- data UntypedExpr db r where
- ExprRaw :: DbType -> QueryRaw db r -> UntypedExpr db r
- ExprField :: FieldChain -> UntypedExpr db r
- ExprPure :: forall db r a. PurePersistField a => a -> UntypedExpr db r
- ExprCond :: Cond db r -> UntypedExpr db r
- newtype Expr db r a = Expr (UntypedExpr db r)
- data Order db r
- = forall a f.Projection' f db r a => Asc f
- | forall a f.Projection' f db r a => Desc f
- class HasSelectOptions a db r | a -> db r where
- type HasLimit a
- type HasOffset a
- type HasOrder a
- type HasDistinct a
- getSelectOptions :: a -> SelectOptions db r (HasLimit a) (HasOffset a) (HasOrder a) (HasDistinct a)
- data SelectOptions db r hasLimit hasOffset hasOrder hasDistinct = SelectOptions {
- condOptions :: Cond db r
- limitOptions :: Maybe Int
- offsetOptions :: Maybe Int
- orderOptions :: [Order db r]
- distinctOptions :: Bool
- dbSpecificOptions :: [(String, QueryRaw db r)]
- limitTo :: (HasSelectOptions a db r, HasLimit a ~ HFalse) => a -> Int -> SelectOptions db r HTrue (HasOffset a) (HasOrder a) (HasDistinct a)
- offsetBy :: (HasSelectOptions a db r, HasOffset a ~ HFalse) => a -> Int -> SelectOptions db r (HasLimit a) HTrue (HasOrder a) (HasDistinct a)
- orderBy :: (HasSelectOptions a db r, HasOrder a ~ HFalse) => a -> [Order db r] -> SelectOptions db r (HasLimit a) (HasOffset a) HTrue (HasDistinct a)
- distinct :: (HasSelectOptions a db r, HasDistinct a ~ HFalse) => a -> SelectOptions db r (HasLimit a) (HasOffset a) (HasOrder a) HTrue
- data DbTypePrimitive' str
- type DbTypePrimitive = DbTypePrimitive' String
- data DbType
- data EntityDef' str dbType = EntityDef {
- entityName :: str
- entitySchema :: Maybe str
- typeParams :: [dbType]
- constructors :: [ConstructorDef' str dbType]
- type EntityDef = EntityDef' String DbType
- data EmbeddedDef' str dbType = EmbeddedDef Bool [(str, dbType)]
- type EmbeddedDef = EmbeddedDef' String DbType
- newtype OtherTypeDef' str = OtherTypeDef [Either str (DbTypePrimitive' str)]
- type OtherTypeDef = OtherTypeDef' String
- data ConstructorDef' str dbType = ConstructorDef {
- constrName :: str
- constrAutoKeyName :: Maybe str
- constrParams :: [(str, dbType)]
- constrUniques :: [UniqueDef' str (Either (str, dbType) str)]
- type ConstructorDef = ConstructorDef' String DbType
- class Constructor c where
- phantomConstrNum :: c (a :: Type -> Type) -> Int
- class PersistEntity v => EntityConstr v c where
- entityConstrNum :: proxy v -> c (a :: Type -> Type) -> Int
- class PurePersistField uKey => IsUniqueKey uKey where
- extractUnique :: uKey ~ Key v u => v -> uKey
- uniqueNum :: uKey -> Int
- data UniqueDef' str field = UniqueDef {
- uniqueDefName :: Maybe str
- uniqueDefType :: UniqueType
- uniqueDefFields :: [field]
- type UniqueDef = UniqueDef' String (Either (String, DbType) String)
- data UniqueType
- data ReferenceActionType
- = NoAction
- | Restrict
- | Cascade
- | SetNull
- | SetDefault
- type ParentTableReference = (Either (EntityDef, Maybe String) ((Maybe String, String), [String]), Maybe ReferenceActionType, Maybe ReferenceActionType)
- type SingleMigration = Either [String] [(Bool, Int, String)]
- type NamedMigrations = Map String SingleMigration
- type Migration m = StateT NamedMigrations m ()
- class (Monad m, MonadIO m, MonadFail m, ConnectionManager (Conn m), PersistBackendConn (Conn m)) => PersistBackend m where
- type Conn m
- getConnection :: m (Conn m)
- class (DbDescriptor conn, ConnectionManager conn) => PersistBackendConn conn where
- insert :: (PersistEntity v, PersistBackend m, Conn m ~ conn) => v -> m (AutoKey v)
- insert_ :: (PersistEntity v, PersistBackend m, Conn m ~ conn) => v -> m ()
- insertBy :: (PersistEntity v, IsUniqueKey (Key v (Unique u)), PersistBackend m, Conn m ~ conn) => u (UniqueMarker v) -> v -> m (Either (AutoKey v) (AutoKey v))
- insertByAll :: (PersistEntity v, PersistBackend m, Conn m ~ conn) => v -> m (Either (AutoKey v) (AutoKey v))
- replace :: (PersistEntity v, PrimitivePersistField (Key v BackendSpecific), PersistBackend m, Conn m ~ conn) => Key v BackendSpecific -> v -> m ()
- replaceBy :: (PersistEntity v, IsUniqueKey (Key v (Unique u)), PersistBackend m, Conn m ~ conn) => u (UniqueMarker v) -> v -> m ()
- select :: (PersistEntity v, EntityConstr v c, HasSelectOptions opts conn (RestrictionHolder v c), PersistBackend m, Conn m ~ conn) => opts -> m [v]
- selectStream :: (PersistEntity v, EntityConstr v c, HasSelectOptions opts conn (RestrictionHolder v c), PersistBackend m, Conn m ~ conn) => opts -> m (RowStream v)
- selectAll :: (PersistEntity v, PersistBackend m, Conn m ~ conn) => m [(AutoKey v, v)]
- selectAllStream :: (PersistEntity v, PersistBackend m, Conn m ~ conn) => m (RowStream (AutoKey v, v))
- get :: (PersistEntity v, PrimitivePersistField (Key v BackendSpecific), PersistBackend m, Conn m ~ conn) => Key v BackendSpecific -> m (Maybe v)
- getBy :: (PersistEntity v, IsUniqueKey (Key v (Unique u)), PersistBackend m, Conn m ~ conn) => Key v (Unique u) -> m (Maybe v)
- update :: (PersistEntity v, EntityConstr v c, PersistBackend m, Conn m ~ conn) => [Update conn (RestrictionHolder v c)] -> Cond conn (RestrictionHolder v c) -> m ()
- delete :: (PersistEntity v, EntityConstr v c, PersistBackend m, Conn m ~ conn) => Cond conn (RestrictionHolder v c) -> m ()
- deleteBy :: (PersistEntity v, PrimitivePersistField (Key v BackendSpecific), PersistBackend m, Conn m ~ conn) => Key v BackendSpecific -> m ()
- deleteAll :: (PersistEntity v, PersistBackend m, Conn m ~ conn) => v -> m ()
- count :: (PersistEntity v, EntityConstr v c, PersistBackend m, Conn m ~ conn) => Cond conn (RestrictionHolder v c) -> m Int
- countAll :: (PersistEntity v, PersistBackend m, Conn m ~ conn) => v -> m Int
- project :: (PersistEntity v, EntityConstr v c, Projection' p conn (RestrictionHolder v c) a, HasSelectOptions opts conn (RestrictionHolder v c), PersistBackend m, Conn m ~ conn) => p -> opts -> m [a]
- projectStream :: (PersistEntity v, EntityConstr v c, Projection' p conn (RestrictionHolder v c) a, HasSelectOptions opts conn (RestrictionHolder v c), PersistBackend m, Conn m ~ conn) => p -> opts -> m (RowStream a)
- migrate :: (PersistEntity v, PersistBackend m, Conn m ~ conn) => v -> Migration m
- executeRaw :: (PersistBackend m, Conn m ~ conn) => Bool -> String -> [PersistValue] -> m ()
- queryRaw :: (PersistBackend m, Conn m ~ conn) => Bool -> String -> [PersistValue] -> m (RowStream [PersistValue])
- insertList :: (PersistField a, PersistBackend m, Conn m ~ conn) => [a] -> m Int64
- getList :: (PersistField a, PersistBackend m, Conn m ~ conn) => Int64 -> m [a]
- type Action conn = ReaderT conn IO
- type TryAction e m conn = ReaderT conn (ExceptT e m)
- type RowStream a = Acquire (IO (Maybe a))
- class PrimitivePersistField (AutoKeyType db) => DbDescriptor db where
- type AutoKeyType db
- type QueryRaw db :: Type -> Type
- backendName :: proxy db -> String
- class ExtractConnection cm conn | cm -> conn where
- extractConn :: (MonadBaseControl IO m, MonadIO m) => (conn -> m a) -> cm -> m a
- class ConnectionManager conn where
- withConn :: (MonadBaseControl IO m, MonadIO m) => (conn -> m a) -> conn -> m a
- class TryConnectionManager conn where
- tryWithConn :: (MonadBaseControl IO m, MonadIO m, MonadCatch m) => (conn -> n a) -> (n a -> m (Either SomeException a)) -> conn -> m (Either SomeException a)
- class Savepoint conn where
- withConnSavepoint :: (MonadBaseControl IO m, MonadIO m) => String -> m a -> conn -> m a
- withSavepoint :: (PersistBackend m, MonadBaseControl IO m, MonadIO m, Savepoint (Conn m)) => String -> m a -> m a
- runDb :: PersistBackend m => Action (Conn m) a -> m a
- runDbConn :: (MonadIO m, MonadBaseControl IO m, ConnectionManager conn, ExtractConnection cm conn) => Action conn a -> cm -> m a
- runTryDbConn :: (MonadIO m, MonadBaseControl IO m, MonadCatch m, TryConnectionManager conn, ExtractConnection cm conn, Exception e) => TryAction e m conn a -> cm -> m (Either SomeException a)
- runTryDbConn' :: (MonadIO m, MonadBaseControl IO m, MonadCatch m, TryConnectionManager conn, ExtractConnection cm conn) => Action conn a -> cm -> m (Either SomeException a)
- runDb' :: PersistBackend m => Action (Conn m) a -> m a
- runDbConn' :: (MonadIO m, MonadBaseControl IO m, ConnectionManager conn, ExtractConnection cm conn) => Action conn a -> cm -> m a
Main types
class (PurePersistField (AutoKey v), PurePersistField (DefaultKey v)) => PersistEntity v where Source #
Only instances of this class can be persisted in a database
Associated Types
data Field v :: ((Type -> Type) -> Type) -> Type -> Type Source #
This type is used for typesafe manipulation of separate fields of datatype v.
Each constructor in Field corresponds to its field in a datatype v.
It is parametrised by constructor phantom type and field value type.
data Key v :: Type -> Type Source #
A unique identifier of a value stored in a database. This may be a primary key, a constraint or unique indices. The second parameter is the key description.
This type is the default autoincremented key for the entity. If entity does not have such key, AutoKey v = ().
type DefaultKey v Source #
This type is the default key for the entity.
It is HFalse for entity with one constructor and HTrue for sum types.
Methods
entityDef :: DbDescriptor db => proxy db -> v -> EntityDef Source #
Returns a complete description of the type
toEntityPersistValues :: PersistBackend m => v -> m ([PersistValue] -> [PersistValue]) Source #
Marshalls value to a list of PersistValue ready for insert to a database
fromEntityPersistValues :: PersistBackend m => [PersistValue] -> m (v, [PersistValue]) Source #
Constructs the value from the list of PersistValue
getUniques :: v -> (Int, [(String, [PersistValue] -> [PersistValue])]) Source #
Returns constructor number and a list of uniques names and corresponding field values
entityFieldChain :: DbDescriptor db => proxy db -> Field v c a -> FieldChain Source #
Is internally used by FieldLike Field instance We could avoid this function if class FieldLike allowed FieldLike Fields Data or FieldLike (Fields Data). However that would require additional extensions in user-space code
data PersistValue Source #
A raw value which can be stored in any backend and can be marshalled to
and from a PersistField.
Constructors
| PersistString String | |
| PersistText Text | |
| PersistByteString ByteString | |
| PersistInt64 Int64 | |
| PersistDouble Double | |
| PersistBool Bool | |
| PersistDay Day | |
| PersistTimeOfDay TimeOfDay | |
| PersistUTCTime UTCTime | |
| PersistZonedTime ZT | |
| PersistNull | |
| PersistCustom Utf8 [PersistValue] | Creating some datatypes may require calling a function, using a special constructor, or other syntax. The string (which can have placeholders) is included into query without escaping. The recursive constructions are not allowed, i.e., [PersistValue] cannot contain PersistCustom values. |
Instances
| Eq PersistValue Source # | |
Defined in Database.Groundhog.Core | |
| Read PersistValue Source # | |
Defined in Database.Groundhog.Core Methods readsPrec :: Int -> ReadS PersistValue # readList :: ReadS [PersistValue] # | |
| Show PersistValue Source # | |
Defined in Database.Groundhog.Core Methods showsPrec :: Int -> PersistValue -> ShowS # show :: PersistValue -> String # showList :: [PersistValue] -> ShowS # | |
| ToJSON PersistValue Source # | |
Defined in Database.Groundhog.Instances Methods toJSON :: PersistValue -> Value # toEncoding :: PersistValue -> Encoding # toJSONList :: [PersistValue] -> Value # toEncodingList :: [PersistValue] -> Encoding # | |
| FromJSON PersistValue Source # | |
Defined in Database.Groundhog.Instances | |
class PersistField a where Source #
Represents everything which can be put into a database. This data can be stored in multiple columns and tables. To get value of those columns we might need to access another table. That is why the result type is monadic.
Methods
persistName :: a -> String Source #
Return name of the type. If it is polymorphic, the names of parameter types are separated with delim symbol
toPersistValues :: PersistBackend m => a -> m ([PersistValue] -> [PersistValue]) Source #
Convert a value into something which can be stored in a database column. Note that for complex datatypes it may insert them to return identifier
fromPersistValues :: PersistBackend m => [PersistValue] -> m (a, [PersistValue]) Source #
Constructs a value from a PersistValue. For complex datatypes it may query the database
dbType :: DbDescriptor db => proxy db -> a -> DbType Source #
Description of value type. It depends on database so that we can have, for example, xml column type in Postgres and varchar type in other databases
Instances
class PersistField a => SinglePersistField a where Source #
Represents all datatypes that map into a single column. Getting value for that column might require monadic actions to access other tables.
Methods
toSinglePersistValue :: PersistBackend m => a -> m PersistValue Source #
fromSinglePersistValue :: PersistBackend m => PersistValue -> m a Source #
Instances
| (PersistField a, PrimitivePersistField a) => SinglePersistField a Source # | |
Defined in Database.Groundhog.Instances Methods toSinglePersistValue :: PersistBackend m => a -> m PersistValue Source # fromSinglePersistValue :: PersistBackend m => PersistValue -> m a Source # | |
class PersistField a => PurePersistField a where Source #
Represents all datatypes that map into several columns. Getting values for those columns is pure.
Methods
toPurePersistValues :: a -> [PersistValue] -> [PersistValue] Source #
fromPurePersistValues :: [PersistValue] -> (a, [PersistValue]) Source #
Instances
class PersistField a => PrimitivePersistField a where Source #
Datatypes which can be converted directly to PersistValue
Methods
toPrimitivePersistValue :: a -> PersistValue Source #
fromPrimitivePersistValue :: PersistValue -> a Source #
Instances
class PersistField v => Embedded v where Source #
Methods
selectorNum :: Selector v a -> Int Source #
Instances
| (PersistField a', PersistField b') => Embedded (a', b') Source # | |
| (PersistField a', PersistField b', PersistField c') => Embedded (a', b', c') Source # | |
| (PersistField a', PersistField b', PersistField c', PersistField d') => Embedded (a', b', c', d') Source # | |
| (PersistField a', PersistField b', PersistField c', PersistField d', PersistField e') => Embedded (a', b', c', d', e') Source # | |
class Projection p a | p -> a where Source #
Any data that can be fetched from a database
Associated Types
type ProjectionDb p db :: Constraint Source #
type ProjectionRestriction p r :: Constraint Source #
Methods
projectionExprs :: (DbDescriptor db, ProjectionDb p db, ProjectionRestriction p r) => p -> [UntypedExpr db r] -> [UntypedExpr db r] Source #
It returns multiple expressions that can be transformed into values which can be selected. Difflist is used for concatenation efficiency.
projectionResult :: PersistBackend m => p -> [PersistValue] -> m (a, [PersistValue]) Source #
It is like fromPersistValues. However, we cannot use it for projections in all cases. For the PersistEntity instances fromPersistValues expects entity id instead of the entity values.
Instances
class (Projection p a, ProjectionDb p db, ProjectionRestriction p r) => Projection' p db r a Source #
Instances
| (Projection p a, ProjectionDb p db, ProjectionRestriction p r) => Projection' p db r a Source # | |
Defined in Database.Groundhog.Core | |
data RestrictionHolder v (c :: (Type -> Type) -> Type) Source #
Instances
| type ProjectionRestriction (u (UniqueMarker v)) (RestrictionHolder v' c) Source # | |
Defined in Database.Groundhog.Instances | |
data KeyForBackend db v Source #
It allows to store autogenerated keys of one database in another if they have different datatype.
Constructors
| (DbDescriptor db, PersistEntity v) => KeyForBackend (AutoKeyType db) |
Instances
| (DbDescriptor db, PersistEntity v, PersistField v) => PrimitivePersistField (KeyForBackend db v) Source # | |
Defined in Database.Groundhog.Instances Methods toPrimitivePersistValue :: KeyForBackend db v -> PersistValue Source # fromPrimitivePersistValue :: PersistValue -> KeyForBackend db v Source # | |
| (DbDescriptor db, PersistEntity v, PersistField v) => PersistField (KeyForBackend db v) Source # | |
Defined in Database.Groundhog.Instances Methods persistName :: KeyForBackend db v -> String Source # toPersistValues :: PersistBackend m => KeyForBackend db v -> m ([PersistValue] -> [PersistValue]) Source # fromPersistValues :: PersistBackend m => [PersistValue] -> m (KeyForBackend db v, [PersistValue]) Source # dbType :: DbDescriptor db0 => proxy db0 -> KeyForBackend db v -> DbType Source # | |
| NeverNull (KeyForBackend db v) Source # | |
Defined in Database.Groundhog.Instances | |
data BackendSpecific Source #
Key marked with this type can have value for any backend
data ConstructorMarker v a Source #
A phantom datatype to make instance head different c (ConstructorMarker v)
Instances
| EntityConstr v c => Projection (c (ConstructorMarker v)) v Source # | |
Defined in Database.Groundhog.Instances Associated Types type ProjectionDb (c (ConstructorMarker v)) db Source # type ProjectionRestriction (c (ConstructorMarker v)) r Source # Methods projectionExprs :: (DbDescriptor db, ProjectionDb (c (ConstructorMarker v)) db, ProjectionRestriction (c (ConstructorMarker v)) r) => c (ConstructorMarker v) -> [UntypedExpr db r] -> [UntypedExpr db r] Source # projectionResult :: PersistBackend m => c (ConstructorMarker v) -> [PersistValue] -> m (v, [PersistValue]) Source # | |
| type ProjectionDb (c (ConstructorMarker v)) db Source # | |
Defined in Database.Groundhog.Instances | |
| type ProjectionRestriction (c (ConstructorMarker v)) r Source # | |
Defined in Database.Groundhog.Instances | |
data UniqueMarker v a Source #
A phantom datatype to make instance head different u (UniqueMarker v)
Instances
fromUtf8 :: Utf8 -> ByteString Source #
Constructing expressions
Represents condition for a query.
Constructors
| And (Cond db r) (Cond db r) | |
| Or (Cond db r) (Cond db r) | |
| Not (Cond db r) | |
| Compare ExprRelation (UntypedExpr db r) (UntypedExpr db r) | |
| CondRaw (QueryRaw db r) | |
| CondEmpty |
Instances
data ExprRelation Source #
Instances
| Show ExprRelation Source # | |
Defined in Database.Groundhog.Core Methods showsPrec :: Int -> ExprRelation -> ShowS # show :: ExprRelation -> String # showList :: [ExprRelation] -> ShowS # | |
Constructors
| forall f a.(Assignable f a, Projection' f db r a) => Update f (UntypedExpr db r) |
(~>) :: (EntityConstr v c, FieldLike f a, DbDescriptor db, Projection' f db (RestrictionHolder v c) a, Embedded a) => f -> Selector a a' -> SubField db v c a' infixl 5 Source #
Accesses fields of the embedded datatypes. For example, SomeField ==. ("abc", "def") ||. SomeField ~> Tuple2_0Selector ==. "def"
class Assignable f a => FieldLike f a | f -> a where Source #
This subset of Assignable is for plain database fields.
Methods
fieldChain :: (DbDescriptor db, ProjectionDb f db) => proxy db -> f -> FieldChain Source #
Instances
class Projection f a => Assignable f a | f -> a Source #
This subset of Projection instances is for things that behave like fields. Namely, they can occur in condition expressions (for example, Field and SubField) and on the left side of update statements. For example "lower(field)" is a valid Projection, but not Field like because it cannot be on the left side. Datatypes that index PostgreSQL arrays "arr[5]" or access composites "(comp).subfield" are valid instances of Assignable.
Instances
| (PersistEntity v, IsUniqueKey k, k ~ Key v (Unique u)) => Assignable (u (UniqueMarker v)) k Source # | |
Defined in Database.Groundhog.Instances | |
| (EntityConstr v c, a ~ AutoKey v) => Assignable (AutoKeyField v c) a Source # | |
Defined in Database.Groundhog.Instances | |
| (EntityConstr v c, PersistField a) => Assignable (Field v c a) a Source # | |
Defined in Database.Groundhog.Instances | |
| (EntityConstr v c, PersistField a) => Assignable (SubField db v c a) a Source # | |
Defined in Database.Groundhog.Instances | |
newtype SubField db v (c :: (Type -> Type) -> Type) a Source #
Constructors
| SubField FieldChain |
Instances
data AutoKeyField v (c :: (Type -> Type) -> Type) where Source #
It can be used in expressions like a regular field.
For example, delete (AutoKeyField ==. k)
or delete (AutoKeyField ==. k ||. SomeField ==. "DUPLICATE")
Constructors
| AutoKeyField :: AutoKeyField v c |
Instances
type FieldChain = ((String, DbType), [(String, EmbeddedDef)]) Source #
It is used to map field to column names. It can be either a column name for a regular field of non-embedded type or a list of this field and the outer fields in reverse order. Eg, fieldChain $ SomeField ~> Tuple2_0Selector may result in [("val0", DbString), ("some", DbEmbedded False [dbType "", dbType True])].
Types which are never NULL when converted to PersistValue.
Consider the type Maybe (Maybe a). Now Nothing is stored as NULL, so we cannot distinguish between Just Nothing and Nothing which is a problem.
The purpose of this class is to ban the inner Maybe's.
Maybe this class can be removed when support for inner Maybe's appears.
Instances
data UntypedExpr db r where Source #
Used to uniformly represent fields, constants and more complex things, e.g., arithmetic expressions.
A value should be converted to UntypedExpr for usage in expressions
Constructors
| ExprRaw :: DbType -> QueryRaw db r -> UntypedExpr db r | |
| ExprField :: FieldChain -> UntypedExpr db r | |
| ExprPure :: forall db r a. PurePersistField a => a -> UntypedExpr db r | |
| ExprCond :: Cond db r -> UntypedExpr db r |
Expr with phantom type helps to keep type safety in complex expressions
Constructors
| Expr (UntypedExpr db r) |
Instances
| (PersistField a, db' ~ db, r' ~ r) => Expression db' r' (Expr db r a) Source # | |
Defined in Database.Groundhog.Expression Methods toExpr :: Expr db r a -> UntypedExpr db' r' Source # | |
| (SqlDb db, PersistField a, Enum a) => Enum (Expr db r a) Source # | |
Defined in Database.Groundhog.Generic.Sql.Functions Methods succ :: Expr db r a -> Expr db r a # pred :: Expr db r a -> Expr db r a # toEnum :: Int -> Expr db r a # fromEnum :: Expr db r a -> Int # enumFrom :: Expr db r a -> [Expr db r a] # enumFromThen :: Expr db r a -> Expr db r a -> [Expr db r a] # enumFromTo :: Expr db r a -> Expr db r a -> [Expr db r a] # enumFromThenTo :: Expr db r a -> Expr db r a -> Expr db r a -> [Expr db r a] # | |
| Eq (Expr db r a) Source # | |
| (FloatingSqlDb db, PersistField a, Floating a) => Floating (Expr db r a) Source # | |
Defined in Database.Groundhog.Generic.Sql.Functions Methods exp :: Expr db r a -> Expr db r a # log :: Expr db r a -> Expr db r a # sqrt :: Expr db r a -> Expr db r a # (**) :: Expr db r a -> Expr db r a -> Expr db r a # logBase :: Expr db r a -> Expr db r a -> Expr db r a # sin :: Expr db r a -> Expr db r a # cos :: Expr db r a -> Expr db r a # tan :: Expr db r a -> Expr db r a # asin :: Expr db r a -> Expr db r a # acos :: Expr db r a -> Expr db r a # atan :: Expr db r a -> Expr db r a # sinh :: Expr db r a -> Expr db r a # cosh :: Expr db r a -> Expr db r a # tanh :: Expr db r a -> Expr db r a # asinh :: Expr db r a -> Expr db r a # acosh :: Expr db r a -> Expr db r a # atanh :: Expr db r a -> Expr db r a # log1p :: Expr db r a -> Expr db r a # expm1 :: Expr db r a -> Expr db r a # | |
| (SqlDb db, PersistField a, Fractional a) => Fractional (Expr db r a) Source # | |
| (SqlDb db, PurePersistField a, Integral a) => Integral (Expr db r a) Source # | |
Defined in Database.Groundhog.Generic.Sql.Functions Methods quot :: Expr db r a -> Expr db r a -> Expr db r a # rem :: Expr db r a -> Expr db r a -> Expr db r a # div :: Expr db r a -> Expr db r a -> Expr db r a # mod :: Expr db r a -> Expr db r a -> Expr db r a # quotRem :: Expr db r a -> Expr db r a -> (Expr db r a, Expr db r a) # divMod :: Expr db r a -> Expr db r a -> (Expr db r a, Expr db r a) # | |
| (SqlDb db, PersistField a, Num a) => Num (Expr db r a) Source # | |
Defined in Database.Groundhog.Generic.Sql.Functions Methods (+) :: Expr db r a -> Expr db r a -> Expr db r a # (-) :: Expr db r a -> Expr db r a -> Expr db r a # (*) :: Expr db r a -> Expr db r a -> Expr db r a # negate :: Expr db r a -> Expr db r a # abs :: Expr db r a -> Expr db r a # signum :: Expr db r a -> Expr db r a # fromInteger :: Integer -> Expr db r a # | |
| (SqlDb db, PersistField a, Ord a) => Ord (Expr db r a) Source # | |
Defined in Database.Groundhog.Generic.Sql.Functions | |
| (SqlDb db, PersistField a, Real a) => Real (Expr db r a) Source # | |
Defined in Database.Groundhog.Generic.Sql.Functions Methods toRational :: Expr db r a -> Rational # | |
| Show (Expr db r a) Source # | |
| PersistField a => Projection (Expr db r a) a Source # | |
Defined in Database.Groundhog.Instances Associated Types type ProjectionDb (Expr db r a) db Source # type ProjectionRestriction (Expr db r a) r Source # Methods projectionExprs :: (DbDescriptor db0, ProjectionDb (Expr db r a) db0, ProjectionRestriction (Expr db r a) r0) => Expr db r a -> [UntypedExpr db0 r0] -> [UntypedExpr db0 r0] Source # projectionResult :: PersistBackend m => Expr db r a -> [PersistValue] -> m (a, [PersistValue]) Source # | |
| type ProjectionDb (Expr db r a) db' Source # | |
Defined in Database.Groundhog.Instances | |
| type ProjectionRestriction (Expr db r a) r' Source # | |
Defined in Database.Groundhog.Instances | |
Defines sort order of a result-set
Constructors
| forall a f.Projection' f db r a => Asc f | |
| forall a f.Projection' f db r a => Desc f |
class HasSelectOptions a db r | a -> db r where Source #
This class helps to check that limit, offset, or order clauses are added to condition only once.
Associated Types
type HasDistinct a Source #
Methods
getSelectOptions :: a -> SelectOptions db r (HasLimit a) (HasOffset a) (HasOrder a) (HasDistinct a) Source #
Instances
| db' ~ db => HasSelectOptions (Cond db r) db' r Source # | |
Defined in Database.Groundhog.Core Associated Types type HasLimit (Cond db r) Source # type HasOffset (Cond db r) Source # type HasOrder (Cond db r) Source # type HasDistinct (Cond db r) Source # Methods getSelectOptions :: Cond db r -> SelectOptions db' r (HasLimit (Cond db r)) (HasOffset (Cond db r)) (HasOrder (Cond db r)) (HasDistinct (Cond db r)) Source # | |
| db' ~ db => HasSelectOptions (SelectOptions db r hasLimit hasOffset hasOrder hasDistinct) db' r Source # | |
Defined in Database.Groundhog.Core Associated Types type HasLimit (SelectOptions db r hasLimit hasOffset hasOrder hasDistinct) Source # type HasOffset (SelectOptions db r hasLimit hasOffset hasOrder hasDistinct) Source # type HasOrder (SelectOptions db r hasLimit hasOffset hasOrder hasDistinct) Source # type HasDistinct (SelectOptions db r hasLimit hasOffset hasOrder hasDistinct) Source # Methods getSelectOptions :: SelectOptions db r hasLimit hasOffset hasOrder hasDistinct -> SelectOptions db' r (HasLimit (SelectOptions db r hasLimit hasOffset hasOrder hasDistinct)) (HasOffset (SelectOptions db r hasLimit hasOffset hasOrder hasDistinct)) (HasOrder (SelectOptions db r hasLimit hasOffset hasOrder hasDistinct)) (HasDistinct (SelectOptions db r hasLimit hasOffset hasOrder hasDistinct)) Source # | |
data SelectOptions db r hasLimit hasOffset hasOrder hasDistinct Source #
Constructors
| SelectOptions | |
Fields
| |
Instances
| db' ~ db => HasSelectOptions (SelectOptions db r hasLimit hasOffset hasOrder hasDistinct) db' r Source # | |
Defined in Database.Groundhog.Core Associated Types type HasLimit (SelectOptions db r hasLimit hasOffset hasOrder hasDistinct) Source # type HasOffset (SelectOptions db r hasLimit hasOffset hasOrder hasDistinct) Source # type HasOrder (SelectOptions db r hasLimit hasOffset hasOrder hasDistinct) Source # type HasDistinct (SelectOptions db r hasLimit hasOffset hasOrder hasDistinct) Source # Methods getSelectOptions :: SelectOptions db r hasLimit hasOffset hasOrder hasDistinct -> SelectOptions db' r (HasLimit (SelectOptions db r hasLimit hasOffset hasOrder hasDistinct)) (HasOffset (SelectOptions db r hasLimit hasOffset hasOrder hasDistinct)) (HasOrder (SelectOptions db r hasLimit hasOffset hasOrder hasDistinct)) (HasDistinct (SelectOptions db r hasLimit hasOffset hasOrder hasDistinct)) Source # | |
| type HasLimit (SelectOptions db r hasLimit hasOffset hasOrder hasDistinct) Source # | |
Defined in Database.Groundhog.Core | |
| type HasOffset (SelectOptions db r hasLimit hasOffset hasOrder hasDistinct) Source # | |
Defined in Database.Groundhog.Core | |
| type HasOrder (SelectOptions db r hasLimit hasOffset hasOrder hasDistinct) Source # | |
Defined in Database.Groundhog.Core | |
| type HasDistinct (SelectOptions db r hasLimit hasOffset hasOrder hasDistinct) Source # | |
Defined in Database.Groundhog.Core | |
limitTo :: (HasSelectOptions a db r, HasLimit a ~ HFalse) => a -> Int -> SelectOptions db r HTrue (HasOffset a) (HasOrder a) (HasDistinct a) Source #
offsetBy :: (HasSelectOptions a db r, HasOffset a ~ HFalse) => a -> Int -> SelectOptions db r (HasLimit a) HTrue (HasOrder a) (HasDistinct a) Source #
orderBy :: (HasSelectOptions a db r, HasOrder a ~ HFalse) => a -> [Order db r] -> SelectOptions db r (HasLimit a) (HasOffset a) HTrue (HasDistinct a) Source #
distinct :: (HasSelectOptions a db r, HasDistinct a ~ HFalse) => a -> SelectOptions db r (HasLimit a) (HasOffset a) (HasOrder a) HTrue Source #
Select DISTINCT rows. select $ distinct CondEmpty
Type description
These types describe the mapping between database schema and datatype. They hold table names, columns, constraints, etc. Some types below are parameterized by string type str and dbType. This is done to make them promotable to kind level.
data DbTypePrimitive' str Source #
A DB data type. Naming attempts to reflect the underlying Haskell datatypes, eg DbString instead of DbVarchar. Different databases may have different representations for these types.
Constructors
| DbString | |
| DbInt32 | |
| DbInt64 | |
| DbReal | |
| DbBool | |
| DbDay | |
| DbTime | |
| DbDayTime | |
| DbDayTimeZoned | |
| DbBlob | ByteString |
| DbOther (OtherTypeDef' str) |
Instances
| Eq str => Eq (DbTypePrimitive' str) Source # | |
Defined in Database.Groundhog.Core Methods (==) :: DbTypePrimitive' str -> DbTypePrimitive' str -> Bool # (/=) :: DbTypePrimitive' str -> DbTypePrimitive' str -> Bool # | |
| Show str => Show (DbTypePrimitive' str) Source # | |
Defined in Database.Groundhog.Core Methods showsPrec :: Int -> DbTypePrimitive' str -> ShowS # show :: DbTypePrimitive' str -> String # showList :: [DbTypePrimitive' str] -> ShowS # | |
type DbTypePrimitive = DbTypePrimitive' String Source #
Constructors
| DbTypePrimitive DbTypePrimitive Bool (Maybe String) (Maybe ParentTableReference) | type, nullable, default value, reference |
| DbEmbedded EmbeddedDef (Maybe ParentTableReference) | |
| DbList String DbType | List table name and type of its argument |
data EntityDef' str dbType Source #
Describes an ADT.
Constructors
| EntityDef | |
Fields
| |
Instances
| (Eq str, Eq dbType) => Eq (EntityDef' str dbType) Source # | |
Defined in Database.Groundhog.Core Methods (==) :: EntityDef' str dbType -> EntityDef' str dbType -> Bool # (/=) :: EntityDef' str dbType -> EntityDef' str dbType -> Bool # | |
| (Show str, Show dbType) => Show (EntityDef' str dbType) Source # | |
Defined in Database.Groundhog.Core Methods showsPrec :: Int -> EntityDef' str dbType -> ShowS # show :: EntityDef' str dbType -> String # showList :: [EntityDef' str dbType] -> ShowS # | |
data EmbeddedDef' str dbType Source #
The first argument is a flag which defines if the field names should be concatenated with the outer field name (False) or used as is which provides full control over table column names (True). Value False should be the default value so that a datatype can be embedded without name conflict concern. The second argument list of field names and field types.
Constructors
| EmbeddedDef Bool [(str, dbType)] |
Instances
| (Eq str, Eq dbType) => Eq (EmbeddedDef' str dbType) Source # | |
Defined in Database.Groundhog.Core Methods (==) :: EmbeddedDef' str dbType -> EmbeddedDef' str dbType -> Bool # (/=) :: EmbeddedDef' str dbType -> EmbeddedDef' str dbType -> Bool # | |
| (Show str, Show dbType) => Show (EmbeddedDef' str dbType) Source # | |
Defined in Database.Groundhog.Core Methods showsPrec :: Int -> EmbeddedDef' str dbType -> ShowS # show :: EmbeddedDef' str dbType -> String # showList :: [EmbeddedDef' str dbType] -> ShowS # | |
type EmbeddedDef = EmbeddedDef' String DbType Source #
newtype OtherTypeDef' str Source #
Stores a database type. The list contains two kinds of tokens for the type string. Backend will choose a string representation for DbTypePrimitive's, and the string literals will go to the type as-is. As the final step, these tokens are concatenated. For example, [Left "varchar(50)"] will become a string with max length and [Right DbInt64, Left "[]"] will become integer[] in PostgreSQL.
Constructors
| OtherTypeDef [Either str (DbTypePrimitive' str)] |
Instances
| Eq str => Eq (OtherTypeDef' str) Source # | |
Defined in Database.Groundhog.Core Methods (==) :: OtherTypeDef' str -> OtherTypeDef' str -> Bool # (/=) :: OtherTypeDef' str -> OtherTypeDef' str -> Bool # | |
| Show str => Show (OtherTypeDef' str) Source # | |
Defined in Database.Groundhog.Core Methods showsPrec :: Int -> OtherTypeDef' str -> ShowS # show :: OtherTypeDef' str -> String # showList :: [OtherTypeDef' str] -> ShowS # | |
type OtherTypeDef = OtherTypeDef' String Source #
data ConstructorDef' str dbType Source #
Describes an entity constructor
Constructors
| ConstructorDef | |
Fields
| |
Instances
| (Eq str, Eq dbType) => Eq (ConstructorDef' str dbType) Source # | |
Defined in Database.Groundhog.Core Methods (==) :: ConstructorDef' str dbType -> ConstructorDef' str dbType -> Bool # (/=) :: ConstructorDef' str dbType -> ConstructorDef' str dbType -> Bool # | |
| (Show str, Show dbType) => Show (ConstructorDef' str dbType) Source # | |
Defined in Database.Groundhog.Core Methods showsPrec :: Int -> ConstructorDef' str dbType -> ShowS # show :: ConstructorDef' str dbType -> String # showList :: [ConstructorDef' str dbType] -> ShowS # | |
type ConstructorDef = ConstructorDef' String DbType Source #
class Constructor c where Source #
Phantom constructors are made instances of this class. This class should be used only by Template Haskell codegen
class PersistEntity v => EntityConstr v c where Source #
This class helps type inference in cases when query does not contain any fields which
define the constructor, but the entity has only one.
For example, in select $ AutoKeyField ==. k the condition would need type annotation with constructor name only if we select a sum type.
Instances
| (PersistEntity v, EntityConstr' (IsSumType v) c) => EntityConstr v c Source # | |
Defined in Database.Groundhog.Instances | |
class PurePersistField uKey => IsUniqueKey uKey where Source #
Methods
extractUnique :: uKey ~ Key v u => v -> uKey Source #
Creates value of unique key using the data extracted from the passed value
uniqueNum :: uKey -> Int Source #
Ordinal number of the unique constraint in the list returned by constrUniques
data UniqueDef' str field Source #
Unique name and list of the fields that form a unique combination. The fields are parametrized to reuse this datatype both with field and DbType and with column name
Constructors
| UniqueDef | |
Fields
| |
Instances
| (Eq str, Eq field) => Eq (UniqueDef' str field) Source # | |
Defined in Database.Groundhog.Core Methods (==) :: UniqueDef' str field -> UniqueDef' str field -> Bool # (/=) :: UniqueDef' str field -> UniqueDef' str field -> Bool # | |
| (Show str, Show field) => Show (UniqueDef' str field) Source # | |
Defined in Database.Groundhog.Core Methods showsPrec :: Int -> UniqueDef' str field -> ShowS # show :: UniqueDef' str field -> String # showList :: [UniqueDef' str field] -> ShowS # | |
type UniqueDef = UniqueDef' String (Either (String, DbType) String) Source #
Field is either a pair of entity field name and its type or an expression which will be used in query as-is.
data UniqueType Source #
Defines how to treat the unique set of fields for a datatype
Constructors
| UniqueConstraint | |
| UniqueIndex | |
| UniquePrimary Bool | is autoincremented |
Instances
| Eq UniqueType Source # | |
Defined in Database.Groundhog.Core | |
| Ord UniqueType Source # | |
Defined in Database.Groundhog.Core Methods compare :: UniqueType -> UniqueType -> Ordering # (<) :: UniqueType -> UniqueType -> Bool # (<=) :: UniqueType -> UniqueType -> Bool # (>) :: UniqueType -> UniqueType -> Bool # (>=) :: UniqueType -> UniqueType -> Bool # max :: UniqueType -> UniqueType -> UniqueType # min :: UniqueType -> UniqueType -> UniqueType # | |
| Show UniqueType Source # | |
Defined in Database.Groundhog.Core Methods showsPrec :: Int -> UniqueType -> ShowS # show :: UniqueType -> String # showList :: [UniqueType] -> ShowS # | |
data ReferenceActionType Source #
Constructors
| NoAction | |
| Restrict | |
| Cascade | |
| SetNull | |
| SetDefault |
Instances
| Eq ReferenceActionType Source # | |
Defined in Database.Groundhog.Core Methods (==) :: ReferenceActionType -> ReferenceActionType -> Bool # (/=) :: ReferenceActionType -> ReferenceActionType -> Bool # | |
| Show ReferenceActionType Source # | |
Defined in Database.Groundhog.Core Methods showsPrec :: Int -> ReferenceActionType -> ShowS # show :: ReferenceActionType -> String # showList :: [ReferenceActionType] -> ShowS # | |
type ParentTableReference = (Either (EntityDef, Maybe String) ((Maybe String, String), [String]), Maybe ReferenceActionType, Maybe ReferenceActionType) Source #
The reference contains either EntityDef of the parent table and name of the unique constraint. Or for tables not mapped by Groundhog schema name, table name, and list of columns Reference to the autogenerated key of a mapped entity = (Left (entityDef, Nothing), onDelete, onUpdate) Reference to a unique key of a mapped entity = (Left (entityDef, Just uniqueKeyName), onDelete, onUpdate) Reference to a table that is not mapped = (Right ((schema, tableName), columns), onDelete, onUpdate)
Migration
type SingleMigration = Either [String] [(Bool, Int, String)] Source #
Either error messages or migration queries with safety flag and execution order
type NamedMigrations = Map String SingleMigration Source #
Datatype names and corresponding migrations
type Migration m = StateT NamedMigrations m () Source #
Database
class (Monad m, MonadIO m, MonadFail m, ConnectionManager (Conn m), PersistBackendConn (Conn m)) => PersistBackend m where Source #
This class helps to shorten the type signatures of user monadic code. If your monad has several connections, e.g., for main and audit databases, create run*Db function runAuditDb :: Action conn a -> m a
Methods
getConnection :: m (Conn m) Source #
Instances
| (Monad m, MonadIO m, MonadFail m, PersistBackendConn conn) => PersistBackend (ReaderT conn m) Source # | |
class (DbDescriptor conn, ConnectionManager conn) => PersistBackendConn conn where Source #
Methods
insert :: (PersistEntity v, PersistBackend m, Conn m ~ conn) => v -> m (AutoKey v) Source #
Insert a new record to a database and return its autogenerated key or ()
insert_ :: (PersistEntity v, PersistBackend m, Conn m ~ conn) => v -> m () Source #
Insert a new record to a database. For some backends it may be faster than insert.
insertBy :: (PersistEntity v, IsUniqueKey (Key v (Unique u)), PersistBackend m, Conn m ~ conn) => u (UniqueMarker v) -> v -> m (Either (AutoKey v) (AutoKey v)) Source #
Try to insert a record and return Right newkey. If there is a constraint violation for the given constraint, Left oldkey is returned , where oldkey is an identifier of the record with the matching values.
insertByAll :: (PersistEntity v, PersistBackend m, Conn m ~ conn) => v -> m (Either (AutoKey v) (AutoKey v)) Source #
Try to insert a record and return Right newkey. If there is a constraint violation for any constraint, Left oldkey is returned , where oldkey is an identifier of the record with the matching values. Note that if several constraints are violated, a key of an arbitrary matching record is returned.
replace :: (PersistEntity v, PrimitivePersistField (Key v BackendSpecific), PersistBackend m, Conn m ~ conn) => Key v BackendSpecific -> v -> m () Source #
Replace a record with the given autogenerated key. Result is undefined if the record does not exist.
replaceBy :: (PersistEntity v, IsUniqueKey (Key v (Unique u)), PersistBackend m, Conn m ~ conn) => u (UniqueMarker v) -> v -> m () Source #
Replace a record. The unique key marker defines what unique key of the entity is used.
select :: (PersistEntity v, EntityConstr v c, HasSelectOptions opts conn (RestrictionHolder v c), PersistBackend m, Conn m ~ conn) => opts -> m [v] Source #
Return a list of the records satisfying the condition. Example: select $ (FirstField ==. "abc" &&. SecondField >. "def") `orderBy` [Asc ThirdField] `limitTo` 100
selectStream :: (PersistEntity v, EntityConstr v c, HasSelectOptions opts conn (RestrictionHolder v c), PersistBackend m, Conn m ~ conn) => opts -> m (RowStream v) Source #
Return a list of the records satisfying the condition. Example: select $ (FirstField ==. "abc" &&. SecondField >. "def") `orderBy` [Asc ThirdField] `limitTo` 100
selectAll :: (PersistEntity v, PersistBackend m, Conn m ~ conn) => m [(AutoKey v, v)] Source #
Return a list of all records. Order is undefined. It can be useful for datatypes with multiple constructors.
selectAllStream :: (PersistEntity v, PersistBackend m, Conn m ~ conn) => m (RowStream (AutoKey v, v)) Source #
Return a list of all records. Order is undefined. It can be useful for datatypes with multiple constructors.
get :: (PersistEntity v, PrimitivePersistField (Key v BackendSpecific), PersistBackend m, Conn m ~ conn) => Key v BackendSpecific -> m (Maybe v) Source #
Fetch an entity from a database
getBy :: (PersistEntity v, IsUniqueKey (Key v (Unique u)), PersistBackend m, Conn m ~ conn) => Key v (Unique u) -> m (Maybe v) Source #
Fetch an entity from a database by its unique key
update :: (PersistEntity v, EntityConstr v c, PersistBackend m, Conn m ~ conn) => [Update conn (RestrictionHolder v c)] -> Cond conn (RestrictionHolder v c) -> m () Source #
Update the records satisfying the condition. Example: update [FirstField =. "abc"] $ FirstField ==. "def"
delete :: (PersistEntity v, EntityConstr v c, PersistBackend m, Conn m ~ conn) => Cond conn (RestrictionHolder v c) -> m () Source #
Remove the records satisfying the condition
deleteBy :: (PersistEntity v, PrimitivePersistField (Key v BackendSpecific), PersistBackend m, Conn m ~ conn) => Key v BackendSpecific -> m () Source #
Remove the record with given key. No-op if the record does not exist
deleteAll :: (PersistEntity v, PersistBackend m, Conn m ~ conn) => v -> m () Source #
Remove all records. The entity parameter is used only for type inference.
count :: (PersistEntity v, EntityConstr v c, PersistBackend m, Conn m ~ conn) => Cond conn (RestrictionHolder v c) -> m Int Source #
Count total number of records satisfying the condition
countAll :: (PersistEntity v, PersistBackend m, Conn m ~ conn) => v -> m Int Source #
Count total number of records with all constructors. The entity parameter is used only for type inference
project :: (PersistEntity v, EntityConstr v c, Projection' p conn (RestrictionHolder v c) a, HasSelectOptions opts conn (RestrictionHolder v c), PersistBackend m, Conn m ~ conn) => p -> opts -> m [a] Source #
Fetch projection of some fields. Example: project (SecondField, ThirdField) $ (FirstField ==. "abc" &&. SecondField >. "def") `orderBy` [Asc ThirdField] `offsetBy` 100
projectStream :: (PersistEntity v, EntityConstr v c, Projection' p conn (RestrictionHolder v c) a, HasSelectOptions opts conn (RestrictionHolder v c), PersistBackend m, Conn m ~ conn) => p -> opts -> m (RowStream a) Source #
migrate :: (PersistEntity v, PersistBackend m, Conn m ~ conn) => v -> Migration m Source #
Check database schema and create migrations for the entity and the entities it contains
Arguments
| :: (PersistBackend m, Conn m ~ conn) | |
| => Bool | keep in cache |
| -> String | query |
| -> [PersistValue] | positional parameters |
| -> m () |
Execute raw query
Arguments
| :: (PersistBackend m, Conn m ~ conn) | |
| => Bool | keep in cache |
| -> String | query |
| -> [PersistValue] | positional parameters |
| -> m (RowStream [PersistValue]) |
Execute raw query with results
insertList :: (PersistField a, PersistBackend m, Conn m ~ conn) => [a] -> m Int64 Source #
getList :: (PersistField a, PersistBackend m, Conn m ~ conn) => Int64 -> m [a] Source #
class PrimitivePersistField (AutoKeyType db) => DbDescriptor db where Source #
Connections and transactions
class ExtractConnection cm conn | cm -> conn where Source #
Methods
extractConn :: (MonadBaseControl IO m, MonadIO m) => (conn -> m a) -> cm -> m a Source #
Extracts the connection. The connection manager can be a pool or the connection itself
class ConnectionManager conn where Source #
Connection manager provides connection to the passed function handles transations. Manager can be a connection itself, a pool, Snaplet in Snap, foundation datatype in Yesod, etc.
class TryConnectionManager conn where Source #
Methods
tryWithConn :: (MonadBaseControl IO m, MonadIO m, MonadCatch m) => (conn -> n a) -> (n a -> m (Either SomeException a)) -> conn -> m (Either SomeException a) Source #
Tries the transaction, using a provided function which evaluates to an Either. Any Left result will cause transaction rollback.
class Savepoint conn where Source #
Methods
withConnSavepoint :: (MonadBaseControl IO m, MonadIO m) => String -> m a -> conn -> m a Source #
Wraps the passed action into a named savepoint
withSavepoint :: (PersistBackend m, MonadBaseControl IO m, MonadIO m, Savepoint (Conn m)) => String -> m a -> m a Source #
It helps to run withConnSavepoint within a monad. Make sure that transaction is open
runDb :: PersistBackend m => Action (Conn m) a -> m a Source #
It helps to run database operations within an application monad.
runDbConn :: (MonadIO m, MonadBaseControl IO m, ConnectionManager conn, ExtractConnection cm conn) => Action conn a -> cm -> m a Source #
Runs action within connection. It can handle a simple connection, a pool of them, etc.
runTryDbConn :: (MonadIO m, MonadBaseControl IO m, MonadCatch m, TryConnectionManager conn, ExtractConnection cm conn, Exception e) => TryAction e m conn a -> cm -> m (Either SomeException a) Source #
Runs TryAction within connection.
runTryDbConn' :: (MonadIO m, MonadBaseControl IO m, MonadCatch m, TryConnectionManager conn, ExtractConnection cm conn) => Action conn a -> cm -> m (Either SomeException a) Source #
Tries Action within connection.
runDb' :: PersistBackend m => Action (Conn m) a -> m a Source #
It helps to run database operations within an application monad. Unlike runDb it does not wrap action in transaction
runDbConn' :: (MonadIO m, MonadBaseControl IO m, ConnectionManager conn, ExtractConnection cm conn) => Action conn a -> cm -> m a Source #
It is similar to runDbConn but runs action without transaction.
flip withConn conn $ \conn -> liftIO $ do -- transaction is already opened by withConn at this point someIOAction runDbConn' (insert_ value) conn