vj:S      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQR Safe-Infered(Phantom type for a SET% operation on an entity of the given  type (see : and '(=.)'). Phantom type used by !, " and #. ((Internal) Phantom type used to process @ (see ). Exception thrown whenever   is used to create an ON  clause but no matching JOIN is found. <(Internal) Functions that operate on types (that should be)  of kind .  (Internal)  smartJoin a b is a JOIN of the correct kind. (Internal) Reify a JoinKind from a JOIN. This  function is non-strict. (Internal) A kind of JOIN. FULL OUTER JOIN RIGHT OUTER JOIN LEFT OUTER JOIN  CROSS JOIN  INNER JOINData type that represents a FULL OUTER JOIN (see  for an example). Data type that represents a RIGHT OUTER JOIN (see  for an example). Data type that represents a LEFT OUTER JOIN. For example,    select $  from $ (person  pet) ->  ... is translated into   SELECT ... ! FROM Person LEFT OUTER JOIN Pet  ... Data type that represents a  CROSS JOIN (see  for an example). Data type that represents an  INNER JOIN (see  for an example). <A single value (as opposed to a whole entity). You may use  (&) or (') to get a  from an S. "Finally tagless representation of  esqueleto's EDSL. (Internal) Start a @ query with an entity. @  does two kinds of magic using ,  and  : 8 The simple but tedious magic of allowing tuples to be  used. & The more advanced magic of creating JOINs. The  JOIN1 is processed from right to left. The rightmost  entity of the JOIN is created with . Each  JOIN( step is then translated into a call to .  In the end,  is called to materialize the  JOIN. (Internal) Same as , but entity may be missing. (Internal) Do a JOIN. (Internal) Finish a JOIN. WHERE clause: restrict the query' s result. ON clause: restrict the a JOIN's result. The ON  clause will be applied to the last JOIN that does not  have an ON clause yet. If there are no JOIN s without  ON! clauses (either because you didn' t do any JOIN, or  because all JOINs already have their own ON clauses), a  runtime exception  is  thrown. ON! clauses are optional when doing JOINs. %On the simple case of doing just one JOIN, for example    select $  from $ (foo  bar) -> do ) on (foo ^. FooId ==. bar ^. BarFooId)  ... there'2s no ambiguity and the rules above just mean that  you're allowed to call   only once (as in SQL). If you  have many joins, then the  s are applied on the reverse  order that the JOINs appear. For example:    select $  from $ (foo  bar  baz) -> do ) on (baz ^. BazId ==. bar ^. BarBazId) ) on (foo ^. FooId ==. bar ^. BarFooId)  ...  The order is reversed$ in order to improve composability.  For example, consider query1 and query2 below:    let query1 =  from $ (foo  bar) -> do / on (foo ^. FooId ==. bar ^. BarFooId)   query2 =  from $ (mbaz  quux) -> do ( return (mbaz ?. BazName, quux)  test1 = (,)  $ query1  * query2  test2 = flip (,)  $ query2  * query1 &If the order was *not* reversed, then test2 would be  broken: query1's   would refer to query2's  . !ORDER BY clause. See also " and #. "-Ascending order of this field or expression. #.Descending order of this field or expression. $Execute a subquery SELECT in an expression. %Execute a subquery SELECT_DISTINCT in an expression. &Project a field of an entity. '/Project a field of an entity that may be null. (6Lift a constant value from Haskell-land to the query. )IS NULL comparison. * Analog to T, promotes a value of type typ into one  of type  Maybe typ. It should hold that val . Just ===  just . val. +NULL value. ,COUNT(*) value. :SET clause used on UPDATEs. Note that while it's not ( a type error to use this function on a SELECT , it will + most certainly result in a runtime error. @FROM% clause: bring an entity into scope. The following types implement @:  Expr (Entity val)+, which brings a single entity into scope. ( Tuples of any other types supported by @ . Calling  @' multiple times is the same as calling @ a ! single time and using a tuple. Note that using @% for the same entity twice does work ) and corresponds to a self-join. You don't even need to use  two different calls to @, you may use a tuple. X  !"#$%&'()*+,-./0123456789:;<=>?@UVWXYZ[\]^_`abcdefghijkA  !"#$%&'()*+,-./0123456789:;<=>?@A !"#$%&'()*+,-./0123456789:;<=>?@ % % !"#$%&'()*+,-./0123456789:;<=>?@UVWXYZ[\]^_`abcdefghijk Safe-Infered F"An expression on the SQL backend. GSQL backend for  esqueleto using l. H(Internal) Execute an  esqueleto SELECT G inside   persistent's l monad. I Execute an  esqueleto SELECT query inside  persistent's  l monad and return a m of rows. J Execute an  esqueleto SELECT query inside  persistent's  l" monad and return a list of rows. K Execute an  esqueleto SELECT DISTINCT query inside   persistent's l monad and return a m of  rows. L Execute an  esqueleto SELECT DISTINCT query inside   persistent's l" monad and return a list of rows. MRuns a m of rows. N(Internal) Execute an  esqueleto statement inside   persistent's l monad. O Execute an  esqueleto DELETE query inside  persistent's  l/ monad. Note that currently there are no type 3 checks for statements that should not appear on a DELETE  query. Example of usage:   delete $  from $ appointment -> ( where_ (appointment ^. AppointmentDate < . val now) P Execute an  esqueleto UPDATE query inside  persistent's  l/ monad. Note that currently there are no type 3 checks for statements that should not appear on a UPDATE  query. Example of usage:   update $ p -> do = set p [ PersonAge =. just (val thisYear) -. p ^. PersonBorn ] " where_ $ isNull (p ^. PersonAge) QPretty prints a G into a SQL query. "ABCDEFGHIJKLMNOPQnopqrstuvwxyz{|}~ABCDEFGHIJKLMNOPQGFJILKHMNOPQAEDCBAEDCBFGHIJKLMNOPQnopqrstuvwxyz{|}~ Safe-InferedR Synonym for  that does not  clash with  esqueleto's O. RlS !"#$%&'()*+,-./0123456789:;<=>?@FGIJKLOPR; !"#$%&'()*+,-./0123456789:;<=>?@GFJLIKOPRR      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklPmnopqrstuvwxyz{|}~PQLPPPPPPPPPPPPPPPPPPPPmPmnPPPQPQPQPQPQPQPQPQPQPQPQPQPQPQPQPQPQPQPQPQPQPQPQPQPQPQPQPQPQPQPQPQPQPQPQPQPQPQPQPQPQPQPQPQPQPQPQPQPQPQPQPQPQPQPQPQPQPQPQPQPQPQPQPQPQPQPQPQPQPQRPQPQPQPQPQPQPQPQPQPQPQPQPQPQPQPQPQPQPQPQPQPQPQPQPQPQPQPQPQ esqueleto-0.2$Database.Esqueleto.Internal.LanguageDatabase.Esqueleto.Internal.SqlDatabase.EsqueletoUpdateOrderByPreprocessedFrom$OnClauseWithoutMatchingJoinException IsJoinKind smartJoin reifyJoinKindJoinKindFullOuterJoinKindRightOuterJoinKindLeftOuterJoinKind CrossJoinKind InnerJoinKind FullOuterJoinRightOuterJoin LeftOuterJoin CrossJoin InnerJoinValue Esqueleto fromStartfromStartMaybefromJoin fromFinishwhere_onorderByascdesc sub_selectsub_selectDistinct^.?.val isNothingjustnothing countRowsnot_==.>=.>.<=.<.!=.&&.||.+.-./.*.set=.+=.-=.*=./=.fromModeUPDATEDELETESELECT_DISTINCTSELECTSqlExprSqlQueryrawSelectSource selectSourceselectselectDistinctSourceselectDistinct runSource rawExecutedeleteupdatetoRawSql deleteKeypersistent-1.0.1Database.Persist.StoreEntitybase Data.MaybeJust$$fFromPreprocessqueryexprbackendjoin$$fFromPreprocessqueryexprbackendexpr%$fFromPreprocessqueryexprbackendexpr0$fFromqueryexprbackend(,,,,,,,)$fFromqueryexprbackend(,,,,,,)$fFromqueryexprbackend(,,,,,)$fFromqueryexprbackend(,,,,)$fFromqueryexprbackend(,,,)$fFromqueryexprbackend(,,)$fFromqueryexprbackend(,)#$fFromqueryexprbackendFullOuterJoin$$fFromqueryexprbackendRightOuterJoin#$fFromqueryexprbackendLeftOuterJoin$fFromqueryexprbackendCrossJoin$fFromqueryexprbackendInnerJoin$fFromqueryexprbackendexpr$fFromqueryexprbackendexpr0/$fExceptionOnClauseWithoutMatchingJoinException$fIsJoinKindFullOuterJoin$fIsJoinKindRightOuterJoin$fIsJoinKindLeftOuterJoin$fIsJoinKindCrossJoin$fIsJoinKindInnerJoinDatabase.Persist.GenericSql.Raw SqlPersistconduit-0.5.2.3Data.Conduit.InternalSource$fSqlSelect(,,,,,,,)(,,,,,,,)$fSqlSelect(,,,,,,)(,,,,,,)$fSqlSelect(,,,,,)(,,,,,)$fSqlSelect(,,,,)(,,,,)$fSqlSelect(,,,)(,,,)$fSqlSelect(,,)(,,)$fSqlSelect(,)(,)$fSqlSelectSqlExprValue$fSqlSelectSqlExprMaybe$fSqlSelectSqlExprEntity$fSqlSelect()()$$fEsqueletoSqlQuerySqlExprSqlPersist$fMonoidWhereClause$fMonoidSideData$fApplicativeSqlQuery$fMonadSqlQuery$fFunctorSqlQueryDatabase.Persist.GenericSqlrawSql runSqlConn runSqlPoolConnectionPoolunSingleSingleRawSql%Database.Persist.GenericSql.MigrationrollbackcommitmigraterunMigrationUnsaferunMigrationSilent runMigration getMigrationprintMigrationparseMigration'parseMigration Migration unSqlPersist$Database.Persist.GenericSql.Internal Connection Statement mapToJSON listToJSON checkUniquegetJust belongsToJust belongsTo getByValueinsertBy getPersistMap PersistErrorPersistMarshalErrorPersistInvalidFieldPersistForeignConstraintUnmetPersistMongoDBErrorPersistMongoDBUnsupportedPersistExceptionZT PersistTextPersistByteString PersistInt64 PersistDouble PersistBool PersistDayPersistTimeOfDayPersistUTCTimePersistZonedTime PersistNull PersistList PersistMapPersistObjectId PersistValue SqlStringSqlInt32SqlInt64SqlRealSqlBoolSqlDaySqlTime SqlDayTimeSqlDayTimeZonedSqlBlobSqlOtherSqlType isNullablesqlTypefromPersistValuetoPersistValue PersistFieldpersistIdFieldpersistUniqueKeyspersistUniqueToValuespersistUniqueToFieldNames halfDefinedfromPersistValuestoPersistFields entityDefpersistFieldDefUniquePersistEntityBackend EntityField PersistEntitySomePersistFieldunKeyKey entityVal entityKeygetreplacerepsert insertKeyinsert PersistStore insertUniquedeleteBygetBy PersistUniqueEqNeGtLtGeLeInNotInBackendSpecificFilter PersistFilter deleteCascade DeleteCascaderunPoolcreatePoolConfigapplyEnv loadConfigPersistConfigPoolPersistConfigBackend PersistConfig