Only instances of this class can be persisted in a database

A raw value which can be stored in any backend and can be marshalled to and from a PersistField.

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.

Represents all datatypes that map into a single column. Getting value for that column might require monadic actions to access other tables.

Represents all datatypes that map into several columns. Getting values for those columns is pure.

Datatypes which can be converted directly to PersistValue

Any data that can be fetched from a database

A holder for Unique constraints

It allows to store autogenerated keys of one database in another if they have different datatype.

Key marked with this type can have value for any backend

A phantom datatype to make instance head different c (ConstructorMarker v)

A phantom datatype to make instance head different u (UniqueMarker v)

Avoid orphan instances.

Datatype for incremental building SQL queries

Represents condition for a query.

Accesses fields of the embedded datatypes. For example, SomeField ==. ("abc", "def") ||. SomeField ~> Tuple2_0Selector ==. "def"

This subset of Assignable is for plain database fields.

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.

It can be used in expressions like a regular field. For example, delete (AutoKeyField ==. k) or delete (AutoKeyField ==. k ||. SomeField ==. "DUPLICATE")

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.

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

Expr with phantom type helps to keep type safety in complex expressions

Defines sort order of a result-set

This class helps to check that limit, offset, or order clauses are added to condition only once.

Select DISTINCT rows. select $ distinct CondEmpty

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.

Describes an ADT.

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.

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.

Describes an entity constructor

Phantom constructors are made instances of this class. This class should be used only by Template Haskell codegen

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.

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

Field is either a pair of entity field name and its type or an expression which will be used in query as-is.

Defines how to treat the unique set of fields for a datatype

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)

Either error messages or migration queries with safety flag and execution order

Datatype names and corresponding migrations

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

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.

It helps to run withConnSavepoint within a monad. Make sure that transaction is open

It helps to run database operations within an application monad.

Runs action within connection. It can handle a simple connection, a pool of them, etc.

Runs TryAction within connection.

Tries Action within connection.

It helps to run database operations within an application monad. Unlike runDb it does not wrap action in transaction

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