Opaleye.Internal.Table

Documentation

data Table writeFields viewFields

Define a table as follows, where "id", "color", "location", "quantity" and "radius" are the table's fields in Postgres and the types are given in the type signature. The id field is an autoincrementing field (i.e. optional for writes).

data Widget a b c d e = Widget { wid      :: a
                               , color    :: b
                               , location :: c
                               , quantity :: d
                               , radius   :: e }

$(makeAdaptorAndInstance "pWidget" ''Widget)

widgetTable :: Table (Widget (Maybe (Field SqlInt4)) (Field SqlText) (Field SqlText)
                             (Field SqlInt4) (Field SqlFloat8))
                     (Widget (Field SqlInt4) (Field SqlText) (Field SqlText)
                             (Field SqlInt4) (Field SqlFloat8))
widgetTable = table "widgetTable"
                     (pWidget Widget { wid      = tableField "id"
                                     , color    = tableField "color"
                                     , location = tableField "location"
                                     , quantity = tableField "quantity"
                                     , radius   = tableField "radius" })

Constructors

Table String (TableFields writeFields viewFields)

TableWithSchema String String (TableFields writeFields viewFields)

Instances

Profunctor Table

Defined in Opaleye.Internal.Table

Methods

dimap :: (a -> b) -> (c -> d) -> Table b c -> Table a d

lmap :: (a -> b) -> Table b c -> Table a c

rmap :: (b -> c) -> Table a b -> Table a c

