Same as get, but for a non-null (not Maybe) foreign key Unsafe unless your database is enforcing that the foreign key is valid

curry this to make a convenience function that loads an associated model > foreign = belongsTo foeignId

same as belongsTo, but uses getJust and therefore is similarly unsafe

Queries against unique keys (other than the id).

Please read the general Persistent documentation to learn how to create Unique keys. SQL backends automatically create uniqueness constraints, but for MongoDB you must manually place a unique index on the field.

Some functions in this module (insertUnique, insertBy, and replaceUnique) first query the unique indexes to check for conflicts. You could instead optimistically attempt to perform the operation (e.g. replace instead of replaceUnique). However,

• there is some fragility to trying to catch the correct exception and determing the column of failure.
• an exception will automatically abort the current SQL transaction

A modification of getBy, which takes the PersistEntity itself instead of a Unique value. Returns a value matching one of the unique keys. This function makes the most sense on entities with a single Unique constructor.

Insert a value, checking for conflicts with any unique constraints. If a duplicate exists in the database, it is returned as Left. Otherwise, the new 'Key is returned as Right.

Attempt to replace the record of the given key with the given new record. First query the unique fields to make sure the replacement maintains uniqueness constraints. Return Nothing if the replacement was made. If uniqueness is violated, return a Just with the Unique violation

Since 1.2.2.0

Call selectSource but return the result as a list.

Call selectKeys but return the result as a list.

Persistent serialized Haskell records to the database. A Database Entity (A row in SQL, a document in MongoDB, etc) corresponds to a Key plus a Haskell record.

For every Haskell record type stored in the database there is a corresponding PersistEntity instance. An instance of PersistEntity contains meta-data for the record. PersistEntity also helps abstract over different record types. That way the same query interface can return a PersistEntity, with each query returning different types of Haskell records.

Some advanced type system capabilities are used to make this process type-safe. Persistent users usually don't need to understand the class associated data and functions.

A value which can be marshalled to and from a PersistValue.

Represents a value containing all the configuration options for a specific backend. This abstraction makes it easier to write code that can easily swap backends.

Predefined toJSON. The resulting JSON looks like {"key": 1, "value": {"name": ...}}.

The typical usage is:

  instance ToJSON User where
      toJSON = keyValueEntityToJSON

Predefined parseJSON. The input JSON looks like {"key": 1, "value": {"name": ...}}.

The typical usage is:

  instance FromJSON User where
      parseJSON = keyValueEntityFromJSON

Predefined toJSON. The resulting JSON looks like {"id": 1, "name": ...}.

The typical usage is:

  instance ToJSON User where
      toJSON = entityIdToJSON

Predefined parseJSON. The input JSON looks like {"id": 1, "name": ...}.

The typical usage is:

  instance FromJSON User where
      parseJSON = entityIdFromJSON