B#r      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~None%      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~NoneF%(Internal) Class that implements the JOIN h magic  (see $). +(Internal) Class that implements the tuple h magic (see  $). Phantom type used by  insertSelect. 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 h (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  ...  See also: h. Data type that represents a  CROSS JOIN (see  for an example). Data type that represents an  INNER JOIN (see  for an example). IA class of things that can be converted into a list of SomeValue. It has J instances for tuples and is the reason why groupBy can take tuples, like  6groupBy (foo ^. FooId, foo ^. FooName, foo ^. FooType). A wrapper type for for any expr (Value a) for all a. A list of single values. There's a limited set of functions + able to work with this data type (such as X,  Z, [ and ]). !<A single value (as opposed to a whole entity). You may use  (4) or (5) to get a ! from an $. #"Finally tagless representation of  esqueleto's EDSL. $(Internal) Start a h query with an entity. h  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  . *GROUP BY* clause. You can enclose multiple columns  in a tuple.    select $ from \(foo `` bar) -> do ) on (foo ^. FooBarId ==. bar ^. BarId) * groupBy (bar ^. BarId, bar ^. BarName) 4 return (bar ^. BarId, bar ^. BarName, countRows) >With groupBy you can sort by aggregate functions, like so (we  used let to restrict the more general ; to  SqlExpr (Value Int) to avoid ambiguity):   r <- select $ from \(foo `` bar) -> do ) on (foo ^. FooBarId ==. bar ^. BarId)  groupBy $ bar ^. BarName  let countRows' = countRows  orderBy [asc countRows'] $ return (bar ^. BarName, countRows')  forM_ r $ \$((Value name), (Value count)) -> do  print name  print (count :: Int) +ORDER BY clause. See also , and -. ,-Ascending order of this field or expression. -.Descending order of this field or expression. .LIMIT&. Limit the number of returned rows. /OFFSET. Usually used with .. 0ORDER BY random() clause.  Since: 1.3.10 1HAVING.  Since: 1.2.2 2Execute a subquery SELECT in an expression. Returns a . simple value so should be used only when the SELECT query ' is guaranteed to return just one row. 3Same as 2 but using SELECT DISTINCT. 4Project a field of an entity. 5/Project a field of an entity that may be null. 66Lift a constant value from Haskell-land to the query. 7IS NULL comparison. 8 Analogous to , promotes a value of type typ into  one of type  Maybe typ. It should hold that  val . Just  === just . val. 9NULL value. : Join nested s in a ! into one. This is useful when 1 calling aggregate functions on nullable fields. ;COUNT(*) value. <COUNT. RCOALESCE0 function. Evaluates the arguments in order and = returns the value of the first non-NULL expression, or NULL ; (Nothing) otherwise. Some RDBMSs (such as SQLite) require 9 at least two arguments; please refer to the appropriate  documentation.  Since: 1.4.3 SLike coalesce&, but takes a non-nullable expression < placed at the end of the expression list, which guarantees  a non-NULL result.  Since: 1.4.3 TLIKE operator. U The string U. May be useful while using T and  concatenation (V or W, depending on your ; database). Note that you always to type the parenthesis,  for example:   name ``'like'`` (%) ++. val John ++. (%) VThe CONCAT$ function with a variable number of 1 parameters. Supported by MySQL and PostgreSQL. WThe ||, string concatenation operator (named after  Haskell's % in order to avoid naming clash with E). % Supported by SQLite and PostgreSQL. XExecute a subquery SELECT in an expression. Returns a  list of values. YSame as sublist_select but using SELECT DISTINCT. Z>Lift a list of constant value from Haskell-land to the query. [IN operator. \NOT IN operator. ]EXISTS operator. For example:   select $  from $ \ person -> do  where_ $ exists $  from $ \ post -> do C where_ (post ^. BlogPostAuthorId ==. person ^. PersonId)  return person ^ NOT EXISTS operator. _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. eApply a ' constructor to  expr Value arguments. f Apply extra  expr Value arguments to a ' constructor g Unwrap a !.  Since: 1.4.1 hFROM$ clause: bring entities into scope. ;This function internally uses two type classes in order to > provide some flexibility of how you may call it. Internally = we refer to these type classes as the two different magics. &The innermost magic allows you to use from with the  following types:  expr (Entity val)$, which brings a single entity into  scope.  expr (Maybe (Entity val)), which brings a single entity  that may be NULL into scope. Used for  OUTER JOINs.  A JOIN1 of any other two types allowed by the innermost  magic, where a JOIN may be an , a , a  , a , or a .  The JOINs( have right fixity, the same as in SQL. &The outermost magic allows you to use from on any tuples of @ types supported by innermost magic (and also tuples of tuples,  and so on), up to 8-tuples. Note that using from) for the same entity twice does work and % corresponds to a self-join. You don't even need to use two  different calls to from, you may use a JOIN or a tuple. ,The following are valid examples of uses of from (the types = of the arguments of the lambda are inside square brackets):    from $ \person -> ...  from $ \(person, blogPost) -> ...  from $ \(p `` mb) -> ...  from $ \(p1 `` f `` p2) -> ...  from $ \((p1 `` f) `` p2) -> ... 5The types of the arguments to the lambdas above are,  respectively:    person % :: ( Esqueleto query expr backend  , PersistEntity Person . , PersistEntityBackend Person ~ backend  ) => expr (Entity Person)  (person, blogPost) > :: (...) => (expr (Entity Person), expr (Entity BlogPost))  (p `` mb) Q :: (...) => InnerJoin (expr (Entity Person)) (expr (Maybe (Entity BlogPost)))  (p1 `` f `` p2)  :: (...) => InnerJoin ( (expr (Entity Person)) 3 (InnerJoin (expr (Entity Follow)) 4 (expr (Entity Person)))  ((p1 `` f) `` p2) ::  :: (...) => InnerJoin 3 (InnerJoin (expr (Entity Person)) 4 (expr (Entity Follow))) ( (expr (Entity Person)) 5Note that some backends may not support all kinds of JOINs. > For example, when using the SQL backend with SQLite, it will ? not accept the last example above (which is associated to the : left, instead of being to the right) and will not accept  s or s.  Since: 1.4.4   !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghi  !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghi#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefh!"g    4   !"#C$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghNone3i1(Internal) Class for mapping results coming from y  into actual results. This looks very similar to RawSql, and it is! However, 7 there are some crucial differences and ultimately they're  different classes. j!Creates the variable part of the SELECT query and  returns the list of s that will be given to  . k)Number of columns that will be consumed. l2Transform a row of the result into the data type. mCreate  INSERT INTO clause instead. n,(Internal) Mode of query being converted by . on should be either s or r. Phantom type used to mark a  INSERT INTO query. u"An expression on the SQL backend. v2Information needed to escape and use identifiers. w;List of identifiers already in use and supply of temporary  identifiers. !Identifier used for table names. A LIMIT clause. A ORDER BY clause. A HAVING cause. A GROUP BY clause.  A complete WHERE clause.  A part of a SET clause.  A part of a FROM clause. Side data written by y. xConstraint synonym for  persistent entities whose backend  is . ySQL backend for  esqueleto using . Collect s on s. Returns the first  unmatched )s data on error. Returns a list without   OnClauses on success. Create a fresh . If possible, use the given  I. Use an identifier. {1(Internal) Create a custom binary operator. You should  not3 use this function directly since its type is very 9 general, you should always use it with an explicit type  signature. For example:   I (==.) :: SqlExpr (Value a) -> SqlExpr (Value a) -> SqlExpr (Value Bool)  (==.) = unsafeSqlBinOp  =  ?In the example above, we constraint the arguments to be of the < same type and constraint the result to be a boolean value. |3(Internal) A raw SQL value. The same warning from  {# applies to this function as well. }=(Internal) A raw SQL function. Once again, the same warning  from {# applies to this function as well. ~H(Internal) An unsafe SQL function to extract a subfield from a compound  field, e.g. datetime. See { for warnings. Since: 1.3.6. (Internal) Coerce a value' s type from 'SqlExpr (Value a)' to  'SqlExpr (Value b)'. You should not use this function  unless you know what you' re doing! (Internal) Coerce a value' s type from 'SqlExpr (ValueList  a)' to 'SqlExpr (Value a)'#. Does not work with empty lists. (Internal) Execute an  esqueleto SELECT y inside   persistent's  monad.  Execute an  esqueleto SELECT query inside  persistent's   monad and return a  of rows.  Execute an  esqueleto SELECT query inside  persistent's  " monad and return a list of rows. We' ve seen that h% has some magic about which kinds of ( things you may bring into scope. This  function also @ has some magic for which kinds of things you may bring back to  Haskell-land by using SqlQuery's return:  You may return a  SqlExpr ($ v) for an entity v  (i.e., like the *$ in SQL), which is then returned to  Haskell-land as just Entity v.  You may return a SqlExpr (Maybe (Entity v)) for an entity  v that may be NULL, which is then returned to  Haskell-land as Maybe (Entity v) . Used for  OUTER JOINs.  You may return a  SqlExpr (! t) for a value t ! (i.e., a single column), where t is any instance of  ',, which is then returned to Haskell-land as  Value t. You may use Value to return projections of an  Entity (see (4) and (5)) or to return any other ' value calculated on the query (e.g., ; or  2). The  SqlSelect a r( class has functional dependencies that * allow type information to flow both from a to r and ! vice-versa. This means that you'll almost never have to give  any type signatures for  esqueleto queries. For example, the  query select $ from $ \ p -> return p alone is ambiguous, but  in the context of    do ps < - select $  from $ \p ->  return p : liftIO $ mapM_ (putStrLn . personName . entityVal) ps &we are able to infer from that single personName . entityVal  function composition that the p inside the query is of type  SqlExpr (Entity Person).  Execute an  esqueleto SELECT DISTINCT query inside   persistent's  monad and return a  of  rows.  Execute an  esqueleto SELECT DISTINCT query inside   persistent's " monad and return a list of rows. (Internal) Run a  of rows. (Internal) Execute an  esqueleto statement inside   persistent's  monad.  Execute an  esqueleto DELETE query inside  persistent's  / 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) Unlike !, there is a useful way of using  that @ will lead to type ambiguities. If you want to delete all rows  (i.e., no ( clause), you'!ll have to use a type signature:   delete $  from $ \1(appointment :: SqlExpr (Entity Appointment)) ->  return () Same as +, but returns the number of rows affected.  Execute an  esqueleto UPDATE query inside  persistent's  / 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_ $ isNothing (p ^. PersonAge) Same as +, but returns the number of rows affected. (Internal) Pretty prints a y into a SQL query.  Note: if you'2re curious about the SQL query being generated by   esqueleto4, instead of manually using this function (which is > possible but tedious), you may just turn on query logging of   persistent.  Insert a ' for every selected value.  Insert a '" for every unique selected value. =You may return tuples (up to 16-tuples) and tuples of tuples  from a  query. <You may return any single value (i.e. a single column) from  a  query. You may return a possibly-NULL $ from a  query. You may return an $ from a  query. Not useful for , but used for  and .  INSERT INTO hack. ijklmnopqrstuvw     xyz{|}~ !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcde&ijklmnopqrstuvwxyz{|}~&yux{|}~tnsrqpowzvijklmijklmnsrqpotu vw     xyz{|}~ !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdeNone%valkey i = val (Key (PersistInt64 i))  ( /https://github.com/meteficha/esqueleto/issues/9). valJ is like val% but for something that is already a Value . The use & case it was written for was, given a Value lift the Key for that Value N into the query expression in a type safe way. However, the implementation is & more generic than that so we call it valJ. FIts important to note that the input entity and the output entity are B constrained to be the same by the type signature on the function  ( 1https://github.com/prowdsponsor/esqueleto/pull/69).  Since: 1.4.2  Synonym for  that does not  clash with  esqueleto's .       !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ !"#()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghuxyc#()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefh!"g yuxf        !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,,-.-/-0-1-1232425262728292:2;2<2=2>2?2@2A2B2C2D2E2F2G2H2I2J2J2K2L2M2M2N2O2O2P2Q2R2S2T2U2V2W2X2Y2Z2[2\2\2]2^2_2`2a2b2c2d2d2e2f2g2g2h2i2j2k2l2l2m2n2o2o2p2q2r2s2t2u2v2w2x2x2y2z2{2|2}2~222222222222222222222222222222222222222222222222)2u      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefgesqueleto-2.1.1$Database.Esqueleto.Internal.LanguageDatabase.Esqueleto.Internal.SqlDatabase.Esqueleto,Database.Esqueleto.Internal.PersistentImportDatabase.Persist.StoredeleteFromPreprocessFrom InsertionUpdateOrderByPreprocessedFrom$OnClauseWithoutMatchingJoinException IsJoinKind smartJoin reifyJoinKindJoinKindFullOuterJoinKindRightOuterJoinKindLeftOuterJoinKind CrossJoinKind InnerJoinKind FullOuterJoinRightOuterJoin LeftOuterJoin CrossJoin InnerJoin ToSomeValues toSomeValues SomeValue ValueListValue Esqueleto fromStartfromStartMaybefromJoin fromFinishwhere_ongroupByorderByascdesclimitoffsetrandhaving sub_selectsub_selectDistinct^.?.val isNothingjustnothingjoinV countRowscountnot_==.>=.>.<=.<.!=.&&.||.+.-./.*.random_round_ceiling_floor_sum_min_max_avg_coalescecoalesceDefaultlike%concat_++.subList_selectsubList_selectDistinctvalListin_notInexists notExistsset=.+=.-=.*=./=.<#<&>unValuefrom SqlSelect sqlSelectColssqlSelectColCountsqlSelectProcessRow sqlInsertIntoMode INSERT_INTOUPDATEDELETESELECT_DISTINCTSELECTUnsafeSqlFunctionArgumentSqlExpr IdentInfo IdentState SqlEntitySqlQueryinitialIdentStateunsafeSqlBinOpunsafeSqlValueunsafeSqlFunctionunsafeSqlExtractSubFieldveryUnsafeCoerceSqlExprValue veryUnsafeCoerceSqlExprValueListrawSelectSource selectSourceselectselectDistinctSourceselectDistinct runSource rawEsqueleto deleteCountupdate updateCounttoRawSql insertSelectinsertSelectDistinctvalkeyvalJ deleteKeypersistent-2.1.0.2(Database.Persist.Sql.Orphan.PersistStoreunSqlBackendKey SqlBackendKeyDatabase.Persist.SqltransactionUndotransactionSave(Database.Persist.Sql.Orphan.PersistQuerydecorateSQLWithLimitOffset fromSqlKeytoSqlKey withRawQueryDatabase.Persist.Sql.MigrationmigraterunMigrationUnsaferunMigrationSilent runMigration getMigrationprintMigrationparseMigration'parseMigrationDatabase.Persist.Sql.Runclose' withSqlConn askLogFunc createSqlPool withSqlPoolrunSqlPersistMPoolrunSqlPersistM runSqlConn runSqlPoolDatabase.Persist.Sql.RawrawSql getStmtConnrawExecuteCount rawExecute rawQueryResrawQueryDatabase.Persist.Sql.ClassrawSqlProcessRowrawSqlColCountReason rawSqlColsRawSqlsqlTypePersistFieldSqlDatabase.Persist toJsonTextDatabase.Persist.Sql.Internal mkColumnsdefaultAttributeDatabase.Persist.Sql.Types ISRSingle ISRInsertGet ISRManyKeysInsertSqlResult Connection connLogFuncconnLimitOffset connRDBMS connNoLimitconnEscapeName connRollback connCommit connBeginconnMigrateSql connClose connStmtMap connInsertSql connPrepare SqlBackendLogFunc stmtQuery stmtExecute stmtReset stmtFinalize Statement cReferencecMaxLencDefaultConstraintNamecDefaultcSqlTypecNullcNameColumnStatementAlreadyFinalizedCouldn'tGetSQLConnectionPersistentSqlException SqlPersistT SqlPersist SqlPersistMSqlCautiousMigration MigrationConnectionPoolunSingleSingle$Database.Persist.Class.PersistUnique checkUnique replaceUnique getByValue onlyUniqueinsertByupsert insertUniquedeleteBygetBy PersistUnique$Database.Persist.Class.DeleteCascade deleteCascade DeleteCascade#Database.Persist.Class.PersistQuery selectKeys#Database.Persist.Class.PersistStore belongsToJust belongsTogetJust liftPersistpersistBackendHasPersistBackendfromBackendKey toBackendKey ToBackendKey updateGetreplacerepsert insertKey insertMany_ insertManyinsert_insertget BackendKey PersistStore$Database.Persist.Class.PersistEntityentityIdFromJSONentityIdToJSONkeyValueEntityFromJSONkeyValueEntityToJSON fieldLenspersistUniqueToValuespersistUniqueToFieldNamespersistUniqueKeysfromPersistValuestoPersistFieldspersistFieldDef entityDefpersistIdField keyFromValues keyToValuesUnique EntityFieldKeyPersistEntityBackend PersistEntityBackendSpecificUpdate entityVal entityKeyEntity#Database.Persist.Class.PersistFieldfromPersistValuetoPersistValue PersistFieldSomePersistFieldDatabase.Persist.Types.BasefromPersistValueTexttoEmbedFieldDeftoEmbedEntityDef entityPrimaryActiveInactive CheckmarkNullable NotNullable IsNullable ByMaybeAttrByNullableAttr WhyNullable entitySum entityExtra entityDerivesentityForeigns entityUniques entityFields entityAttrsentityIdentityDB entityHaskell EntityDef ExtraLine unHaskellName HaskellNameunDBNameDBNameAttr FTTypeConFTAppFTList FieldTypefieldReference fieldStrict fieldAttrs fieldSqlType fieldTypefieldDB fieldHaskellFieldDef NoReference ForeignRefEmbedRef CompositeRef ReferenceDefembeddedFieldsembeddedHaskellEmbedEntityDef emFieldEmbed emFieldDB EmbedFieldDef uniqueAttrs uniqueFields uniqueDBName uniqueHaskell UniqueDefcompositeAttrscompositeFields CompositeDefForeignFieldDefforeignNullable foreignAttrs foreignFieldsforeignConstraintNameDBNameforeignConstraintNameHaskellforeignRefTableDBNameforeignRefTableHaskell ForeignDef PersistErrorPersistMarshalErrorPersistInvalidFieldPersistForeignConstraintUnmetPersistMongoDBErrorPersistMongoDBUnsupportedPersistException PersistTextPersistByteString PersistInt64 PersistDoublePersistRational PersistBool PersistDayPersistTimeOfDayPersistUTCTime PersistNull PersistList PersistMapPersistObjectIdPersistDbSpecific PersistValue SqlStringSqlInt32SqlInt64SqlReal SqlNumericSqlBoolSqlDaySqlTime SqlDayTimeSqlBlobSqlOtherSqlTypeEqNeGtLtGeLeInNotIn PersistFilter KeyNotFound UpsertErrorUpdateExceptionOnlyUniqueExceptionAssignAddSubtractMultiplyDivide PersistUpdate$Database.Persist.Class.PersistConfigrunPoolcreatePoolConfigapplyEnv loadConfigPersistConfigPoolPersistConfigBackend PersistConfigbase Data.MaybeJustMaybeGHC.Base++$fFunctorValuefromPreprocessfrom_$$fFromPreprocessqueryexprbackendjoin$$fFromPreprocessqueryexprbackendexpr%$fFromPreprocessqueryexprbackendexpr0$fFromqueryexprbackend(,,,,,,,)$fFromqueryexprbackend(,,,,,,)$fFromqueryexprbackend(,,,,,)$fFromqueryexprbackend(,,,,)$fFromqueryexprbackend(,,,)$fFromqueryexprbackend(,,)$fFromqueryexprbackend(,)#$fFromqueryexprbackendFullOuterJoin$$fFromqueryexprbackendRightOuterJoin#$fFromqueryexprbackendLeftOuterJoin$fFromqueryexprbackendCrossJoin$fFromqueryexprbackendInnerJoin$fFromqueryexprbackendexpr$fFromqueryexprbackendexpr0/$fExceptionOnClauseWithoutMatchingJoinException$fIsJoinKindFullOuterJoin$fIsJoinKindRightOuterJoin$fIsJoinKindLeftOuterJoin$fIsJoinKindCrossJoin$fIsJoinKindInnerJoin$fToSomeValuesexpr(,,,,,,,)$fToSomeValuesexpr(,,,,,,)$fToSomeValuesexpr(,,,,,)$fToSomeValuesexpr(,,,,)$fToSomeValuesexpr(,,,)$fToSomeValuesexpr(,,)$fToSomeValuesexpr(,) InsertFinalIdent LimitClause OrderByClause HavingClause GroupByClause WhereClause SetClause FromClauseSideDatacollectOnClausesOnClauseFromJoin newIdentForuseIdent conduit-1.2.1Data.Conduit.Internal.ConduitSource$fSqlSelect(,)(,)$fSqlSelectSqlExprValue$fSqlSelectSqlExprMaybe$fSqlSelectSqlExprEntity$fSqlSelect()()$fSqlSelectSqlExprInsertFinal toArgList OrderByTypeDESCASC NeedParensNeverParens EInsertFinalEInsertEPreprocessedFromESet EOrderRandomEOrderBy EEmptyListEListERawEMaybeEEntityinUseILimitGroupByNoWhereWhere FromStart sdFromClause sdSetClause sdWhereClausesdGroupByClausesdHavingClausesdOrderByClause sdLimitClauseQunQparensM fieldNamesetAuxsub fromDBName existsHelperifNotEmptyList builderToTextuncommas uncommas'makeInsertInto makeSelectmakeFrommakeSet makeWhere makeGroupBy makeHaving makeOrderBy makeLimitparens getEntityValfrom3Pfrom3to3from4Pfrom4to4from5Pto5from6Pto6from7Pto7from8Pto8from9Pto9from10Pto10from11Pto11from12Pto12from13Pto13from14Pto14from15Pto15from16Pto16insertGeneralSelect-$fSqlSelect(,,,,,,,,,,,,,,,)(,,,,,,,,,,,,,,,)+$fSqlSelect(,,,,,,,,,,,,,,)(,,,,,,,,,,,,,,))$fSqlSelect(,,,,,,,,,,,,,)(,,,,,,,,,,,,,)'$fSqlSelect(,,,,,,,,,,,,)(,,,,,,,,,,,,)%$fSqlSelect(,,,,,,,,,,,)(,,,,,,,,,,,)#$fSqlSelect(,,,,,,,,,,)(,,,,,,,,,,)!$fSqlSelect(,,,,,,,,,)(,,,,,,,,,)$fSqlSelect(,,,,,,,,)(,,,,,,,,)$fSqlSelect(,,,,,,,)(,,,,,,,)$fSqlSelect(,,,,,,)(,,,,,,)$fSqlSelect(,,,,,)(,,,,,)$fSqlSelect(,,,,)(,,,,)$fSqlSelect(,,,)(,,,)$fSqlSelect(,,)(,,) $fUnsafeSqlFunctionArgument(,,,)$fUnsafeSqlFunctionArgument(,,)$fUnsafeSqlFunctionArgument(,)$fUnsafeSqlFunctionArgument[]"$fUnsafeSqlFunctionArgumentSqlExpr$fToSomeValuesSqlExprSqlExpr$$fEsqueletoSqlQuerySqlExprSqlBackend$fMonoidLimitClause$fMonoidGroupByClause$fMonoidWhereClause$fMonoidSideData$fApplicativeSqlQuery$fMonadSqlQuery$fFunctorSqlQuery