(#.) :: forall a b c q. Coercible c b => q b c -> Table a b -> Table a c

(.#) :: forall a b c q. Coercible b a => Table b c -> q a b -> Table a c

Functor (Table a)

Defined in Opaleye.Internal.Table

Methods

fmap :: (a0 -> b) -> Table a a0 -> Table a b

(<$) :: a0 -> Table a b -> Table a a0

tableIdentifier :: Table writeColumns viewColumns -> TableIdentifier

tableColumns :: Table writeColumns viewColumns -> TableFields writeColumns viewColumns

tableProperties :: Table writeColumns viewColumns -> TableFields writeColumns viewColumns

Use tableColumns instead. Will be deprecated soon.

data TableFields writeColumns viewColumns

Constructors

TableFields

Fields

• tablePropertiesWriter :: Writer writeColumns viewColumns
• tablePropertiesView :: View viewColumns

Instances

ProductProfunctor TableFields

Defined in Opaleye.Internal.Table

Methods

purePP :: b -> TableFields a b

(****) :: TableFields a (b -> c) -> TableFields a b -> TableFields a c

empty :: TableFields () ()

(***!) :: TableFields a b -> TableFields a' b' -> TableFields (a, a') (b, b')

Profunctor TableFields

Defined in Opaleye.Internal.Table

Methods

dimap :: (a -> b) -> (c -> d) -> TableFields b c -> TableFields a d

lmap :: (a -> b) -> TableFields b c -> TableFields a c

rmap :: (b -> c) -> TableFields a b -> TableFields a c

(#.) :: forall a b c q. Coercible c b => q b c -> TableFields a b -> TableFields a c

(.#) :: forall a b c q. Coercible b a => TableFields b c -> q a b -> TableFields a c

Applicative (TableFields a)

Defined in Opaleye.Internal.Table

Methods

pure :: a0 -> TableFields a a0

(<*>) :: TableFields a (a0 -> b) -> TableFields a a0 -> TableFields a b

liftA2 :: (a0 -> b -> c) -> TableFields a a0 -> TableFields a b -> TableFields a c

(*>) :: TableFields a a0 -> TableFields a b -> TableFields a b

(<*) :: TableFields a a0 -> TableFields a b -> TableFields a a0

Functor (TableFields a)

Defined in Opaleye.Internal.Table

Methods

fmap :: (a0 -> b) -> TableFields a a0 -> TableFields a b

(<$) :: a0 -> TableFields a b -> TableFields a a0

tableColumnsWriter :: TableFields writeColumns viewColumns -> Writer writeColumns viewColumns

tableColumnsView :: TableFields writeColumns viewColumns -> View viewColumns

newtype View columns

Constructors

View columns

newtype Writer columns dummy

Constructors

Writer (forall f. Functor f => PackMap (f PrimExpr, String) () (f columns) ())

Instances

ProductProfunctor Writer

Defined in Opaleye.Internal.Table

Methods

purePP :: b -> Writer a b

(****) :: Writer a (b -> c) -> Writer a b -> Writer a c

empty :: Writer () ()

(***!) :: Writer a b -> Writer a' b' -> Writer (a, a') (b, b')

Profunctor Writer

Defined in Opaleye.Internal.Table

Methods

dimap :: (a -> b) -> (c -> d) -> Writer b c -> Writer a d

lmap :: (a -> b) -> Writer b c -> Writer a c

rmap :: (b -> c) -> Writer a b -> Writer a c

(#.) :: forall a b c q. Coercible c b => q b c -> Writer a b -> Writer a c

(.#) :: forall a b c q. Coercible b a => Writer b c -> q a b -> Writer a c

Applicative (Writer a)

Defined in Opaleye.Internal.Table

Methods

pure :: a0 -> Writer a a0

(<*>) :: Writer a (a0 -> b) -> Writer a a0 -> Writer a b

liftA2 :: (a0 -> b -> c) -> Writer a a0 -> Writer a b -> Writer a c

(*>) :: Writer a a0 -> Writer a b -> Writer a b

(<*) :: Writer a a0 -> Writer a b -> Writer a a0

Functor (Writer a)

Defined in Opaleye.Internal.Table

Methods

fmap :: (a0 -> b) -> Writer a a0 -> Writer a b

(<$) :: a0 -> Writer a b -> Writer a a0

requiredTableField :: String -> TableFields (Field_ n a) (Field_ n a)

requiredTableField is for fields which are not optional. You must provide them on writes.

optionalTableField :: String -> TableFields (Maybe (Field_ n a)) (Field_ n a)

optionalTableField is for fields that you can omit on writes, such as fields which have defaults or which are SERIAL.

readOnlyTableField :: String -> TableFields () (Field_ n a)

Don't use readOnlyTableField. It will be formally deprecated in a future version. It is broken for updates because it always updates its field with DEFAULT which is very unlikely to be what you want! For more details see https://github.com/tomjaguarpaw/haskell-opaleye/issues/447#issuecomment-685617841.

class InferrableTableField w n r | w -> n, w -> r where

You should not define your own instances of InferrableTableField.

Methods

tableField :: String -> TableFields w (Field_ n r)

Infer either a required (requiredTableField) or optional (optionalTableField) field depending on the write type. It's generally more convenient to use this than required or optional but you do have to provide a type signature instead.

Instances

InferrableTableField (Maybe (Field_ n r)) n r

Equivalent to defining the column with optionalTableField. If the write type is Maybe (Field_ n r) (i.e. DEFAULT can be written to it) then the write type is Field_ n r.

Defined in Opaleye.Internal.Table

Methods

tableField :: String -> TableFields (Maybe (Field_ n r)) (Field_ n r)

InferrableTableField (Field_ n r) n r

Equivalent to defining the column with requiredTableField. If the write type is Field_ n r then the read type is also Field_ n r.

Defined in Opaleye.Internal.Table

Methods

tableField :: String -> TableFields (Field_ n r) (Field_ n r)

queryTable :: Unpackspec viewColumns columns -> Table writeColumns viewColumns -> Tag -> (columns, PrimQuery)

runColumnMaker :: Unpackspec tablecolumns columns -> Tag -> tablecolumns -> (columns, [(Symbol, PrimExpr)])

runWriter :: Writer columns columns' -> columns -> [(PrimExpr, String)]

runWriter' :: Writer columns columns' -> NonEmpty columns -> (NonEmpty [PrimExpr], [String])

newtype Zip a

Constructors

Zip

Fields

• unZip :: NonEmpty [a]

Instances

Monoid (Zip a)

Defined in Opaleye.Internal.Table

Methods

mempty :: Zip a

mappend :: Zip a -> Zip a -> Zip a

mconcat :: [Zip a] -> Zip a

Semigroup (Zip a)

Defined in Opaleye.Internal.Table

Methods

(<>) :: Zip a -> Zip a -> Zip a

sconcat :: NonEmpty (Zip a) -> Zip a

stimes :: Integral b => b -> Zip a -> Zip a

requiredW :: String -> Writer (Field_ n a) (Field_ n a)

optionalW :: String -> Writer (Maybe (Field_ n a)) (Field_ n a)