Database.Ribbit.PostgreSQL

"postgresql-simple"-backed query ribbit implementation.

Integrating your types.

class HasPsqlType a where

Given a Haskell type, produce the PostgreSQL type of columns that store values of that haskell type.

Methods

psqlType :: proxy a -> PsqlType

Instances

HasPsqlType Int

Defined in Database.Ribbit.PostgreSQL

Methods

psqlType :: proxy Int -> PsqlType

HasPsqlType Text

Defined in Database.Ribbit.PostgreSQL

Methods

psqlType :: proxy Text -> PsqlType

HasPsqlType Day

Defined in Database.Ribbit.PostgreSQL

Methods

psqlType :: proxy Day -> PsqlType

HasPsqlType a => HasPsqlType (Maybe a :: Type)

Defined in Database.Ribbit.PostgreSQL

Methods

psqlType :: proxy (Maybe a) -> PsqlType

newtype PsqlType

Represents the "base" PostgreSQL type. We say "base" type because whether the type is nullable is handle automatically.

e.g.

• PsqlType "integer"

• PsqlType "timestamp with time zone"

Constructors

PsqlType

Fields

• unPsqlType :: Text

Instances

IsString PsqlType

Defined in Database.Ribbit.PostgreSQL

Methods

fromString :: String -> PsqlType

Performing queries.

execute :: forall m query. (MonadIO m, ToRow (ParamsType query), KnownSymbol (Render query)) => Connection -> Proxy query -> ParamsType query -> m Int64

Execute a statement.

query :: forall m query. (MonadIO m, KnownSymbol (Render query), ToRow (ParamsType query), FromRow (ResultType query)) => Connection -> Proxy query -> ParamsType query -> m [ResultType query]

Execute a query against a PostgreSQL database connection.

Creating tables.

createTable :: forall proxy1 proxy2 key table m. (KnownSymbol (Name table), HasPsqlTypes (DBSchema table), HasFields (DBSchema table), HasFields key, IsSubset key (DBSchema table) ~ True, MonadIO m) => Connection -> proxy1 key -> proxy2 table -> m ()

Create the indicated table in the database.

See createTableStatement for details.

createTableStatement :: forall proxy1 proxy2 table key. (KnownSymbol (Name table), HasPsqlTypes (DBSchema table), HasFields (DBSchema table), HasFields key, IsSubset key (DBSchema table) ~ True) => proxy1 key -> proxy2 table -> Text

Produce the statement used to create a table.

In this example, we create an employee table with a multi-part primary key, one nullable field, and a few non-nullable fields.

data Employee
instance Table Employee where
  type Name = "employees"
  type DBSchema =
    Field "company_id" Int
    :> Field "id" Int
    :> Field "name" Text
    :> Field "quit_date" (Maybe Day)

let
  primaryKey :: Proxy '["company_id", "id"]
  primaryKey = Proxy
  
  table :: Proxy Employee
  table = Proxy

in
  createTableStatement primaryKey table

This will produce the statement:

"create table employees (company_id integer not null, id integer not null, name text not null, quit_date date, primary key (company_id, id));"

Other types.

These type classes/families are not meant to be used directly. They are exported primarily because they appear in the type signatures of some of the above functions and documenting them can be helpful when trying to figure out how to use those functions.

class HasFields a

Produce a list of field names from a schema.

Minimal complete definition

fields

Instances

HasFields ([] :: [k])

Defined in Database.Ribbit.PostgreSQL

Methods

fields :: proxy [] -> [Text]

(KnownSymbol name, HasFields more) => HasFields (Field name typ :> more :: Type)

Defined in Database.Ribbit.PostgreSQL

Methods

fields :: proxy (Field name typ :> more) -> [Text]

(KnownSymbol name, HasFields more) => HasFields (name ': more :: [Symbol])

Defined in Database.Ribbit.PostgreSQL

Methods

fields :: proxy (name ': more) -> [Text]

KnownSymbol name => HasFields (Field name typ :: Type)

Defined in Database.Ribbit.PostgreSQL

Methods

fields :: proxy (Field name typ) -> [Text]

class HasPsqlTypes a

Minimal complete definition

psqlTypes

Instances

(HasIsNullable typ, HasPsqlType typ, HasPsqlTypes more) => HasPsqlTypes (Field name typ :> more :: Type)

Defined in Database.Ribbit.PostgreSQL

Methods

psqlTypes :: proxy (Field name typ :> more) -> [Text]

(HasIsNullable typ, HasPsqlType typ) => HasPsqlTypes (Field name typ :: Type)

Defined in Database.Ribbit.PostgreSQL

Methods

psqlTypes :: proxy (Field name typ) -> [Text]

class HasIsNullable a

Figure out if a Haskell type is "nullable" in sql.

Minimal complete definition

isNullable

Instances

HasIsNullable (a :: k)

Defined in Database.Ribbit.PostgreSQL

Methods

isNullable :: proxy a -> Bool

HasIsNullable (Maybe a :: Type)

Defined in Database.Ribbit.PostgreSQL

Methods

isNullable :: proxy (Maybe a) -> Bool

type family IsSubset fields schema where ...

Make sure the fields in the list are actually part of the schema.

Equations

IsSubset '[] schema = True

IsSubset (field ': more) schema = If (ValidField field schema) (IsSubset more schema) (TypeError ((Text "field " :<>: ShowType field) :<>: Text " is not part of the schema, so it cannot be used as a component of the primary key."))

class FromRow a

Like FromRow, but defined here so we can avoid orphaned instances.

Minimal complete definition

fromRow

Instances

FromField a => FromRow (Only a)

Defined in Database.Ribbit.PostgreSQL

Methods

fromRow :: RowParser (Only a)

(FromRow a, FromRow b) => FromRow (a :> b)

Defined in Database.Ribbit.PostgreSQL

Methods

fromRow :: RowParser (a :> b)

class ToRow a

Like ToRow, but defined here to avoid orphan instances.

Minimal complete definition

toRow

Instances

ToRow ()

Defined in Database.Ribbit.PostgreSQL

Methods

toRow :: () -> [Action]

ToField a => ToRow (Only a)

Defined in Database.Ribbit.PostgreSQL

Methods

toRow :: Only a -> [Action]

(ToRow a, ToRow b) => ToRow (a :> b)

Defined in Database.Ribbit.PostgreSQL

Methods

toRow :: (a :> b) -> [Action]