Join sub-query. Query result is not Maybe.

Join sub-query. Query result is Maybe. The combinations of query and queryMaybe express inner joins, left outer joins, right outer joins, and full outer joins. Here is an example of a right outer join:

  outerJoin = relation $ do
    e <- queryMaybe employee
    d <- query department
    on $ e ?! E.deptId' .=. just (d ! D.deptId')
    return $ (,) |$| e |*| d

Add restriction to last join. Projection type version.

Add restriction to this not aggregated query.

Add GROUP BY term into context and get aggregated projection.

Add restriction to this aggregated query. Aggregated Projection type version.

Specify DISTINCT attribute to query context.

Specify ALL attribute to query context.

Add and assginment.

Direct inner join.

Direct left outer join.

Direct right outer join.

Direct full outer join.

Apply restriction for direct join style.

Restriction predicate function type for direct style join operator, used on predicates of direct join style as follows.

  do xy <- query $
           relX inner relY on' [ x y -> ... ] -- this lambda form has JoinRestriction type
     ...

Relation type with place-holder parameter p and query result type r.

Finalize QuerySimple monad and generate Relation.

Finalize QueryAggregate monad and geneate Relation.

UpdateTarget type with place-holder parameter p and projection record type r.

Finalize Target monad and generate UpdateTarget.

Restriction type with place-holder parameter p and projection record type r.

Finalize Restrict monad and generate Restriction.

Phantom typed projection. Projected into Haskell record type t.

Type tag for flat (not-aggregated) query

Type tag for aggregated query

Type tag for exists predicate

Type tag for window function building

Projection path from type r0 into type r1. This type also indicate key object which type is r1 for record type r0.

Get narrower projection along with projection path.

Compose projection path.

ShowConstantTermsSQL a is implicit rule to derive function to convert from haskell record type a into constant SQL terms.

Generic programming (https://downloads.haskell.org/~ghc/latest/docs/html/users_guide/glasgow_exts.html#generic-programming) with default signature is available for ShowConstantTermsSQL class, so you can make instance like below:

  {-# LANGUAGE DeriveGeneric #-}
  import GHC.Generics (Generic)
  --
  data Foo = Foo { ... } deriving Generic
  instance ShowConstantTermsSQL Foo

Generate polymorphic projection of SQL constant values from Haskell value.

Polymorphic proejction of SQL set value from Haskell list.

Compare operator corresponding SQL = .

Compare operator corresponding SQL < .

Compare operator corresponding SQL <= .

Compare operator corresponding SQL > .

Compare operator corresponding SQL >= .

Compare operator corresponding SQL <> .

Logical operator corresponding SQL AND .

Logical operator corresponding SQL OR .

Binary operator corresponding SQL IN .

Concatinate operator corresponding SQL || .

String-compare operator corresponding SQL LIKE .

String-compare operator corresponding SQL LIKE .

Number operator corresponding SQL + .

Number operator corresponding SQL - .

Number operator corresponding SQL * .

Number operator corresponding SQL /// .

Operator corresponding SQL IS NULL , and extended against record types.

Operator corresponding SQL NOT (... IS NULL) , and extended against record type.

Operator from maybe type using record extended isNull.

Logical operator corresponding SQL NOT .

Logical operator corresponding SQL EXISTS .

Number negate uni-operator corresponding SQL -.

Number fromIntegral uni-operator.

Unsafely show number into string-like type in projections.

Same as caseSearch, but you can write like list casesOrElse clause.

Simple case operator correnponding SQL simple CASE. Like, CASE x WHEN v THEN a WHEN w THEN b ... ELSE c END

Aggregation function COUNT.

Aggregation function SUM.

Aggregation function AVG.

Aggregation function MAX.

Aggregation function MIN.

Aggregation function EVERY.

Aggregation function ANY.

Aggregation function SOME.

Operator to make window function result projection using built Window monad.

RANK() term.

DENSE_RANK() term.

ROW_NUMBER() term.

PERCENT_RANK() term.

CUME_DIST() term.

Union of two relations.

Subtraction of two relations.

Intersection of two relations.

Cast projection phantom type into Maybe.

Compose nested Maybe phantom type on projection.

Get narrower projection along with projection path Maybe phantom functor is map-ed.

Get narrower projection along with projection path and project into result projection type. Source record Maybe phantom functor and projection path leaf Maybe functor are join-ed.

Compose projection path. Maybe phantom functor is map-ed.

Compose projection path. Maybe phantom functors are join-ed like >=>.

Number operator corresponding SQL + .

Number negate uni-operator corresponding SQL -.

Aggregation function SUM.

Provide scoped placeholder and return its parameter object. Monadic version.

Join sub-query with place-holder parameter p. query result is not Maybe.

Direct left outer join with place-holder parameters.

Finalize QuerySimple monad and generate Relation with place-holder parameter p.

Finalize Target monad and generate UpdateTarget with place-holder parameter p.

Finalize Restrict monad and generate Restriction with place-holder parameter p

Union of two relations with place-holder parameters.

Specify tuple like record constructors which are allowed to define ProjectableFunctor.

Weaken functor on projections.

Weaken applicative functor on projections.

Binary operator the same as projectZip.

From Relation into typed Query.

Make typed Insert from Table and columns selector Pi.

Make typed InsertQuery from columns selector Table, Pi and Relation.

Make typed Update using defaultConfig, Table and UpdateTarget.

Make typed Delete from Table and Restriction.

Make typed KeyUpdate from Table and key columns selector Pi.

Table type inferred Insert.

Table type inferred InsertQuery.

Make typed Update from defaultConfig, derived table and AssignStatement

Make typed Delete from defaultConfig, derived table and RestrictContext

FromSql q a is implicit rule to derive RecordFromSql q a record parser function against type a.

Generic programming (https://downloads.haskell.org/~ghc/latest/docs/html/users_guide/glasgow_exts.html#generic-programming) with default signature is available for FromSql class, so you can make instance like below:

  {-# LANGUAGE DeriveGeneric #-}
  import GHC.Generics (Generic)
  import Database.HDBC (SqlValue)
  --
  data Foo = Foo { ... } deriving Generic
  instance FromSql SqlValue Foo

ToSql q a is implicit rule to derive RecordToSql q a record printer function for type a.

Generic programming (https://downloads.haskell.org/~ghc/latest/docs/html/users_guide/glasgow_exts.html#generic-programming) with default signature is available for ToSql class, so you can make instance like below:

  {-# LANGUAGE DeriveGeneric #-}
  import GHC.Generics (Generic)
  import Database.HDBC (SqlValue)
  --
  data Foo = Foo { ... } deriving Generic
  instance ToSql SqlValue Foo

To make instances of ToSql manually, ToSql q a and RecordToSql 'q a are composable with monadic context. When, you have data constructor and objects like below.

  data MyRecord = MyRecord Foo Bar Baz

  instance ToSql SqlValue Foo where
    ...
  instance ToSql SqlValue Bar where
    ...
  instance ToSql SqlValue Baz where
    ...

You can get composed ToSql implicit rule like below.

  instance ToSql SqlValue MyRecord where
    recordToSql =
    recordToSql = wrapToSql $ \ (MyRecord x y z) -> do
      putRecord x
      putRecord y
      putRecord z

RecordFromSql q a is data-type wrapping function to convert from list of database value type (to receive from database) [q] into Haskell type a

This structure is similar to parser. While running RecordFromSql behavior is the same as non-fail-able parser which parse list of database value type [q] stream.

So, RecordFromSql q is Monad and Applicative instance like parser monad. When, you have data constructor and objects like below.

  data MyRecord = MyRecord Foo Bar Baz

  foo :: RecordFromSql SqlValue Foo
  foo =  ...
  bar :: RecordFromSql SqlValue Bar
  bar =  ...
  baz :: RecordFromSql SqlValue Bar
  baz =  ...

You can get composed RecordFromSql like below.

  myRecord :: RecordFromSql SqlValue MyRecord
  myRecord =  MyRecord <$> foo <*> bar <*> baz

RecordToSql q a is data-type wrapping function to convert from Haskell type a into list of database value type (to send to database) [q].

This structure is similar to printer. While running RecordToSql behavior is the same as list printer. which appends list of database value type [q] stream.

Generalized prepare inferred from UntypeableNoFetch instance.

Typed operation to bind parameters. Inferred RecordToSql is used.

Use executeBound instead of this. WARNING! This name will be used for executePrepared function in future release.

Use executeBoundNoFetch instead of this. WARNING! This name will be used for runPreparedNoFetch function in future release.

Same as prepare.

Fetch a record.

Prepare SQL, bind parameters, execute statement and lazily fetch all records.

Strict version of runQuery.

Same as prepare.

Prepare insert statement, bind parameters, execute statement and get execution result.

Same as prepare.

Prepare insert statement, bind parameters, execute statement and get execution result.

Same as prepare.

Prepare update statement, bind parameters, execute statement and get execution result.

Same as prepare.

Prepare delete statement, bind parameters, execute statement and get execution result.

Same as prepare.

Typed operation to bind parameters for PreparedKeyUpdate type.

Prepare insert statement, bind parameters, execute statement and get execution result.