changelog, vbump

test case
remove failing test with bad behavior
2021-05-20 16:02:16 -06:00 · 2021-05-20 10:30:12 -06:00 · 2021-05-20 10:20:10 -06:00
35 changed files with 3724 additions and 4484 deletions
--- a/.github/workflows/haskell.yml
+++ b/.github/workflows/haskell.yml
@ -32,13 +32,13 @@ jobs:
          --health-retries=3
    strategy:
      matrix:
-        cabal: ["3.6"]
-        ghc: ["8.6.5", "8.8.4", "8.10.4", "9.0.2", "9.2.2"]
+        cabal: ["3.4"]
+        ghc: ["8.6.5", "8.8.4", "8.10.4"]
    env:
      CONFIG: "--enable-tests --enable-benchmarks "
    steps:
      - uses: actions/checkout@v2
-      - uses: haskell/actions/setup@v1
+      - uses: actions/setup-haskell@v1.1.4
        id: setup-haskell-cabal
        with:
          ghc-version: ${{ matrix.ghc }}
@ -71,6 +71,6 @@ jobs:
            ${{ runner.os }}-${{ matrix.ghc }}-${{ hashFiles('cabal.project.freeze') }}
            ${{ runner.os }}-${{ matrix.ghc }}-
      - run: cabal v2-build --disable-optimization -j $CONFIG
-      - run: cabal v2-test --disable-optimization -j $CONFIG --test-options "--fail-on-focus"
+      - run: cabal v2-test --disable-optimization -j $CONFIG
      - run: cabal v2-haddock -j $CONFIG
      - run: cabal v2-sdist
--- a/.gitignore
+++ b/.gitignore
@ -6,5 +6,4 @@ stack.yaml.lock
 .cabal-sandbox/
 cabal.sandbox.config
 .hspec-failures
-*.sqlite*
 cabal.project.freeze
--- a/14
+++ b/14
@ -21,19 +21,7 @@ test-ghci:
 	stack ghci esqueleto:test:sqlite

 test-ghcid:
-	ghcid -c "stack ghci --ghci-options -fobject-code esqueleto --test" \
-		--warnings \
-		--restart "stack.yaml" \
-		--restart "esqueleto.cabal" \
-		--test main
-
-test-ghcid-build:
-	ghcid -c "stack ghci --ghci-options -fobject-code esqueleto --test" \
-		--warnings \
-		--restart "stack.yaml" \
-		--restart "esqueleto.cabal"
-
-
+	ghcid -c "stack ghci --ghci-options -fobject-code esqueleto:test:sqlite"

 init-pgsql:
 	sudo -u postgres -- createuser -s esqutest
--- a/README.md
+++ b/README.md
@ -127,61 +127,7 @@ FROM Person
 WHERE Person.age >= 18
 ```

-Since `age` is an optional `Person` field, we use `just` to lift `val 18 :: SqlExpr (Value Int)` into `just (val 18) ::SqlExpr (Value (Maybe Int))`.
-
-### Alternative Field Projections
-
-The `(^.)` operator works on an `EntityField` value, which are generated by
-`persistent` as the table name + the field name. This can get a little bit
-verbose. As of `persistent-2.11`, you can use `OverloadedLabels` to make this a
-bit more concise:
-
-```haskell
-{-# LANGUAGE OverloadedLabels #-}
-
-select $ do
-    p <- from $ table @Person
-    pure
-        ( p ^. PersonName
-        , p ^. #name
-        )
-```
-
-The `OverloadedLabels` support uses the `fieldName` as given by the Persistent
-entity definition syntax - no type name prefix necessary. Additionally, these
-field accesses are *polymorphic* - the following query filters any table that
-has a `name` column:
-
-```haskell
-rowsByName
-    :: forall rec.
-    ( PersistEntity rec
-    , PersistEntityBackend rec ~ SqlBackend
-    , SymbolToField "name" rec Text
-    )
-    => SqlExpr (Value Text)
-    -> SqlQuery (SqlExpr (Entity rec))
-rowsByName name = do
-    rec <- from $ table @rec
-    where_ $ rec ^. #name ==. name
-    pure rec
-```
-
-GHC 9.2 introduces the `OverloadedRecordDot` language extension, and `esqueleto`
-supports this on `SqlExpr (Entity rec)` and `SqlExpr (Maybe (Entity rec))`. It
-looks like this:
-
-```haskell
-select $ do
-    (person, blogPost) <-
-        from $
-            table @Person
-            `leftJoin` table @BlogPost
-            `on` do
-                \(person :& blogPost) ->
-                    just person.id ==. blogPost.authorId
-    pure (person.name, blogPost.title)
-```
+Since `age` is an optional `Person` field, we use `just` to lift`val 18 :: SqlExpr (Value Int)` into `just (val 18) ::SqlExpr (Value (Maybe Int))`.

 ## Experimental/New Joins

@ -542,5 +488,5 @@ user which can access it:
 mysql> CREATE DATABASE esqutest;
 mysql> CREATE USER 'travis'@'localhost';
 mysql> ALTER USER 'travis'@'localhost' IDENTIFIED BY 'esqutest';
-mysql> GRANT ALL ON esqutest.* TO 'travis'@'localhost';
+mysql> GRANT ALL ON esqutest.* TO 'travis';
 ```
--- a/changelog.md
+++ b/changelog.md
@ -1,85 +1,3 @@
-3.5.4.0
-=======
- @parsonsmatt
-    - [#310](https://github.com/bitemyapp/esqueleto/pull/310)
-        - Add instances of `HasField` for `SqlExpr (Entity rec)` and `SqlExpr
-          (Maybe (Entity rec))`. These instances allow you to use the
-          `OverloadedRecordDot` language extension in GHC 9.2 with SQL
-          representations of database entities.
-
-3.5.3.2
-=======
- @parsonsmatt
-    - [#309](https://github.com/bitemyapp/esqueleto/pull/309)
-        - Bump `time` version bound
-
-3.5.3.1
-=======
- @jappeace
-  - [#303](https://github.com/bitemyapp/esqueleto/pull/303)
-      - Added docs for delete function for new experimental API.
-
-3.5.3.0
-=======
- @m4dc4p
-  - [#291](https://github.com/bitemyapp/esqueleto/pull/291)
-         - Added `ToAlias` and `ToAliasReference` instaces to the `:&` type, mirroring
-         the tuple instances for the same classes. See [Issue #290](https://github.com/bitemyapp/esqueleto/issues/290)
-         for discussion.
- @NikitaRazmakhnin
-  - [#284](https://github.com/bitemyapp/esqueleto/pull/284)
-        - Add PostgreSQL-specific support of VALUES(..) literals
-
-
-3.5.2.2
-=======
- @NikitaRazmakhnin
-  - [#278](https://github.com/bitemyapp/esqueleto/pull/278)
-        - Fix generating of bad sql using nexted expressions with `distinctOnOrderBy`.
-
-3.5.2.1
-=======
- @cdparks
-  - [#273](https://github.com/bitemyapp/esqueleto/pull/273)
-        - Avoid generating an empty list as the left operand to `NOT IN`.
-
-3.5.2.0
-=======
- @ivanbakel
-  - [#268](https://github.com/bitemyapp/esqueleto/pull/268)
-        - Added `SqlSelect` instance for `(:&)`, allowing it to be returned from
-          queries just like `(,)` tuples.
-
-3.5.1.0
-=======
- @ibarrae
-  - [#265](https://github.com/bitemyapp/esqueleto/pull/265)
-        - Added `selectOne`
-
-3.5.0.0
-=======
- @belevy
-  - [#228](https://github.com/bitemyapp/esqueleto/pull/228)
-        - Destroy all GADTs; Removes the From GADT and SqlExpr GADT
-        - From GADT is replaced with a From data type and FromRaw
-        - SqlExpr is now all defined in terms of ERaw
-        - Modified ERaw to contain a SqlExprMeta with any extra information
-          that may be needed
-        - Experimental top level is now strictly for documentation and all the
-          implementation details are in Experimental.* modules
- @parsonsmatt
-    - [#259](https://github.com/bitemyapp/esqueleto/pull/259)
-        - Create the `Database.Esqueleto.Legacy` module. The
-          `Database.Esqueleto` module now emits a warning, directing users to
-          either import `Database.Esqueleto.Legacy` to keep the old behavior or
-          to import `Database.Esqueleto.Experimental` to opt in to the new
-          behavior.
-        - Deleted the deprecated modules
-          `Database.Esqueleto.Internal.{Language,Sql}`. Please use
-          `Database.Esqueleto.Internal.Internal` instead, or ideally post what
-          you need from the library so we can support you safely.
-        - Support GHC 9
-
 3.4.2.2
 =======
 - @parsonsmatt
@ -113,7 +31,6 @@
  - [#232](https://github.com/bitemyapp/esqueleto/pull/232)
    - Export the `ValidOnClauseValue` type family

-
 3.4.0.1
 =======
 - @arthurxavierx
--- a/esqueleto.cabal
+++ b/esqueleto.cabal
@ -1,7 +1,7 @@
 cabal-version: 1.12

 name:           esqueleto
-version:        3.5.4.0
+version:        3.4.2.2
 synopsis:       Type-safe EDSL for SQL queries on persistent backends.
 description:    @esqueleto@ is a bare bones, type-safe EDSL for SQL queries that works with unmodified @persistent@ SQL backends.  Its language closely resembles SQL, so you don't have to learn new concepts, just new syntax, and it's fairly easy to predict the generated SQL and optimize it for your backend. Most kinds of errors committed when writing SQL are caught as compile-time errors---although it is possible to write type-checked @esqueleto@ queries that fail at runtime.
                .
@ -29,24 +29,18 @@ source-repository head
 library
    exposed-modules:
        Database.Esqueleto
-        Database.Esqueleto.Legacy
        Database.Esqueleto.Experimental
+        Database.Esqueleto.Internal.Language
+        Database.Esqueleto.Internal.Sql
        Database.Esqueleto.Internal.Internal
        Database.Esqueleto.Internal.ExprParser
        Database.Esqueleto.MySQL
        Database.Esqueleto.PostgreSQL
        Database.Esqueleto.PostgreSQL.JSON
        Database.Esqueleto.SQLite
-        Database.Esqueleto.Experimental.From
-        Database.Esqueleto.Experimental.From.CommonTableExpression
-        Database.Esqueleto.Experimental.From.Join
-        Database.Esqueleto.Experimental.From.SqlSetOperation
-        Database.Esqueleto.Experimental.ToAlias
-        Database.Esqueleto.Experimental.ToAliasReference
-        Database.Esqueleto.Experimental.ToMaybe
    other-modules:
-        Database.Esqueleto.PostgreSQL.JSON.Instances
        Database.Esqueleto.Internal.PersistentImport
+        Database.Esqueleto.PostgreSQL.JSON.Instances
        Paths_esqueleto
    hs-source-dirs:
        src/
@ -63,7 +57,7 @@ library
      , resourcet >=1.2
      , tagged >=0.2
      , text >=0.11 && <1.3
-      , time >=1.5.0.1 && <=1.13
+      , time >=1.5.0.1 && <=1.10
      , transformers >=0.2
      , unliftio
      , unordered-containers >=0.2
@ -75,24 +69,53 @@ library
        -Wpartial-fields
        -Wmissing-home-modules
        -Widentities
+        -Wredundant-constraints
        -Wcpp-undef
        -Wcpp-undef
+        -Wmonomorphism-restriction
    default-language: Haskell2010

-test-suite specs
+test-suite mysql
    type: exitcode-stdio-1.0
-    main-is: Spec.hs
+    main-is: MySQL/Test.hs
+    other-modules:
+        Common.Test
+        Paths_esqueleto
+    hs-source-dirs:
+        test
+    ghc-options: -Wall
+    build-depends:
+        base >=4.8 && <5.0
+      , attoparsec
+      , blaze-html
+      , bytestring
+      , conduit >=1.3
+      , containers
+      , esqueleto
+      , exceptions
+      , hspec
+      , monad-logger
+      , mtl
+      , mysql
+      , mysql-simple
+      , persistent
+      , persistent-mysql
+      , resourcet >=1.2
+      , tagged >=0.2
+      , text >=0.11 && <1.3
+      , time
+      , transformers >=0.2
+      , unliftio
+      , unordered-containers >=0.2
+    default-language: Haskell2010
+
+test-suite postgresql
+    type: exitcode-stdio-1.0
+    main-is: PostgreSQL/Test.hs
    other-modules:
        Common.Test
-        Common.Test.Models
-        Common.Test.Import
-        Common.Test.Select
        PostgreSQL.MigrateJSON
-        SQLite.Test
-        PostgreSQL.Test
-        MySQL.Test
-    default-extensions:
-        RankNTypes
+        Paths_esqueleto
    hs-source-dirs:
        test
    ghc-options: -Wall -threaded
@ -102,27 +125,55 @@ test-suite specs
      , attoparsec
      , blaze-html
      , bytestring
-      , conduit
+      , conduit >=1.3
      , containers
      , esqueleto
      , exceptions
      , hspec
-      , hspec-core
      , monad-logger
      , mtl
-      , mysql
-      , mysql-simple
      , persistent
-      , persistent-mysql
      , persistent-postgresql
-      , persistent-sqlite
+      , postgresql-libpq
      , postgresql-simple
-      , QuickCheck
-      , resourcet
-      , tagged
-      , text
+      , resourcet >=1.2
+      , tagged >=0.2
+      , text >=0.11 && <1.3
      , time
-      , transformers
+      , transformers >=0.2
      , unliftio
-      , unordered-containers
+      , unordered-containers >=0.2
+      , vector
+    default-language: Haskell2010
+
+test-suite sqlite
+    type: exitcode-stdio-1.0
+    main-is: SQLite/Test.hs
+    other-modules:
+        Common.Test
+        Paths_esqueleto
+    hs-source-dirs:
+        test
+    ghc-options: -Wall -threaded
+    build-depends:
+        base >=4.8 && <5.0
+      , attoparsec
+      , blaze-html
+      , bytestring
+      , conduit >=1.3
+      , containers
+      , esqueleto
+      , exceptions
+      , hspec
+      , monad-logger
+      , mtl
+      , persistent
+      , persistent-sqlite
+      , resourcet >=1.2
+      , tagged >=0.2
+      , text >=0.11 && <1.3
+      , time
+      , transformers >=0.2
+      , unliftio
+      , unordered-containers >=0.2
    default-language: Haskell2010
--- a/src/Database/Esqueleto.hs
+++ b/src/Database/Esqueleto.hs
@ -1,8 +1,4 @@
-{-# LANGUAGE FlexibleContexts #-}
-{-# LANGUAGE FlexibleInstances #-}
-{-# LANGUAGE GADTs #-}
-{-# LANGUAGE RankNTypes #-}
-
+{-# LANGUAGE FlexibleContexts, FlexibleInstances, GADTs, RankNTypes #-}
 -- | The @esqueleto@ EDSL (embedded domain specific language).
 -- This module replaces @Database.Persist@, so instead of
 -- importing that module you should just import this one:
@ -32,15 +28,11 @@
 -- Other than identifier name clashes, @esqueleto@ does not
 -- conflict with @persistent@ in any way.
 --
-- Note that the facilities for @JOIN@ have been significantly improved in the
+-- Note that the faciliites for @JOIN@ have been significantly improved in the
 -- "Database.Esqueleto.Experimental" module. The definition of 'from' and 'on'
 -- in this module will be replaced with those at the 4.0.0.0 version, so you are
 -- encouraged to migrate to the new method.
--
-- This module has an attached WARNING message indicating that the Experimental
-- syntax will become the default. If you want to continue using the old syntax,
-- please refer to "Database.Esqueleto.Legacy" as a drop-in replacement.
-module Database.Esqueleto {-# WARNING "This module will switch over to the Experimental syntax in an upcoming major version release. Please migrate to the Database.Esqueleto.Legacy module to continue using the old syntax, or translate to the new and improved syntax in Database.Esqueleto.Experimental." #-}
+module Database.Esqueleto
  ( -- * Setup
    -- $setup

@ -97,7 +89,6 @@ module Database.Esqueleto {-# WARNING "This module will switch over to the Exper
  , SqlExpr
  , SqlEntity
  , select
-  , selectOne
  , selectSource
  , delete
  , deleteCount
@ -129,8 +120,14 @@ module Database.Esqueleto {-# WARNING "This module will switch over to the Exper
  , module Database.Esqueleto.Internal.PersistentImport
  ) where

-import Database.Esqueleto.Legacy
+import Control.Monad.IO.Class (MonadIO)
+import Control.Monad.Trans.Reader (ReaderT)
+import Data.Int (Int64)
+import qualified Data.Map.Strict as Map
+import Database.Esqueleto.Internal.Language
+import Database.Esqueleto.Internal.Sql
 import Database.Esqueleto.Internal.PersistentImport
+import qualified Database.Persist


 -- $setup
--- a/src/Database/Esqueleto/Experimental.hs
+++ b/src/Database/Esqueleto/Experimental.hs
--- a/src/Database/Esqueleto/Experimental/From.hs
+++ b/src/Database/Esqueleto/Experimental/From.hs
@ -1,145 +0,0 @@
-{-# LANGUAGE CPP #-}
-{-# LANGUAGE DataKinds #-}
-{-# LANGUAGE DerivingStrategies #-}
-{-# LANGUAGE FlexibleContexts #-}
-{-# LANGUAGE FlexibleInstances #-}
-{-# LANGUAGE FunctionalDependencies #-}
-{-# LANGUAGE GADTs #-}
-{-# LANGUAGE GeneralizedNewtypeDeriving #-}
-{-# LANGUAGE MultiParamTypeClasses #-}
-{-# LANGUAGE OverloadedStrings #-}
-{-# LANGUAGE PatternSynonyms #-}
-{-# LANGUAGE ScopedTypeVariables #-}
-{-# LANGUAGE TypeApplications #-}
-{-# LANGUAGE TypeFamilies #-}
-{-# LANGUAGE TypeOperators #-}
-{-# LANGUAGE UndecidableInstances #-}
-
-module Database.Esqueleto.Experimental.From
-    where
-
-import qualified Control.Monad.Trans.Writer as W
-import Data.Coerce (coerce)
-import Data.Proxy
-import qualified Data.Text.Lazy.Builder as TLB
-import Database.Esqueleto.Experimental.ToAlias
-import Database.Esqueleto.Experimental.ToAliasReference
-import Database.Esqueleto.Internal.Internal hiding (From(..), from, on)
-import Database.Esqueleto.Internal.PersistentImport
-
-import Database.Persist.Names (EntityNameDB(..))
-
-- | 'FROM' clause, used to bring entities into scope.
--
-- Internally, this function uses the `From` datatype.
-- Unlike the old `Database.Esqueleto.from`, this does not
-- take a function as a parameter, but rather a value that
-- represents a 'JOIN' tree constructed out of instances of `From`.
-- This implementation eliminates certain
-- types of runtime errors by preventing the construction of
-- invalid SQL (e.g. illegal nested-@from@).
-from :: ToFrom a a' => a -> SqlQuery a'
-from f = do
-    (a, clause) <- unFrom (toFrom f)
-    Q $ W.tell mempty{sdFromClause=[FromRaw $ clause]}
-    pure a
-
-type RawFn = NeedParens -> IdentInfo -> (TLB.Builder, [PersistValue])
-
-- | Data type defining the "From" language. This should not
-- constructed directly in application code.
--
-- A @From@ is a SqlQuery which returns a reference to the result of calling from
-- and a function that produces a portion of a FROM clause. This gets passed to
-- the FromRaw FromClause constructor directly when converting
-- from a @From@ to a @SqlQuery@ using @from@
--
-- @since 3.5.0.0
-newtype From a = From
-    { unFrom :: SqlQuery (a, RawFn)}
-
-
-- | A helper class primarily designed to allow using @SqlQuery@ directly in
-- a From expression. This is also useful for embedding a @SqlSetOperation@,
-- as well as supporting backwards compatibility for the
-- data constructor join tree used prior to /3.5.0.0/
--
-- @since 3.5.0.0
-class ToFrom a r | a -> r where
-    toFrom :: a -> From r
-instance ToFrom (From a) a where
-    toFrom = id
-
-{-# DEPRECATED Table "@since 3.5.0.0 - use 'table' instead" #-}
-data Table a = Table
-
-instance PersistEntity ent => ToFrom (Table ent) (SqlExpr (Entity ent)) where
-    toFrom _ = table
-
-- | Bring a PersistEntity into scope from a table
--
-- @
-- select $ from $ table \@People
-- @
--
-- @since 3.5.0.0
-table :: forall ent. PersistEntity ent => From (SqlExpr (Entity ent))
-table = From $ do
-    let ed = entityDef (Proxy @ent)
-    ident <- newIdentFor (coerce $ getEntityDBName ed)
-    let entity = unsafeSqlEntity ident
-    pure $ ( entity, const $ base ident ed )
-      where
-        base ident@(I identText) def info =
-            let db = coerce $ getEntityDBName def
-            in ( (fromDBName info (coerce db)) <>
-                     if  db == identText
-                     then mempty
-                     else " AS " <> useIdent info ident
-               , mempty
-               )
-
-
-{-# DEPRECATED SubQuery "/Since: 3.4.0.0/ - It is no longer necessary to tag 'SqlQuery' values with @SubQuery@" #-}
-newtype SubQuery a = SubQuery a
-instance (SqlSelect a r, ToAlias a, ToAliasReference a) => ToFrom (SubQuery (SqlQuery a)) a where
-    toFrom (SubQuery q) = selectQuery q
-instance (SqlSelect a r, ToAlias a, ToAliasReference a) => ToFrom (SqlQuery a) a where
-    toFrom = selectQuery
-
-- | Select from a subquery, often used in conjuction with joins but can be
-- used without any joins. Because @SqlQuery@ has a @ToFrom@ instance you probably
-- dont need to use this function directly.
--
-- @
-- select $
--      p <- from $
--              selectQuery do
--              p <- from $ table \@Person
--              limit 5
--              orderBy [ asc p ^. PersonAge ]
--      ...
-- @
--
-- @since 3.5.0.0
-selectQuery :: (SqlSelect a r, ToAlias a, ToAliasReference a) => SqlQuery a -> From a
-selectQuery subquery = From $ do
-    -- We want to update the IdentState without writing the query to side data
-    (ret, sideData) <- Q $ W.censor (\_ -> mempty) $ W.listen $ unQ subquery
-    aliasedValue <- toAlias ret
-    -- Make a fake query with the aliased results, this allows us to ensure that the query is only run once
-    let aliasedQuery = Q $ W.WriterT $ pure (aliasedValue, sideData)
-    -- Add the FromQuery that renders the subquery to our side data
-    subqueryAlias <- newIdentFor (DBName "q")
-    -- Pass the aliased results of the subquery to the outer query
-    -- create aliased references from the outer query results (e.g value from subquery will be `subquery`.`value`),
-    -- this is probably overkill as the aliases should already be unique but seems to be good practice.
-    ref <- toAliasReference subqueryAlias aliasedValue
-
-    pure (ref, \_ info ->
-            let (queryText,queryVals) = toRawSql SELECT info aliasedQuery
-            in
-            ( (parens queryText) <> " AS " <> useIdent info subqueryAlias
-            , queryVals
-            )
-         )
--- a/src/Database/Esqueleto/Experimental/From/CommonTableExpression.hs
+++ b/src/Database/Esqueleto/Experimental/From/CommonTableExpression.hs
@ -1,111 +0,0 @@
-{-# LANGUAGE FlexibleInstances #-}
-{-# LANGUAGE OverloadedStrings #-}
-{-# LANGUAGE TypeFamilies #-}
-
-module Database.Esqueleto.Experimental.From.CommonTableExpression
-    where
-
-import qualified Control.Monad.Trans.Writer as W
-import qualified Data.Text.Lazy.Builder as TLB
-import Database.Esqueleto.Experimental.From
-import Database.Esqueleto.Experimental.From.SqlSetOperation
-import Database.Esqueleto.Experimental.ToAlias
-import Database.Esqueleto.Experimental.ToAliasReference
-import Database.Esqueleto.Internal.Internal hiding (From(..), from, on)
-
-- | @WITH@ clause used to introduce a [Common Table Expression (CTE)](https://en.wikipedia.org/wiki/Hierarchical_and_recursive_queries_in_SQL#Common_table_expression).
-- CTEs are supported in most modern SQL engines and can be useful
-- in performance tuning. In Esqueleto, CTEs should be used as a
-- subquery memoization tactic. When writing plain SQL, CTEs
-- are sometimes used to organize the SQL code, in Esqueleto, this
-- is better achieved through function that return 'SqlQuery' values.
--
-- @
-- select $ do
-- cte <- with subQuery
-- cteResult <- from cte
-- where_ $ cteResult ...
-- pure cteResult
-- @
--
-- __WARNING__: In some SQL engines using a CTE can diminish performance.
-- In these engines the CTE is treated as an optimization fence. You should
-- always verify that using a CTE will in fact improve your performance
-- over a regular subquery.
--
-- /Since: 3.4.0.0/
-with :: ( ToAlias a
-        , ToAliasReference a
-        , SqlSelect a r
-        ) => SqlQuery a -> SqlQuery (From a)
-with query = do
-    (ret, sideData) <- Q $ W.censor (\_ -> mempty) $ W.listen $ unQ query
-    aliasedValue <- toAlias ret
-    let aliasedQuery = Q $ W.WriterT $ pure (aliasedValue, sideData)
-    ident <- newIdentFor (DBName "cte")
-    let clause = CommonTableExpressionClause NormalCommonTableExpression ident (\info -> toRawSql SELECT info aliasedQuery)
-    Q $ W.tell mempty{sdCteClause = [clause]}
-    ref <- toAliasReference ident aliasedValue
-    pure $ From $ pure (ref, (\_ info -> (useIdent info ident, mempty)))
-
-- | @WITH@ @RECURSIVE@ allows one to make a recursive subquery, which can
-- reference itself. Like @WITH@, this is supported in most modern SQL engines.
-- Useful for hierarchical, self-referential data, like a tree of data.
--
-- @
-- select $ do
-- cte <- withRecursive
--          (do
--              person <- from $ table \@Person
--              where_ $ person ^. PersonId ==. val personId
--              pure person
--          )
--          unionAll_
--          (\\self -> do
--              (p :& f :& p2 :& pSelf) <- from self
--                       \`innerJoin\` $ table \@Follow
--                       \`on\` (\\(p :& f) ->
--                               p ^. PersonId ==. f ^. FollowFollower)
--                       \`innerJoin\` $ table \@Person
--                       \`on\` (\\(p :& f :& p2) ->
--                               f ^. FollowFollowed ==. p2 ^. PersonId)
--                       \`leftJoin\` self
--                       \`on\` (\\(_ :& _ :& p2 :& pSelf) ->
--                               just (p2 ^. PersonId) ==. pSelf ?. PersonId)
--              where_ $ isNothing (pSelf ?. PersonId)
--              groupBy (p2 ^. PersonId)
--              pure p2
--          )
-- from cte
-- @
--
-- /Since: 3.4.0.0/
-withRecursive :: ( ToAlias a
-                 , ToAliasReference a
-                 , SqlSelect a r
-                 )
-              => SqlQuery a
-              -> UnionKind
-              -> (From a -> SqlQuery a)
-              -> SqlQuery (From a)
-withRecursive baseCase unionKind recursiveCase = do
-    (ret, sideData) <- Q $ W.censor (\_ -> mempty) $ W.listen $ unQ baseCase
-    aliasedValue <- toAlias ret
-    let aliasedQuery = Q $ W.WriterT $ pure (aliasedValue, sideData)
-    ident <- newIdentFor (DBName "cte")
-    ref <- toAliasReference ident aliasedValue
-    let refFrom = From (pure (ref, (\_ info -> (useIdent info ident, mempty))))
-    let recursiveQuery = recursiveCase refFrom
-    let clause = CommonTableExpressionClause RecursiveCommonTableExpression ident
-                 (\info -> (toRawSql SELECT info aliasedQuery)
-                        <> ("\n" <> (unUnionKind unionKind)  <> "\n", mempty)
-                        <> (toRawSql SELECT info recursiveQuery)
-                 )
-    Q $ W.tell mempty{sdCteClause = [clause]}
-    pure refFrom
-
-newtype UnionKind = UnionKind { unUnionKind :: TLB.Builder }
-instance Union_ UnionKind where
-    union_ = UnionKind "UNION"
-instance UnionAll_ UnionKind where
-    unionAll_ = UnionKind "UNION ALL"
--- a/src/Database/Esqueleto/Experimental/From/Join.hs
+++ b/src/Database/Esqueleto/Experimental/From/Join.hs
@ -1,425 +0,0 @@
-{-# LANGUAGE DataKinds #-}
-{-# LANGUAGE FlexibleContexts #-}
-{-# LANGUAGE FlexibleInstances #-}
-{-# LANGUAGE FunctionalDependencies #-}
-{-# LANGUAGE MultiParamTypeClasses #-}
-{-# LANGUAGE OverloadedStrings #-}
-{-# LANGUAGE ScopedTypeVariables #-}
-{-# LANGUAGE TypeApplications #-}
-{-# LANGUAGE TypeFamilies #-}
-{-# LANGUAGE TypeOperators #-}
-{-# LANGUAGE UndecidableInstances #-}
-
-{-# OPTIONS_GHC -fno-warn-orphans #-}
-
-module Database.Esqueleto.Experimental.From.Join
-    where
-
-import Data.Bifunctor (first)
-import Data.Kind (Constraint)
-import Data.Proxy
-import qualified Data.Text.Lazy.Builder as TLB
-import Database.Esqueleto.Experimental.From
-import Database.Esqueleto.Experimental.ToAlias
-import Database.Esqueleto.Experimental.ToAliasReference
-import Database.Esqueleto.Experimental.ToMaybe
-import Database.Esqueleto.Internal.Internal hiding
-       (From(..), from, fromJoin, on)
-import GHC.TypeLits
-
-- | A left-precedence pair. Pronounced \"and\". Used to represent expressions
-- that have been joined together.
--
-- The precedence behavior can be demonstrated by:
--
-- @
-- a :& b :& c == ((a :& b) :& c)
-- @
--
-- See the examples at the beginning of this module to see how this
-- operator is used in 'JOIN' operations.
-data (:&) a b = a :& b
-infixl 2 :&
-
-instance (ToMaybe a, ToMaybe b) => ToMaybe (a :& b) where
-    type ToMaybeT (a :& b) = (ToMaybeT a :& ToMaybeT b)
-    toMaybe (a :& b) = (toMaybe a :& toMaybe b)
-
-class ValidOnClause a
-instance {-# OVERLAPPABLE #-} ToFrom a a' => ValidOnClause a
-instance ValidOnClause (a -> SqlQuery b)
-
-- | You may return joined values from a 'select' query - this is
-- identical to the tuple instance, but is provided for convenience.
--
-- @since 3.5.2.0
-instance (SqlSelect a ra, SqlSelect b rb) => SqlSelect (a :& b) (ra :& rb) where
-    sqlSelectCols esc (a :& b) = sqlSelectCols esc (a, b)
-    sqlSelectColCount = sqlSelectColCount . toTuple
-      where
-        toTuple :: Proxy (a :& b) -> Proxy (a, b)
-        toTuple = const Proxy
-    sqlSelectProcessRow = fmap (uncurry (:&)) . sqlSelectProcessRow
-
-- | Identical to the tuple instance and provided for convenience.
--
-- @since 3.5.3.0
-instance (ToAlias a, ToAlias b) => ToAlias (a :& b) where
-    toAlias (a :& b) = (:&) <$> toAlias a <*> toAlias b
-
-- | Identical to the tuple instance and provided for convenience.
--
-- @since 3.5.3.0
-instance (ToAliasReference a, ToAliasReference b) => ToAliasReference (a :& b) where
-    toAliasReference ident (a :& b) = (:&) <$> (toAliasReference ident a) <*> (toAliasReference ident b)
-
-- | An @ON@ clause that describes how two tables are related. This should be
-- used as an infix operator after a 'JOIN'. For example,
--
-- @
-- select $
-- from $ table \@Person
-- \`innerJoin\` table \@BlogPost
-- \`on\` (\\(p :& bP) ->
--         p ^. PersonId ==. bP ^. BlogPostAuthorId)
-- @
-on :: ValidOnClause a => a -> (b -> SqlExpr (Value Bool)) -> (a, b -> SqlExpr (Value Bool))
-on = (,)
-infix 9 `on`
-
-type family ErrorOnLateral a :: Constraint where
-  ErrorOnLateral (a -> SqlQuery b) = TypeError ('Text "LATERAL can only be used for INNER, LEFT, and CROSS join kinds.")
-  ErrorOnLateral _ = ()
-
-fromJoin :: TLB.Builder -> RawFn -> RawFn -> Maybe (SqlExpr (Value Bool)) -> RawFn
-fromJoin joinKind lhs rhs monClause =
-    \paren info ->
-        first (parensM paren) $
-        mconcat [ lhs Never info
-                , (joinKind, mempty)
-                , rhs Parens info
-                , maybe mempty (makeOnClause info) monClause
-                ]
-    where
-        makeOnClause info (ERaw _ f)        = first (" ON " <>) (f Never info)
-
-type family HasOnClause actual expected :: Constraint where
-    HasOnClause (a, b -> SqlExpr (Value Bool)) c = () -- Let the compiler handle the type mismatch
-    HasOnClause a expected =
-        TypeError ( 'Text "Missing ON clause for join with"
-                    ':$$: 'ShowType a
-                    ':$$: 'Text ""
-                    ':$$: 'Text "Expected: "
-                    ':$$: 'ShowType a
-                    ':$$: 'Text "`on` " ':<>: 'ShowType (expected -> SqlExpr (Value Bool))
-                    ':$$: 'Text ""
-                  )
-
-
-- | INNER JOIN
--
-- Used as an infix operator \`innerJoin\`
--
-- @
-- select $
-- from $ table \@Person
-- \`innerJoin\` table \@BlogPost
-- \`on\` (\\(p :& bp) ->
--         p ^. PersonId ==. bp ^. BlogPostAuthorId)
-- @
--
-- @since 3.5.0.0
-innerJoin :: ( ToFrom a a'
-             , ToFrom b b'
-             , HasOnClause rhs (a' :& b')
-             , rhs ~ (b, (a' :& b') -> SqlExpr (Value Bool))
-             ) => a -> rhs -> From (a' :& b')
-innerJoin lhs (rhs, on') = From $ do
-     (leftVal, leftFrom) <- unFrom (toFrom lhs)
-     (rightVal, rightFrom) <- unFrom (toFrom rhs)
-     let ret = leftVal :& rightVal
-     pure $ (ret, fromJoin " INNER JOIN " leftFrom rightFrom (Just $ on' ret))
-
-
-- | INNER JOIN LATERAL
--
-- A Lateral subquery join allows the joined query to reference entities from the
-- left hand side of the join. Discards rows that don't match the on clause
--
-- Used as an infix operator \`innerJoinLateral\`
--
-- See example 6
--
-- @since 3.5.0.0
-innerJoinLateral :: ( ToFrom a a'
-                    , HasOnClause rhs (a' :& b)
-                    , SqlSelect b r
-                    , ToAlias b
-                    , ToAliasReference b
-                    , rhs ~ (a' -> SqlQuery b, (a' :& b) -> SqlExpr (Value Bool))
-                    )
-                 => a -> rhs -> From (a' :& b)
-innerJoinLateral lhs (rhsFn, on') = From $ do
-     (leftVal, leftFrom) <- unFrom (toFrom lhs)
-     (rightVal, rightFrom) <- unFrom (selectQuery (rhsFn leftVal))
-     let ret = leftVal :& rightVal
-     pure $ (ret, fromJoin " INNER JOIN LATERAL " leftFrom rightFrom (Just $ on' ret))
-
-- | CROSS JOIN
--
-- Used as an infix \`crossJoin\`
--
-- @
-- select $ do
-- from $ table \@Person
-- \`crossJoin\` table \@BlogPost
-- @
--
-- @since 3.5.0.0
-crossJoin :: ( ToFrom a a'
-             , ToFrom b b'
-             ) => a -> b -> From (a' :& b')
-crossJoin lhs rhs = From $ do
-     (leftVal, leftFrom) <- unFrom (toFrom lhs)
-     (rightVal, rightFrom) <- unFrom (toFrom rhs)
-     let ret = leftVal :& rightVal
-     pure $ (ret, fromJoin " CROSS JOIN " leftFrom rightFrom Nothing)
-
-- | CROSS JOIN LATERAL
--
-- A Lateral subquery join allows the joined query to reference entities from the
-- left hand side of the join.
--
-- Used as an infix operator \`crossJoinLateral\`
--
-- See example 6
--
-- @since 3.5.0.0
-crossJoinLateral :: ( ToFrom a a'
-                    , SqlSelect b r
-                    , ToAlias b
-                    , ToAliasReference b
-                    )
-                 => a -> (a' -> SqlQuery b) -> From (a' :& b)
-crossJoinLateral lhs rhsFn = From $ do
-     (leftVal, leftFrom) <- unFrom (toFrom lhs)
-     (rightVal, rightFrom) <- unFrom (selectQuery (rhsFn leftVal))
-     let ret = leftVal :& rightVal
-     pure $ (ret, fromJoin " CROSS JOIN LATERAL " leftFrom rightFrom Nothing)
-
-- | LEFT OUTER JOIN
--
-- Join where the right side may not exist.
-- If the on clause fails then the right side will be NULL'ed
-- Because of this the right side needs to be handled as a Maybe
--
-- Used as an infix operator \`leftJoin\`
--
-- @
-- select $
-- from $ table \@Person
-- \`leftJoin\` table \@BlogPost
-- \`on\` (\\(p :& bp) ->
--         p ^. PersonId ==. bp ?. BlogPostAuthorId)
-- @
--
-- @since 3.5.0.0
-leftJoin :: ( ToFrom a a'
-            , ToFrom b b'
-            , ToMaybe b'
-            , HasOnClause rhs (a' :& ToMaybeT b')
-            , rhs ~ (b, (a' :& ToMaybeT b') -> SqlExpr (Value Bool))
-            ) => a -> rhs -> From (a' :& ToMaybeT b')
-leftJoin lhs (rhs, on') = From $ do
-     (leftVal, leftFrom) <- unFrom (toFrom lhs)
-     (rightVal, rightFrom) <- unFrom (toFrom rhs)
-     let ret = leftVal :& toMaybe rightVal
-     pure $ (ret, fromJoin " LEFT OUTER JOIN " leftFrom rightFrom (Just $ on' ret))
-
-- | LEFT OUTER JOIN LATERAL
--
-- Lateral join where the right side may not exist.
-- In the case that the query returns nothing or the on clause fails the right
-- side of the join will be NULL'ed
-- Because of this the right side needs to be handled as a Maybe
--
-- Used as an infix operator \`leftJoinLateral\`
--
-- See example 6 for how to use LATERAL
--
-- @since 3.5.0.0
-leftJoinLateral :: ( ToFrom a a'
-                   , SqlSelect b r
-                   , HasOnClause rhs (a' :& ToMaybeT b)
-                   , ToAlias b
-                   , ToAliasReference b
-                   , ToMaybe b
-                   , rhs ~ (a' -> SqlQuery b, (a' :& ToMaybeT b) -> SqlExpr (Value Bool))
-                   )
-                 => a -> rhs -> From (a' :& ToMaybeT b)
-leftJoinLateral lhs (rhsFn, on') = From $ do
-     (leftVal, leftFrom) <- unFrom (toFrom lhs)
-     (rightVal, rightFrom) <- unFrom (selectQuery (rhsFn leftVal))
-     let ret = leftVal :& toMaybe rightVal
-     pure $ (ret, fromJoin " LEFT OUTER JOIN LATERAL " leftFrom rightFrom (Just $ on' ret))
-
-- | RIGHT OUTER JOIN
--
-- Join where the left side may not exist.
-- If the on clause fails then the left side will be NULL'ed
-- Because of this the left side needs to be handled as a Maybe
--
-- Used as an infix operator \`rightJoin\`
--
-- @
-- select $
-- from $ table \@Person
-- \`rightJoin\` table \@BlogPost
-- \`on\` (\\(p :& bp) ->
--         p ?. PersonId ==. bp ^. BlogPostAuthorId)
-- @
--
-- @since 3.5.0.0
-rightJoin :: ( ToFrom a a'
-             , ToFrom b b'
-             , ToMaybe a'
-             , HasOnClause rhs (ToMaybeT a' :& b')
-             , rhs ~ (b, (ToMaybeT a' :& b') -> SqlExpr (Value Bool))
-             ) => a -> rhs -> From (ToMaybeT a' :& b')
-rightJoin lhs (rhs, on') = From $ do
-     (leftVal, leftFrom) <- unFrom (toFrom lhs)
-     (rightVal, rightFrom) <- unFrom (toFrom rhs)
-     let ret = toMaybe leftVal :& rightVal
-     pure $ (ret, fromJoin " RIGHT OUTER JOIN " leftFrom rightFrom (Just $ on' ret))
-
-- | FULL OUTER JOIN
--
-- Join where both sides of the join may not exist.
-- Because of this the result needs to be handled as a Maybe
--
-- Used as an infix operator \`fullOuterJoin\`
--
-- @
-- select $
-- from $ table \@Person
-- \`fullOuterJoin\` table \@BlogPost
-- \`on\` (\\(p :& bp) ->
--         p ?. PersonId ==. bp ?. BlogPostAuthorId)
-- @
--
-- @since 3.5.0.0
-fullOuterJoin :: ( ToFrom a a'
-                 , ToFrom b b'
-                 , ToMaybe a'
-                 , ToMaybe b'
-                 , HasOnClause rhs (ToMaybeT a' :& ToMaybeT b')
-                 , rhs ~ (b, (ToMaybeT a' :& ToMaybeT b') -> SqlExpr (Value Bool))
-                 ) => a -> rhs -> From (ToMaybeT a' :& ToMaybeT b')
-fullOuterJoin lhs (rhs, on') = From $ do
-     (leftVal, leftFrom) <- unFrom (toFrom lhs)
-     (rightVal, rightFrom) <- unFrom (toFrom rhs)
-     let ret = toMaybe leftVal :& toMaybe rightVal
-     pure $ (ret, fromJoin " FULL OUTER JOIN " leftFrom rightFrom (Just $ on' ret))
-
-infixl 2 `innerJoin`,
-         `innerJoinLateral`,
-         `leftJoin`,
-         `leftJoinLateral`,
-         `crossJoin`,
-         `crossJoinLateral`,
-         `rightJoin`,
-         `fullOuterJoin`
-
-
------ Compatibility for old syntax
-
-data Lateral
-data NotLateral
-
-type family IsLateral a where
-    IsLateral (a -> SqlQuery b, c) = Lateral
-    IsLateral (a -> SqlQuery b) = Lateral
-    IsLateral a = NotLateral
-
-class DoInnerJoin lateral lhs rhs res | lateral rhs lhs -> res where
-    doInnerJoin :: Proxy lateral -> lhs -> rhs -> From res
-
-instance ( ToFrom a a'
-         , ToFrom b b'
-         , HasOnClause rhs (a' :& b')
-         , rhs ~ (b, (a' :& b') -> SqlExpr (Value Bool))
-         ) => DoInnerJoin NotLateral a rhs (a' :& b') where
-    doInnerJoin _ = innerJoin
-
-instance ( ToFrom a a'
-         , SqlSelect b r
-         , ToAlias b
-         , ToAliasReference b
-         , d ~ (a' :& b)
-         ) => DoInnerJoin Lateral a (a' -> SqlQuery b, d -> SqlExpr (Value Bool)) d where
-    doInnerJoin _ = innerJoinLateral
-
-instance ( DoInnerJoin lateral lhs rhs r, lateral ~ IsLateral rhs )
-           => ToFrom (InnerJoin lhs rhs) r where
-     toFrom (InnerJoin a b) = doInnerJoin (Proxy @lateral) a b
-
-class DoLeftJoin lateral lhs rhs res | lateral rhs lhs -> res where
-    doLeftJoin :: Proxy lateral -> lhs -> rhs -> From res
-
-instance ( ToFrom a a'
-         , ToFrom b b'
-         , ToMaybe b'
-         , ToMaybeT b' ~ mb
-         , HasOnClause rhs (a' :& mb)
-         , rhs ~ (b, (a' :& mb) -> SqlExpr (Value Bool))
-         ) => DoLeftJoin NotLateral a rhs (a' :& mb) where
-    doLeftJoin _ = leftJoin
-
-instance ( ToFrom a a'
-         , ToMaybe b
-         , d ~ (a' :& ToMaybeT b)
-         , SqlSelect b r
-         , ToAlias b
-         , ToAliasReference b
-         ) => DoLeftJoin Lateral a (a' -> SqlQuery b, d -> SqlExpr (Value Bool)) d where
-    doLeftJoin _ = leftJoinLateral
-
-instance ( DoLeftJoin lateral lhs rhs r, lateral ~ IsLateral rhs )
-           => ToFrom (LeftOuterJoin lhs rhs) r where
-     toFrom (LeftOuterJoin a b) = doLeftJoin (Proxy @lateral) a b
-
-class DoCrossJoin lateral lhs rhs res | lateral lhs rhs -> res where
-    doCrossJoin :: Proxy lateral -> lhs -> rhs -> From res
-
-instance (ToFrom a a', ToFrom b b') => DoCrossJoin NotLateral a b (a' :& b') where
-    doCrossJoin _ = crossJoin
-instance (ToFrom a a', SqlSelect b r, ToAlias b, ToAliasReference b)
-  => DoCrossJoin Lateral a (a' -> SqlQuery b) (a' :& b) where
-    doCrossJoin _ = crossJoinLateral
-
-instance (DoCrossJoin lateral lhs rhs r, IsLateral rhs ~ lateral)
-  => ToFrom (CrossJoin lhs rhs) r where
-    toFrom (CrossJoin a b) = doCrossJoin (Proxy @lateral) a b
-
-instance ( ToFrom a a'
-         , ToFrom b b'
-         , ToMaybe a'
-         , ToMaybeT a' ~ ma
-         , HasOnClause rhs (ma :& b')
-         , ErrorOnLateral b
-         , rhs ~ (b, (ma :& b') -> SqlExpr (Value Bool))
-         ) => ToFrom (RightOuterJoin a rhs) (ma :& b') where
-    toFrom (RightOuterJoin a b) = rightJoin a b
-
-instance ( ToFrom a a'
-         , ToFrom b b'
-         , ToMaybe a'
-         , ToMaybeT a' ~ ma
-         , ToMaybe b'
-         , ToMaybeT b' ~ mb
-         , HasOnClause rhs (ma :& mb)
-         , ErrorOnLateral b
-         , rhs ~ (b, (ma :& mb) -> SqlExpr (Value Bool))
-         ) => ToFrom (FullOuterJoin a rhs) (ma :& mb) where
-    toFrom (FullOuterJoin a b) = fullOuterJoin a b
-
--- a/src/Database/Esqueleto/Experimental/From/SqlSetOperation.hs
+++ b/src/Database/Esqueleto/Experimental/From/SqlSetOperation.hs
@ -1,130 +0,0 @@
-{-# LANGUAGE FlexibleContexts #-}
-{-# LANGUAGE FlexibleInstances #-}
-{-# LANGUAGE FunctionalDependencies #-}
-{-# LANGUAGE MultiParamTypeClasses #-}
-{-# LANGUAGE OverloadedStrings #-}
-{-# LANGUAGE PatternSynonyms #-}
-{-# LANGUAGE ScopedTypeVariables #-}
-{-# LANGUAGE TypeApplications #-}
-{-# LANGUAGE TypeFamilies #-}
-{-# LANGUAGE UndecidableInstances #-}
-
-module Database.Esqueleto.Experimental.From.SqlSetOperation
-        where
-
-import Control.Arrow (first)
-import Control.Monad.Trans.Class (lift)
-import qualified Control.Monad.Trans.State as S
-import qualified Control.Monad.Trans.Writer as W
-import qualified Data.Text.Lazy.Builder as TLB
-import Database.Esqueleto.Experimental.From
-import Database.Esqueleto.Experimental.ToAlias
-import Database.Esqueleto.Experimental.ToAliasReference
-import Database.Esqueleto.Internal.Internal hiding (From(..), from, on)
-import Database.Esqueleto.Internal.PersistentImport (PersistValue)
-
-- | Data type used to implement the SqlSetOperation language
-- this type is implemented in the same way as a @From@
--
-- Semantically a @SqlSetOperation@ is always a @From@ but not vice versa
--
-- @since 3.5.0.0
-newtype SqlSetOperation a = SqlSetOperation
-    { unSqlSetOperation :: NeedParens -> SqlQuery (a, IdentInfo -> (TLB.Builder, [PersistValue]))}
-
-instance ToAliasReference a => ToFrom (SqlSetOperation a) a where
-    toFrom setOperation = From $ do
-        ident <- newIdentFor (DBName "u")
-        (a, fromClause) <- unSqlSetOperation setOperation Never
-        ref <- toAliasReference ident a
-        pure (ref, \_ info -> (first parens $ fromClause info) <> (" AS " <> useIdent info ident, mempty))
-
-- | Type class to support direct use of @SqlQuery@ in a set operation tree
--
-- @since 3.5.0.0
-class ToSqlSetOperation a r | a -> r where
-    toSqlSetOperation :: a -> SqlSetOperation r
-instance ToSqlSetOperation (SqlSetOperation a) a where
-    toSqlSetOperation = id
-instance (SqlSelect a r, ToAlias a, ToAliasReference a) => ToSqlSetOperation (SqlQuery a) a where
-    toSqlSetOperation subquery =
-        SqlSetOperation $ \p -> do
-            (ret, sideData) <- Q $ W.censor (\_ -> mempty) $ W.listen $ unQ subquery
-            state <- Q $ lift S.get
-            aliasedValue <- toAlias ret
-            Q $ lift $ S.put state
-            let aliasedQuery = Q $ W.WriterT $ pure (aliasedValue, sideData)
-            let p' =
-                  case p of
-                    Parens -> Parens
-                    Never ->
-                      if (sdLimitClause sideData) /= mempty
-                          || length (sdOrderByClause sideData) > 0 then
-                        Parens
-                      else
-                        Never
-            pure (aliasedValue, \info -> first (parensM p') $ toRawSql SELECT info aliasedQuery)
-
-- | Helper function for defining set operations
-- @since 3.5.0.0
-mkSetOperation :: (ToSqlSetOperation a a', ToSqlSetOperation b a')
-               => TLB.Builder -> a -> b -> SqlSetOperation a'
-mkSetOperation operation lhs rhs = SqlSetOperation $ \p -> do
-    (leftValue, leftClause) <- unSqlSetOperation (toSqlSetOperation lhs) p
-    (_, rightClause) <- unSqlSetOperation (toSqlSetOperation rhs) p
-    pure (leftValue, \info -> leftClause info <> (operation, mempty) <> rightClause info)
-
-{-# DEPRECATED Union "/Since: 3.4.0.0/ - Use the 'union_' function instead of the 'Union' data constructor" #-}
-data Union a b = a `Union` b
-instance ToSqlSetOperation a a' => ToSqlSetOperation (Union a a) a' where
-    toSqlSetOperation (Union a b) = union_ a b
-
-- | Overloaded @union_@ function to support use in both 'SqlSetOperation'
-- and 'withRecursive'
--
-- @since 3.5.0.0
-class Union_ a where
-    -- | @UNION@ SQL set operation. Can be used as an infix function between 'SqlQuery' values.
-    union_ :: a
-
-instance (ToSqlSetOperation a c, ToSqlSetOperation b c, res ~ SqlSetOperation c)
-  => Union_ (a -> b -> res) where
-    union_ = mkSetOperation " UNION "
-
-- | Overloaded @unionAll_@ function to support use in both 'SqlSetOperation'
-- and 'withRecursive'
--
-- @since 3.5.0.0
-class UnionAll_ a where
-    -- | @UNION@ @ALL@ SQL set operation. Can be used as an infix function between 'SqlQuery' values.
-    unionAll_ :: a
-instance (ToSqlSetOperation a c, ToSqlSetOperation b c, res ~ SqlSetOperation c)
-  => UnionAll_ (a -> b -> res) where
-    unionAll_ = mkSetOperation " UNION ALL "
-
-{-# DEPRECATED UnionAll "/Since: 3.4.0.0/ - Use the 'unionAll_' function instead of the 'UnionAll' data constructor" #-}
-data UnionAll a b = a `UnionAll` b
-instance ToSqlSetOperation a a' => ToSqlSetOperation (UnionAll a a) a' where
-    toSqlSetOperation (UnionAll a b) = unionAll_ a b
-
-{-# DEPRECATED Except "/Since: 3.4.0.0/ - Use the 'except_' function instead of the 'Except' data constructor" #-}
-data Except a b = a `Except` b
-instance ToSqlSetOperation a a' => ToSqlSetOperation (Except a a) a' where
-    toSqlSetOperation (Except a b) = except_ a b
-
-- | @EXCEPT@ SQL set operation. Can be used as an infix function between 'SqlQuery' values.
-except_ :: (ToSqlSetOperation a a', ToSqlSetOperation b a') => a -> b -> SqlSetOperation a'
-except_ = mkSetOperation " EXCEPT "
-
-{-# DEPRECATED Intersect "/Since: 3.4.0.0/ - Use the 'intersect_' function instead of the 'Intersect' data constructor" #-}
-data Intersect a b = a `Intersect` b
-instance ToSqlSetOperation a a' => ToSqlSetOperation (Intersect a a) a' where
-    toSqlSetOperation (Intersect a b) = intersect_ a b
-
-- | @INTERSECT@ SQL set operation. Can be used as an infix function between 'SqlQuery' values.
-intersect_ :: (ToSqlSetOperation a a', ToSqlSetOperation b a') => a -> b -> SqlSetOperation a'
-intersect_ = mkSetOperation " INTERSECT "
-
-{-# DEPRECATED SelectQuery "/Since: 3.4.0.0/ - It is no longer necessary to tag 'SqlQuery' values with @SelectQuery@" #-}
-pattern SelectQuery a = a
-
--- a/src/Database/Esqueleto/Experimental/ToAlias.hs
+++ b/src/Database/Esqueleto/Experimental/ToAlias.hs
@ -1,92 +0,0 @@
-{-# LANGUAGE FlexibleInstances #-}
-{-# LANGUAGE OverloadedStrings #-}
-{-# LANGUAGE TypeFamilies #-}
-
-module Database.Esqueleto.Experimental.ToAlias
-    where
-
-import Database.Esqueleto.Internal.Internal hiding (From, from, on)
-import Database.Esqueleto.Internal.PersistentImport
-
-{-# DEPRECATED ToAliasT "This type alias doesn't do anything. Please delete it. Will be removed in the next release." #-}
-type ToAliasT a = a
-
-- Tedious tuple magic
-class ToAlias a where
-    toAlias :: a -> SqlQuery a
-
-instance ToAlias (SqlExpr (Value a)) where
-    toAlias e@(ERaw m f)
-      | Just _ <- sqlExprMetaAlias m = pure e
-      | otherwise = do
-            ident <- newIdentFor (DBName "v")
-            pure $ ERaw noMeta{sqlExprMetaAlias = Just ident} f
-
-instance ToAlias (SqlExpr (Entity a)) where
-    toAlias e@(ERaw m f)
-      | Just _ <- sqlExprMetaAlias m = pure e
-      | otherwise = do
-           ident <- newIdentFor (DBName "v")
-           pure $ ERaw m{sqlExprMetaIsReference = False, sqlExprMetaAlias = Just ident} f
-
-instance ToAlias (SqlExpr (Maybe (Entity a))) where
-    -- FIXME: Code duplication because the compiler doesnt like half final encoding
-    toAlias e@(ERaw m f)
-      | Just _ <- sqlExprMetaAlias m = pure e
-      | otherwise = do
-           ident <- newIdentFor (DBName "v")
-           pure $ ERaw m{sqlExprMetaIsReference = False, sqlExprMetaAlias = Just ident} f
-
-instance (ToAlias a, ToAlias b) => ToAlias (a,b) where
-    toAlias (a,b) = (,) <$> toAlias a <*> toAlias b
-
-instance ( ToAlias a
-         , ToAlias b
-         , ToAlias c
-         ) => ToAlias (a,b,c) where
-    toAlias x = to3 <$> (toAlias $ from3 x)
-
-instance ( ToAlias a
-         , ToAlias b
-         , ToAlias c
-         , ToAlias d
-         ) => ToAlias (a,b,c,d) where
-    toAlias x = to4 <$> (toAlias $ from4 x)
-
-instance ( ToAlias a
-         , ToAlias b
-         , ToAlias c
-         , ToAlias d
-         , ToAlias e
-         ) => ToAlias (a,b,c,d,e) where
-    toAlias x = to5 <$> (toAlias $ from5 x)
-
-instance ( ToAlias a
-         , ToAlias b
-         , ToAlias c
-         , ToAlias d
-         , ToAlias e
-         , ToAlias f
-         ) => ToAlias (a,b,c,d,e,f) where
-    toAlias x = to6 <$> (toAlias $ from6 x)
-
-instance ( ToAlias a
-         , ToAlias b
-         , ToAlias c
-         , ToAlias d
-         , ToAlias e
-         , ToAlias f
-         , ToAlias g
-         ) => ToAlias (a,b,c,d,e,f,g) where
-    toAlias x = to7 <$> (toAlias $ from7 x)
-
-instance ( ToAlias a
-         , ToAlias b
-         , ToAlias c
-         , ToAlias d
-         , ToAlias e
-         , ToAlias f
-         , ToAlias g
-         , ToAlias h
-         ) => ToAlias (a,b,c,d,e,f,g,h) where
-    toAlias x = to8 <$> (toAlias $ from8 x)
--- a/src/Database/Esqueleto/Experimental/ToAliasReference.hs
+++ b/src/Database/Esqueleto/Experimental/ToAliasReference.hs
@ -1,90 +0,0 @@
-{-# LANGUAGE FlexibleInstances #-}
-{-# LANGUAGE OverloadedStrings #-}
-{-# LANGUAGE TypeFamilies #-}
-
-module Database.Esqueleto.Experimental.ToAliasReference
-    where
-
-import Data.Coerce
-import Database.Esqueleto.Internal.Internal hiding (From, from, on)
-import Database.Esqueleto.Internal.PersistentImport
-
-{-# DEPRECATED ToAliasReferenceT "This type alias doesn't do anything. Please delete it. Will be removed in the next release." #-}
-type ToAliasReferenceT a = a
-
-- more tedious tuple magic
-class ToAliasReference a where
-    toAliasReference :: Ident -> a -> SqlQuery a
-
-instance ToAliasReference (SqlExpr (Value a)) where
-    toAliasReference aliasSource (ERaw m _)
-      | Just alias <- sqlExprMetaAlias m = pure $ ERaw m{sqlExprMetaIsReference = True} $ \_ info ->
-          (useIdent info aliasSource <> "." <> useIdent info alias, [])
-    toAliasReference _ e = pure e
-
-instance ToAliasReference (SqlExpr (Entity a)) where
-    toAliasReference aliasSource (ERaw m _)
-      | Just _ <- sqlExprMetaAlias m =
-          pure $ ERaw m{sqlExprMetaIsReference = True} $ \_ info ->
-            (useIdent info aliasSource, [])
-    toAliasReference _ e = pure e
-
-instance ToAliasReference (SqlExpr (Maybe (Entity a))) where
-    toAliasReference aliasSource e =
-        coerce <$> toAliasReference aliasSource (coerce e :: SqlExpr (Entity a))
-
-
-instance (ToAliasReference a, ToAliasReference b) => ToAliasReference (a, b) where
-    toAliasReference ident (a,b) = (,) <$> (toAliasReference ident a) <*> (toAliasReference ident b)
-
-instance ( ToAliasReference a
-         , ToAliasReference b
-         , ToAliasReference c
-         ) => ToAliasReference (a,b,c) where
-    toAliasReference ident x = fmap to3 $ toAliasReference ident $ from3 x
-
-instance ( ToAliasReference a
-         , ToAliasReference b
-         , ToAliasReference c
-         , ToAliasReference d
-         ) => ToAliasReference (a,b,c,d) where
-    toAliasReference ident x = fmap to4 $ toAliasReference ident $ from4 x
-
-instance ( ToAliasReference a
-         , ToAliasReference b
-         , ToAliasReference c
-         , ToAliasReference d
-         , ToAliasReference e
-         ) => ToAliasReference (a,b,c,d,e) where
-    toAliasReference ident x = fmap to5 $ toAliasReference ident $ from5 x
-
-instance ( ToAliasReference a
-         , ToAliasReference b
-         , ToAliasReference c
-         , ToAliasReference d
-         , ToAliasReference e
-         , ToAliasReference f
-         ) => ToAliasReference (a,b,c,d,e,f) where
-    toAliasReference ident x = to6 <$> (toAliasReference ident $ from6 x)
-
-instance ( ToAliasReference a
-         , ToAliasReference b
-         , ToAliasReference c
-         , ToAliasReference d
-         , ToAliasReference e
-         , ToAliasReference f
-         , ToAliasReference g
-         ) => ToAliasReference (a,b,c,d,e,f,g) where
-    toAliasReference ident x = to7 <$> (toAliasReference ident $ from7 x)
-
-instance ( ToAliasReference a
-         , ToAliasReference b
-         , ToAliasReference c
-         , ToAliasReference d
-         , ToAliasReference e
-         , ToAliasReference f
-         , ToAliasReference g
-         , ToAliasReference h
-         ) => ToAliasReference (a,b,c,d,e,f,g,h) where
-    toAliasReference ident x = to8 <$> (toAliasReference ident $ from8 x)
-
--- a/src/Database/Esqueleto/Experimental/ToMaybe.hs
+++ b/src/Database/Esqueleto/Experimental/ToMaybe.hs
@ -1,79 +0,0 @@
-{-# LANGUAGE FlexibleInstances #-}
-{-# LANGUAGE TypeFamilies #-}
-
-module Database.Esqueleto.Experimental.ToMaybe
-    where
-
-import Database.Esqueleto.Internal.Internal hiding (From(..), from, on)
-import Database.Esqueleto.Internal.PersistentImport (Entity(..))
-
-type family Nullable a where
-    Nullable (Maybe a) = a
-    Nullable a =  a
-
-class ToMaybe a where
-    type ToMaybeT a
-    toMaybe :: a -> ToMaybeT a
-
-instance ToMaybe (SqlExpr (Maybe a)) where
-    type ToMaybeT (SqlExpr (Maybe a)) = SqlExpr (Maybe a)
-    toMaybe = id
-
-instance ToMaybe (SqlExpr (Entity a)) where
-    type ToMaybeT (SqlExpr (Entity a)) = SqlExpr (Maybe (Entity a))
-    toMaybe (ERaw f m) = (ERaw f m)
-
-instance ToMaybe (SqlExpr (Value a)) where
-    type ToMaybeT (SqlExpr (Value a)) = SqlExpr (Value (Maybe (Nullable a)))
-    toMaybe = veryUnsafeCoerceSqlExprValue
-
-
-instance (ToMaybe a, ToMaybe b) => ToMaybe (a,b) where
-    type ToMaybeT (a, b) = (ToMaybeT a, ToMaybeT b)
-    toMaybe (a, b) = (toMaybe a, toMaybe b)
-
-instance ( ToMaybe a , ToMaybe b , ToMaybe c) => ToMaybe (a,b,c) where
-    type ToMaybeT (a, b, c) = (ToMaybeT a, ToMaybeT b, ToMaybeT c)
-    toMaybe = to3 . toMaybe . from3
-
-instance ( ToMaybe a , ToMaybe b , ToMaybe c , ToMaybe d) => ToMaybe (a,b,c,d) where
-    type ToMaybeT (a, b, c, d) = (ToMaybeT a, ToMaybeT b, ToMaybeT c, ToMaybeT d)
-    toMaybe = to4 . toMaybe . from4
-
-instance ( ToMaybe a , ToMaybe b , ToMaybe c , ToMaybe d , ToMaybe e) => ToMaybe (a,b,c,d,e) where
-    type ToMaybeT (a, b, c, d, e) = (ToMaybeT a, ToMaybeT b, ToMaybeT c, ToMaybeT d, ToMaybeT e)
-    toMaybe = to5 . toMaybe . from5
-
-instance ( ToMaybe a
-         , ToMaybe b
-         , ToMaybe c
-         , ToMaybe d
-         , ToMaybe e
-         , ToMaybe f
-         ) => ToMaybe (a,b,c,d,e,f) where
-    type ToMaybeT (a, b, c, d, e, f) = (ToMaybeT a, ToMaybeT b, ToMaybeT c, ToMaybeT d, ToMaybeT e, ToMaybeT f)
-    toMaybe = to6 . toMaybe . from6
-
-instance ( ToMaybe a
-         , ToMaybe b
-         , ToMaybe c
-         , ToMaybe d
-         , ToMaybe e
-         , ToMaybe f
-         , ToMaybe g
-         ) => ToMaybe (a,b,c,d,e,f,g) where
-    type ToMaybeT (a, b, c, d, e, f, g) = (ToMaybeT a, ToMaybeT b, ToMaybeT c, ToMaybeT d, ToMaybeT e, ToMaybeT f, ToMaybeT g)
-    toMaybe = to7 . toMaybe . from7
-
-instance ( ToMaybe a
-         , ToMaybe b
-         , ToMaybe c
-         , ToMaybe d
-         , ToMaybe e
-         , ToMaybe f
-         , ToMaybe g
-         , ToMaybe h
-         ) => ToMaybe (a,b,c,d,e,f,g,h) where
-     type ToMaybeT (a, b, c, d, e, f, g, h) = (ToMaybeT a, ToMaybeT b, ToMaybeT c, ToMaybeT d, ToMaybeT e, ToMaybeT f, ToMaybeT g, ToMaybeT h)
-     toMaybe = to8 . toMaybe . from8
-
--- a/src/Database/Esqueleto/Internal/Internal.hs
+++ b/src/Database/Esqueleto/Internal/Internal.hs
--- a/src/Database/Esqueleto/Internal/Language.hs
+++ b/src/Database/Esqueleto/Internal/Language.hs
@ -0,0 +1,140 @@
+{-# LANGUAGE DeriveDataTypeable #-}
+{-# LANGUAGE EmptyDataDecls #-}
+{-# LANGUAGE FlexibleContexts #-}
+{-# LANGUAGE FlexibleInstances #-}
+{-# LANGUAGE FunctionalDependencies #-}
+{-# LANGUAGE GADTs #-}
+{-# LANGUAGE MultiParamTypeClasses #-}
+{-# LANGUAGE TypeFamilies #-}
+{-# LANGUAGE UndecidableInstances #-}
+
+-- | This is an internal module, anything exported by this module
+-- may change without a major version bump.  Please use only
+-- "Database.Esqueleto" if possible.
+--
+-- This module is deprecated as of 3.4.0.1, and will be removed in 3.5.0.0.
+module Database.Esqueleto.Internal.Language
+    {-# DEPRECATED "Use Database.Esqueleto.Internal.Internal instead. This module will be removed in 3.5.0.0 " #-}
+    ( -- * The pretty face
+      from
+    , Value(..)
+    , ValueList(..)
+    , SomeValue(..)
+    , ToSomeValues(..)
+    , InnerJoin(..)
+    , CrossJoin(..)
+    , LeftOuterJoin(..)
+    , RightOuterJoin(..)
+    , FullOuterJoin(..)
+    , OnClauseWithoutMatchingJoinException(..)
+    , OrderBy
+    , DistinctOn
+    , Update
+    , Insertion
+    , LockingKind(..)
+    , SqlString
+    , ToBaseId(..)
+      -- * The guts
+    , JoinKind(..)
+    , IsJoinKind(..)
+    , BackendCompatible(..)
+    , PreprocessedFrom
+    , From
+    , FromPreprocess
+    , when_
+    , then_
+    , else_
+    , where_
+    , on
+    , groupBy
+    , orderBy
+    , rand
+    , asc
+    , desc
+    , limit
+    , offset
+    , distinct
+    , distinctOn
+    , don
+    , distinctOnOrderBy
+    , having
+    , locking
+    , sub_select
+    , (^.)
+    , (?.)
+    , val
+    , isNothing
+    , just
+    , nothing
+    , joinV
+    , withNonNull
+    , countRows
+    , count
+    , countDistinct
+    , not_
+    , (==.)
+    , (>=.)
+    , (>.)
+    , (<=.)
+    , (<.)
+    , (!=.)
+    , (&&.)
+    , (||.)
+    , between
+    , (+.)
+    , (-.)
+    , (/.)
+    , (*.)
+    , random_
+    , round_
+    , ceiling_
+    , floor_
+    , min_
+    , max_
+    , sum_
+    , avg_
+    , castNum
+    , castNumM
+    , coalesce
+    , coalesceDefault
+    , lower_
+    , upper_
+    , trim_
+    , ltrim_
+    , rtrim_
+    , length_
+    , left_
+    , right_
+    , like
+    , ilike
+    , (%)
+    , concat_
+    , (++.)
+    , castString
+    , subList_select
+    , valList
+    , justList
+    , in_
+    , notIn
+    , exists
+    , notExists
+    , set
+    , (=.)
+    , (+=.)
+    , (-=.)
+    , (*=.)
+    , (/=.)
+    , case_
+    , toBaseId
+    , (<#)
+    , (<&>)
+    , subSelect
+    , subSelectMaybe
+    , subSelectCount
+    , subSelectList
+    , subSelectForeign
+    , subSelectUnsafe
+    ) where
+
+import Database.Esqueleto.Internal.Internal
+import Database.Esqueleto.Internal.PersistentImport
--- a/src/Database/Esqueleto/Internal/PersistentImport.hs
+++ b/src/Database/Esqueleto/Internal/PersistentImport.hs
@ -138,6 +138,7 @@ module Database.Esqueleto.Internal.PersistentImport
    , getEntityId
    , getEntityDBName
    , getEntityUniques
+    , getEntityDBName
    ) where

 import Database.Persist.Sql hiding
--- a/src/Database/Esqueleto/Internal/Sql.hs
+++ b/src/Database/Esqueleto/Internal/Sql.hs
@ -0,0 +1,78 @@
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE ConstraintKinds #-}
+{-# LANGUAGE DeriveDataTypeable #-}
+{-# LANGUAGE EmptyDataDecls #-}
+{-# LANGUAGE FlexibleContexts #-}
+{-# LANGUAGE FlexibleInstances #-}
+{-# LANGUAGE FunctionalDependencies #-}
+{-# LANGUAGE GADTs #-}
+{-# LANGUAGE InstanceSigs #-}
+{-# LANGUAGE MultiParamTypeClasses #-}
+{-# LANGUAGE OverloadedStrings #-}
+{-# LANGUAGE Rank2Types #-}
+{-# LANGUAGE ScopedTypeVariables #-}
+{-# LANGUAGE TypeFamilies #-}
+{-# LANGUAGE UndecidableInstances #-}
+
+
+-- | This is an internal module, anything exported by this module
+-- may change without a major version bump.  Please use only
+-- "Database.Esqueleto" if possible.
+--
+-- This module is deprecated as of 3.4.0.1, and will be removed in 3.5.0.0.
+module Database.Esqueleto.Internal.Sql
+    {-# DEPRECATED "Use Database.Esqueleto.Internal.Internal instead. This module will be removed in 3.5.0.0 " #-}
+    ( -- * The pretty face
+      SqlQuery
+    , SqlExpr(..)
+    , SqlEntity
+    , select
+    , selectSource
+    , delete
+    , deleteCount
+    , update
+    , updateCount
+    , insertSelect
+    , insertSelectCount
+      -- * The guts
+    , unsafeSqlCase
+    , unsafeSqlBinOp
+    , unsafeSqlBinOpComposite
+    , unsafeSqlValue
+    , unsafeSqlCastAs
+    , unsafeSqlFunction
+    , unsafeSqlExtractSubField
+    , UnsafeSqlFunctionArgument
+    , OrderByClause
+    , rawSelectSource
+    , runSource
+    , rawEsqueleto
+    , toRawSql
+    , Mode(..)
+    , NeedParens(..)
+    , IdentState
+    , renderExpr
+    , initialIdentState
+    , IdentInfo
+    , SqlSelect(..)
+    , veryUnsafeCoerceSqlExprValue
+    , veryUnsafeCoerceSqlExprValueList
+    -- * Helper functions
+    , renderQueryToText
+    , renderQuerySelect
+    , renderQueryUpdate
+    , renderQueryDelete
+    , renderQueryInsertInto
+    , makeOrderByNoNewline
+    , uncommas'
+    , parens
+    , toArgList
+    , builderToText
+    , Ident(..)
+    , valkey
+    , valJ
+    , deleteKey
+    , associateJoin
+    ) where
+
+import Database.Esqueleto.Internal.Internal
--- a/src/Database/Esqueleto/Legacy.hs
+++ b/src/Database/Esqueleto/Legacy.hs
@ -1,416 +0,0 @@
-{-# LANGUAGE FlexibleContexts #-}
-{-# LANGUAGE FlexibleInstances #-}
-{-# LANGUAGE GADTs #-}
-{-# LANGUAGE RankNTypes #-}
-
-- | WARNING
--
-- This module is introduced in version @3.5.0.0@ to provide a smooth migration
-- experience from this legacy syntax to the new and improved syntax. If you've
-- imported this module, it means you've decided to use the old syntax for
-- a little bit longer, rather than migrate to the new stuff. That's fine!
--
-- But you should know that this module, and all of the legacy syntax, will be
-- completely removed from the library in version @4.0.0.0@.
--
-- The @esqueleto@ EDSL (embedded domain specific language).
-- This module replaces @Database.Persist@, so instead of
-- importing that module you should just import this one:
--
-- @
-- -- For a module using just esqueleto.
-- import Database.Esqueleto
-- @
--
-- If you need to use @persistent@'s default support for queries
-- as well, either import it qualified:
--
-- @
-- -- For a module that mostly uses esqueleto.
-- import Database.Esqueleto
-- import qualified Database.Persist as P
-- @
--
-- or import @esqueleto@ itself qualified:
--
-- @
-- -- For a module that uses esqueleto just on some queries.
-- import Database.Persist
-- import qualified Database.Esqueleto as E
-- @
--
-- Other than identifier name clashes, @esqueleto@ does not
-- conflict with @persistent@ in any way.
-module Database.Esqueleto.Legacy
-  ( -- * Setup
-    -- $setup
-
-    -- * Introduction
-    -- $introduction
-
-    -- * Getting started
-    -- $gettingstarted
-
-    -- * @esqueleto@'s Language
-    where_, on, groupBy, orderBy, rand, asc, desc, limit, offset
-             , distinct, distinctOn, don, distinctOnOrderBy, having, locking
-             , sub_select, (^.), (?.)
-             , val, isNothing, just, nothing, joinV, withNonNull
-             , countRows, count, countDistinct
-             , not_, (==.), (>=.), (>.), (<=.), (<.), (!=.), (&&.), (||.)
-             , between, (+.), (-.), (/.), (*.)
-             , random_, round_, ceiling_, floor_
-             , min_, max_, sum_, avg_, castNum, castNumM
-             , coalesce, coalesceDefault
-             , lower_, upper_, trim_, ltrim_, rtrim_, length_, left_, right_
-             , like, ilike, (%), concat_, (++.), castString
-             , subList_select, valList, justList
-             , in_, notIn, exists, notExists
-             , set, (=.), (+=.), (-=.), (*=.), (/=.)
-             , case_, toBaseId
-  , subSelect
-  , subSelectMaybe
-  , subSelectCount
-  , subSelectForeign
-  , subSelectList
-  , subSelectUnsafe
-  , ToBaseId(..)
-  , when_
-  , then_
-  , else_
-  , from
-  , Value(..)
-  , ValueList(..)
-  , OrderBy
-  , DistinctOn
-  , LockingKind(..)
-  , SqlString
-    -- ** Joins
-  , InnerJoin(..)
-  , CrossJoin(..)
-  , LeftOuterJoin(..)
-  , RightOuterJoin(..)
-  , FullOuterJoin(..)
-  , JoinKind(..)
-  , OnClauseWithoutMatchingJoinException(..)
-    -- * SQL backend
-  , SqlQuery
-  , SqlExpr
-  , SqlEntity
-  , select
-  , selectOne
-  , selectSource
-  , delete
-  , deleteCount
-  , update
-  , updateCount
-  , insertSelect
-  , insertSelectCount
-  , (<#)
-  , (<&>)
-  -- ** Rendering Queries
-  , renderQueryToText
-  , renderQuerySelect
-  , renderQueryUpdate
-  , renderQueryDelete
-  , renderQueryInsertInto
-    -- * Internal.Language
-  , From
-    -- * RDBMS-specific modules
-    -- $rdbmsSpecificModules
-
-    -- * Helpers
-  , valkey
-  , valJ
-  , associateJoin
-
-    -- * Re-exports
-    -- $reexports
-  , deleteKey
-  , module Database.Esqueleto.Internal.PersistentImport
-  ) where
-
-import Database.Esqueleto.Internal.Internal
-import Database.Esqueleto.Internal.PersistentImport
-
-
-- $setup
--
-- If you're already using @persistent@, then you're ready to use
-- @esqueleto@, no further setup is needed.  If you're just
-- starting a new project and would like to use @esqueleto@, take
-- a look at @persistent@'s book first
-- (<http://www.yesodweb.com/book/persistent>) to learn how to
-- define your schema.
-
-
----------------------------------------------------------------------
-
-
-- $introduction
--
-- The main goals of @esqueleto@ are to:
--
--   * Be easily translatable to SQL.  When you take a look at a
--   @esqueleto@ query, you should be able to know exactly how
--   the SQL query will end up.  (As opposed to being a
--   relational algebra EDSL such as HaskellDB, which is
--   non-trivial to translate into SQL.)
--
--   * Support the most widely used SQL features.  We'd like you to be
--   able to use @esqueleto@ for all of your queries, no
--   exceptions.  Send a pull request or open an issue on our
--   project page (<https://github.com/prowdsponsor/esqueleto>) if
--   there's anything missing that you'd like to see.
--
--   * Be as type-safe as possible.  We strive to provide as many
--   type checks as possible.  If you get bitten by some invalid
--   code that type-checks, please open an issue on our project
--   page so we can take a look.
--
-- However, it is /not/ a goal to be able to write portable SQL.
-- We do not try to hide the differences between DBMSs from you,
-- and @esqueleto@ code that works for one database may not work
-- on another.  This is a compromise we have to make in order to
-- give you as much control over the raw SQL as possible without
-- losing too much convenience.  This also means that you may
-- type-check a query that doesn't work on your DBMS.
-
-
----------------------------------------------------------------------
-
-
-- $gettingstarted
--
-- We like clean, easy-to-read EDSLs.  However, in order to
-- achieve this goal we've used a lot of type hackery, leading to
-- some hard-to-read type signatures.  On this section, we'll try
-- to build some intuition about the syntax.
--
-- For the following examples, we'll use this example schema:
--
-- @
-- share [mkPersist sqlSettings, mkMigrate \"migrateAll\"] [persist|
--   Person
--     name String
--     age Int Maybe
--     deriving Eq Show
--   BlogPost
--     title String
--     authorId PersonId
--     deriving Eq Show
--   Follow
--     follower PersonId
--     followed PersonId
--     deriving Eq Show
-- |]
-- @
--
-- Most of @esqueleto@ was created with @SELECT@ statements in
-- mind, not only because they're the most common but also
-- because they're the most complex kind of statement.  The most
-- simple kind of @SELECT@ would be:
--
-- @
-- SELECT *
-- FROM Person
-- @
--
-- In @esqueleto@, we may write the same query above as:
--
-- @
-- do people <- 'select' $
--              'from' $ \\person -> do
--              return person
--    liftIO $ mapM_ (putStrLn . personName . entityVal) people
-- @
--
-- The expression above has type @SqlPersist m ()@, while
-- @people@ has type @[Entity Person]@.  The query above will be
-- translated into exactly the same query we wrote manually, but
-- instead of @SELECT *@ it will list all entity fields (using
-- @*@ is not robust).  Note that @esqueleto@ knows that we want
-- an @Entity Person@ just because of the @personName@ that we're
-- printing later.
--
-- However, most of the time we need to filter our queries using
-- @WHERE@.  For example:
--
-- @
-- SELECT *
-- FROM Person
-- WHERE Person.name = \"John\"
-- @
--
-- In @esqueleto@, we may write the same query above as:
--
-- @
-- 'select' $
-- 'from' $ \\p -> do
-- 'where_' (p '^.' PersonName '==.' 'val' \"John\")
-- return p
-- @
--
-- Although @esqueleto@'s code is a bit more noisy, it's has
-- almost the same structure (save from the @return@).  The
-- @('^.')@ operator is used to project a field from an entity.
-- The field name is the same one generated by @persistent@'s
-- Template Haskell functions.  We use 'val' to lift a constant
-- Haskell value into the SQL query.
--
-- Another example would be:
--
-- @
-- SELECT *
-- FROM Person
-- WHERE Person.age >= 18
-- @
--
-- In @esqueleto@, we may write the same query above as:
--
-- @
-- 'select' $
-- 'from' $ \\p -> do
-- 'where_' (p '^.' PersonAge '>=.' 'just' ('val' 18))
-- return p
-- @
--
-- Since @age@ is an optional @Person@ field, we use 'just' to lift
-- @'val' 18 :: SqlExpr (Value Int)@ into @just ('val' 18) ::
-- SqlExpr (Value (Maybe Int))@.
--
-- Implicit joins are represented by tuples.  For example, to get
-- the list of all blog posts and their authors, we could write:
--
-- @
-- SELECT BlogPost.*, Person.*
-- FROM BlogPost, Person
-- WHERE BlogPost.authorId = Person.id
-- ORDER BY BlogPost.title ASC
-- @
--
-- In @esqueleto@, we may write the same query above as:
--
-- @
-- 'select' $
-- 'from' $ \\(b, p) -> do
-- 'where_' (b '^.' BlogPostAuthorId '==.' p '^.' PersonId)
-- 'orderBy' ['asc' (b '^.' BlogPostTitle)]
-- return (b, p)
-- @
--
-- However, you may want your results to include people who don't
-- have any blog posts as well using a @LEFT OUTER JOIN@:
--
-- @
-- SELECT Person.*, BlogPost.*
-- FROM Person LEFT OUTER JOIN BlogPost
-- ON Person.id = BlogPost.authorId
-- ORDER BY Person.name ASC, BlogPost.title ASC
-- @
--
-- In @esqueleto@, we may write the same query above as:
--
-- @
-- 'select' $
-- 'from' $ \\(p `'LeftOuterJoin`` mb) -> do
-- 'on' ('just' (p '^.' PersonId) '==.' mb '?.' BlogPostAuthorId)
-- 'orderBy' ['asc' (p '^.' PersonName), 'asc' (mb '?.' BlogPostTitle)]
-- return (p, mb)
-- @
--
-- On a @LEFT OUTER JOIN@ the entity on the right hand side may
-- not exist (i.e. there may be a @Person@ without any
-- @BlogPost@s), so while @p :: SqlExpr (Entity Person)@, we have
-- @mb :: SqlExpr (Maybe (Entity BlogPost))@.  The whole
-- expression above has type @SqlPersist m [(Entity Person, Maybe
-- (Entity BlogPost))]@.  Instead of using @(^.)@, we used
-- @('?.')@ to project a field from a @Maybe (Entity a)@.
--
-- We are by no means limited to joins of two tables, nor by
-- joins of different tables.  For example, we may want a list
-- of the @Follow@ entity:
--
-- @
-- SELECT P1.*, Follow.*, P2.*
-- FROM Person AS P1
-- INNER JOIN Follow ON P1.id = Follow.follower
-- INNER JOIN Person AS P2 ON P2.id = Follow.followed
-- @
--
-- In @esqueleto@, we may write the same query above as:
--
-- @
-- 'select' $
-- 'from' $ \\(p1 `'InnerJoin`` f `'InnerJoin`` p2) -> do
-- 'on' (p1 '^.' PersonId '==.' f '^.' FollowFollower)
-- 'on' (p2 '^.' PersonId '==.' f '^.' FollowFollowed)
-- return (p1, f, p2)
-- @
--
-- We also currently support @UPDATE@ and @DELETE@ statements.
-- For example:
--
-- @
-- do 'update' $ \\p -> do
--      'set' p [ PersonName '=.' 'val' \"João\" ]
--      'where_' (p '^.' PersonName '==.' 'val' \"Joao\")
--    'delete' $
--      'from' $ \\p -> do
--      'where_' (p '^.' PersonAge '<.' 'just' ('val' 14))
-- @
--
-- The results of queries can also be used for insertions.
-- In @SQL@, we might write the following, inserting a new blog
-- post for every user:
--
-- @
-- INSERT INTO BlogPost
-- SELECT ('Group Blog Post', id)
-- FROM Person
-- @
--
-- In @esqueleto@, we may write the same query above as:
--
-- @
--  'insertSelect' $ 'from' $ \\p->
--  return $ BlogPost '<#' \"Group Blog Post\" '<&>' (p '^.' PersonId)
-- @
--
-- Individual insertions can be performed through Persistent's
-- 'insert' function, reexported for convenience.
-
-
----------------------------------------------------------------------
-
-
-- $reexports
--
-- We re-export many symbols from @persistent@ for convenince:
--
--  * \"Store functions\" from "Database.Persist".
--
--  * Everything from "Database.Persist.Class" except for
--    @PersistQuery@ and @delete@ (use 'deleteKey' instead).
--
--  * Everything from "Database.Persist.Types" except for
--    @Update@, @SelectOpt@, @BackendSpecificFilter@ and @Filter@.
--
--  * Everything from "Database.Persist.Sql" except for
--    @deleteWhereCount@ and @updateWhereCount@.
-
-
----------------------------------------------------------------------
-
-
-- $rdbmsSpecificModules
--
-- There are many differences between SQL syntax and functions
-- supported by different RDBMSs.  Since version 2.2.8,
-- @esqueleto@ includes modules containing functions that are
-- specific to a given RDBMS.
--
--  * PostgreSQL: "Database.Esqueleto.PostgreSQL".
--
-- In order to use these functions, you need to explicitly import
-- their corresponding modules, they're not re-exported here.
--- a/src/Database/Esqueleto/PostgreSQL.hs
+++ b/src/Database/Esqueleto/PostgreSQL.hs
@ -1,8 +1,6 @@
 {-# LANGUAGE CPP #-}
 {-# LANGUAGE FlexibleContexts #-}
-{-# LANGUAGE FlexibleInstances #-}
 {-# LANGUAGE GADTs #-}
-{-# LANGUAGE MultiParamTypeClasses #-}
 {-# LANGUAGE OverloadedStrings #-}
 {-# LANGUAGE Rank2Types #-}
 {-# LANGUAGE ScopedTypeVariables #-}
@ -28,7 +26,6 @@ module Database.Esqueleto.PostgreSQL
    , insertSelectWithConflict
    , insertSelectWithConflictCount
    , filterWhere
-    , values
    -- * Internal
    , unsafeSqlAggregateFunction
    ) where
@ -36,20 +33,17 @@ module Database.Esqueleto.PostgreSQL
 #if __GLASGOW_HASKELL__ < 804
 import Data.Semigroup
 #endif
-import Control.Arrow (first)
+import Control.Arrow (first, (***))
 import Control.Exception (throw)
 import Control.Monad (void)
 import Control.Monad.IO.Class (MonadIO(..))
 import qualified Control.Monad.Trans.Reader as R
 import Data.Int (Int64)
-import qualified Data.List.NonEmpty as NE
-import Data.Maybe
+import Data.List.NonEmpty (NonEmpty((:|)))
+import qualified Data.List.NonEmpty as NonEmpty
 import Data.Proxy (Proxy(..))
 import qualified Data.Text.Internal.Builder as TLB
-import qualified Data.Text.Lazy as TL
 import Data.Time.Clock (UTCTime)
-import qualified Database.Esqueleto.Experimental as Ex
-import qualified Database.Esqueleto.Experimental.From as Ex
 import Database.Esqueleto.Internal.Internal hiding (random_)
 import Database.Esqueleto.Internal.PersistentImport hiding (upsert, upsertBy)
 import Database.Persist.Class (OnlyOneUniqueKey)
@ -91,18 +85,18 @@ unsafeSqlAggregateFunction
    -> a
    -> [OrderByClause]
    -> SqlExpr (Value b)
-unsafeSqlAggregateFunction name mode args orderByClauses = ERaw noMeta $ \_ info ->
+unsafeSqlAggregateFunction name mode args orderByClauses = ERaw Never $ \info ->
    let (orderTLB, orderVals) = makeOrderByNoNewline info orderByClauses
        -- Don't add a space if we don't have order by clauses
        orderTLBSpace =
            case orderByClauses of
-                []    -> ""
+                [] -> ""
                (_:_) -> " "
        (argsTLB, argsVals) =
-            uncommas' $ map (\(ERaw _ f) -> f Never info) $ toArgList args
+            uncommas' $ map (\v -> valueToRawSqlParens SqlFunctionError v info) $ toArgList args
        aggMode =
            case mode of
-                AggModeAll      -> ""
+                AggModeAll -> ""
                -- ALL is the default, so we don't need to
                -- specify it
                AggModeDistinct -> "DISTINCT "
@ -190,7 +184,7 @@ upsert
    )
    => record
    -- ^ new record to insert
-    -> [SqlExpr (Entity record) -> SqlExpr Update]
+    -> [SqlExpr (Update record)]
    -- ^ updates to perform if the record already exists
    -> R.ReaderT SqlBackend m (Entity record)
    -- ^ the record in the database after the operation
@ -208,7 +202,7 @@ upsertBy
    -- ^ uniqueness constraint to find by
    -> record
    -- ^ new record to insert
-    -> [SqlExpr (Entity record) -> SqlExpr Update]
+    -> [SqlExpr (Update record)]
    -- ^ updates to perform if the record already exists
    -> R.ReaderT SqlBackend m (Entity record)
    -- ^ the record in the database after the operation
@ -284,13 +278,13 @@ insertSelectWithConflict
    -- a unique "MyUnique 0", "MyUnique undefined" would work as well.
    -> SqlQuery (SqlExpr (Insertion val))
    -- ^ Insert query.
-    -> (SqlExpr (Entity val) -> SqlExpr (Entity val) -> [SqlExpr (Entity val) -> SqlExpr Update])
+    -> (SqlExpr (Entity val) -> SqlExpr (Entity val) -> [SqlExpr (Update val)])
    -- ^ A list of updates to be applied in case of the constraint being
    -- violated. The expression takes the current and excluded value to produce
    -- the updates.
    -> SqlWriteT m ()
-insertSelectWithConflict unique query a =
-    void $ insertSelectWithConflictCount unique query a
+insertSelectWithConflict unique query =
+    void . insertSelectWithConflictCount unique query

 -- | Same as 'insertSelectWithConflict' but returns the number of rows affected.
 --
@ -300,22 +294,22 @@ insertSelectWithConflictCount
     . (FinalResult a, KnowResult a ~ Unique val, MonadIO m, PersistEntity val)
    => a
    -> SqlQuery (SqlExpr (Insertion val))
-    -> (SqlExpr (Entity val) -> SqlExpr (Entity val) -> [SqlExpr (Entity val) -> SqlExpr Update])
+    -> (SqlExpr (Entity val) -> SqlExpr (Entity val) -> [SqlExpr (Update val)])
    -> SqlWriteT m Int64
 insertSelectWithConflictCount unique query conflictQuery = do
    conn <- R.ask
    uncurry rawExecuteCount $
        combine
-            (toRawSql INSERT_INTO (conn, initialIdentState) query)
+            (toRawSql INSERT_INTO (conn, initialIdentState) (fmap EInsertFinal query))
            (conflict conn)
  where
    proxy :: Proxy val
    proxy = Proxy
    updates = conflictQuery entCurrent entExcluded
    combine (tlb1,vals1) (tlb2,vals2) = (builderToText (tlb1 `mappend` tlb2), vals1 ++ vals2)
-    entExcluded = unsafeSqlEntity (I "excluded")
+    entExcluded = EEntity $ I "excluded"
    tableName = unEntityNameDB . getEntityDBName . entityDef
-    entCurrent = unsafeSqlEntity (I (tableName proxy))
+    entCurrent = EEntity $ I (tableName proxy)
    uniqueDef = toUniqueDef unique
    constraint = TLB.fromText . unConstraintNameDB . uniqueDBName $ uniqueDef
    renderedUpdates :: (BackendCompatible SqlBackend backend) => backend -> (TLB.Builder, [PersistValue])
@ -363,76 +357,13 @@ filterWhere
    -> SqlExpr (Value Bool)
    -- ^ Filter clause
    -> SqlExpr (Value a)
-filterWhere aggExpr clauseExpr = ERaw noMeta $ \_ info ->
+filterWhere aggExpr clauseExpr = ERaw Never $ \info ->
    let (aggBuilder, aggValues) = case aggExpr of
-            ERaw _ aggF     -> aggF Never info
+            ERaw _ aggF     -> aggF info
+            ECompositeKey _ -> throw $ CompositeKeyErr FilterWhereAggError
        (clauseBuilder, clauseValues) = case clauseExpr of
-            ERaw _ clauseF  -> clauseF Never info
+            ERaw _ clauseF  -> clauseF info
+            ECompositeKey _ -> throw $ CompositeKeyErr FilterWhereClauseError
    in ( aggBuilder <> " FILTER (WHERE " <> clauseBuilder <> ")"
       , aggValues <> clauseValues
       )
-
-
-- | Allows to use `VALUES (..)` in-memory set of values
-- in RHS of `from` expressions. Useful for JOIN's on
-- known values which also can be additionally preprocessed
-- somehow on db side with usage of inner PostgreSQL capabilities.
--
--
-- Example of usage:
--
-- @
-- share [mkPersist sqlSettings] [persistLowerCase|
--   User
--     name Text
--     age Int
--     deriving Eq Show
--
-- select $ do
--  bound :& user <- from $
--      values (   (val (10 :: Int), val ("ten" :: Text))
--            :| [ (val 20, val "twenty")
--               , (val 30, val "thirty") ]
--            )
--      `InnerJoin` table User
--      `on` (\((bound, _boundName) :& user) -> user^.UserAge >=. bound)
--  groupBy bound
--  pure (bound, count @Int $ user^.UserName)
-- @
--
-- @since 3.5.2.3
-values :: (ToSomeValues a, Ex.ToAliasReference a, Ex.ToAlias a) => NE.NonEmpty a -> Ex.From a
-values exprs = Ex.From $ do
-    ident <- newIdentFor $ DBName "vq"
-    alias <- Ex.toAlias $ NE.head exprs
-    ref   <- Ex.toAliasReference ident alias
-    let aliasIdents = mapMaybe (\someVal -> case someVal of
-            SomeValue (ERaw aliasMeta _) -> sqlExprMetaAlias aliasMeta
-            ) $ toSomeValues ref
-    pure (ref, const $ mkExpr ident aliasIdents)
-  where
-    someValueToSql :: IdentInfo -> SomeValue -> (TLB.Builder, [PersistValue])
-    someValueToSql info (SomeValue expr) = materializeExpr info expr
-
-    mkValuesRowSql :: IdentInfo -> [SomeValue] -> (TLB.Builder, [PersistValue])
-    mkValuesRowSql info vs =
-        let materialized = someValueToSql info <$> vs
-            valsSql = TLB.toLazyText . fst <$> materialized
-            params = concatMap snd materialized
-        in (TLB.fromLazyText $ "(" <> TL.intercalate "," valsSql <> ")", params)
-
-    -- (VALUES (v11, v12,..), (v21, v22,..)) as "vq"("v1", "v2",..)
-    mkExpr :: Ident -> [Ident] -> IdentInfo -> (TLB.Builder, [PersistValue])
-    mkExpr valsIdent colIdents info =
-        let materialized = mkValuesRowSql info . toSomeValues <$> NE.toList exprs
-            (valsSql, params) =
-                ( TL.intercalate "," $ map (TLB.toLazyText . fst) materialized
-                , concatMap snd materialized
-                )
-            colsAliases = TL.intercalate "," (map (TLB.toLazyText . useIdent info) colIdents)
-        in
-            ( "(VALUES " <> TLB.fromLazyText valsSql <> ") AS "
-            <> useIdent info valsIdent
-            <> "(" <> TLB.fromLazyText colsAliases <> ")"
-            , params
-            )
--- a/src/Database/Esqueleto/PostgreSQL/JSON.hs
+++ b/src/Database/Esqueleto/PostgreSQL/JSON.hs
@ -136,8 +136,9 @@ module Database.Esqueleto.PostgreSQL.JSON
    ) where

 import Data.Text (Text)
-import Database.Esqueleto.Internal.Internal hiding ((-.), (?.), (||.))
+import Database.Esqueleto.Internal.Language hiding ((-.), (?.), (||.))
 import Database.Esqueleto.Internal.PersistentImport
+import Database.Esqueleto.Internal.Sql
 import Database.Esqueleto.PostgreSQL.JSON.Instances

 infixl 6 ->., ->>., #>., #>>.
--- a/src/Database/Esqueleto/PostgreSQL/JSON/Instances.hs
+++ b/src/Database/Esqueleto/PostgreSQL/JSON/Instances.hs
@ -15,8 +15,9 @@ import Data.String (IsString(..))
 import Data.Text (Text)
 import qualified Data.Text as T (concat, pack)
 import qualified Data.Text.Encoding as TE (decodeUtf8, encodeUtf8)
+import Database.Esqueleto (Value, just, val)
 import Database.Esqueleto.Internal.PersistentImport
-import Database.Esqueleto.Internal.Internal (SqlExpr, Value, just, val)
+import Database.Esqueleto.Internal.Sql (SqlExpr)
 import GHC.Generics (Generic)

 -- | Newtype wrapper around any type with a JSON representation.
--- a/stack-8.10.yaml
+++ b/stack-8.10.yaml
@ -6,6 +6,7 @@ packages:

 extra-deps:
 - lift-type-0.1.0.1
+- attoparsec-0.14.1
 - persistent-2.13.0.0
 - persistent-sqlite-2.13.0.0
 - persistent-mysql-2.13.0.0
--- a/stack-nightly.yaml
+++ b/stack-nightly.yaml
@ -1,14 +1,6 @@
-resolver: nightly-2022-03-29
-
+resolver: nightly-2021-05-05
 packages:
-  - "."
+  - '.'
  - 'examples'


-extra-deps:
-  - time-1.12.1
-  - base-compat-0.12.1
-  - directory-1.3.7.0
-  - process-1.6.14.0
-  - Cabal-3.6.3.0
-  - unix-2.7.2.2
--- a/stack-nightly.yaml.lock
+++ b/stack-nightly.yaml.lock
@ -3,52 +3,10 @@
 # For more information, please see the documentation at:
 #   https://docs.haskellstack.org/en/stable/lock_files

-packages:
- completed:
-    hackage: time-1.12.1@sha256:af1fafc1fb66e3d0afb66fb5ab8629f74c038bebd42c234b581aff7abc201089,6295
-    pantry-tree:
-      size: 7208
-      sha256: 96205222b57c39156ee646d710a4100a119dc28f211c57cacaf741f6c1bb35da
-  original:
-    hackage: time-1.12.1
- completed:
-    hackage: base-compat-0.12.1@sha256:20e50848d9dfee1523fafe8950060b04fae43d402c15553da5c7cacd116f7846,6960
-    pantry-tree:
-      size: 9038
-      sha256: 2f2c14615443954f117613d77835234b598718e611fb4cf4522e01980bf1bcbd
-  original:
-    hackage: base-compat-0.12.1
- completed:
-    hackage: directory-1.3.7.0@sha256:d44788eac41268d951679fdcc343adc8a65fcf5b016bdf6c1f996bf78dde798e,2940
-    pantry-tree:
-      size: 3433
-      sha256: 2352834a6424cc8b462706c15e08bb721e120829b147b6d798eade4ebce425f5
-  original:
-    hackage: directory-1.3.7.0
- completed:
-    hackage: process-1.6.14.0@sha256:b6ad76fd3f4bf133cdc2dc9176e23447f2a0a8e9316047d53154cd11f871446d,2845
-    pantry-tree:
-      size: 1544
-      sha256: 72300155a8fd5a91f6b25dfebb77db05aa27a0b866dbfb2d7098c5e4580ca105
-  original:
-    hackage: process-1.6.14.0
- completed:
-    hackage: Cabal-3.6.3.0@sha256:ff97c442b0c679c1c9876acd15f73ac4f602b973c45bde42b43ec28265ee48f4,12459
-    pantry-tree:
-      size: 19757
-      sha256: b250a53bdb56844f047a2927833bb565b936a289abfa85dfc2a63148d776368a
-  original:
-    hackage: Cabal-3.6.3.0
- completed:
-    hackage: unix-2.7.2.2@sha256:15f5365c5995634e45de1772b9504761504a310184e676bc2ef60a14536dbef9,3496
-    pantry-tree:
-      size: 3536
-      sha256: 36434ced74d679622d61b69e8d92e1bd632d9ef3e284c63094653b2e473b0553
-  original:
-    hackage: unix-2.7.2.2
+packages: []
 snapshots:
 - completed:
-    size: 539378
-    url: https://raw.githubusercontent.com/commercialhaskell/stackage-snapshots/master/nightly/2022/3/29.yaml
-    sha256: c959441a05f6fa4d45ae6e258290f04d399245b8436263b4abb525c7f73da6a5
-  original: nightly-2022-03-29
+    size: 581922
+    url: https://raw.githubusercontent.com/commercialhaskell/stackage-snapshots/master/nightly/2021/5/5.yaml
+    sha256: 70797737e072284037792abaffd399e029da7ec3c855fd27b16898662f285d82
+  original: nightly-2021-05-05
--- a/test/Common/Test.hs
+++ b/test/Common/Test.hs
--- a/test/Common/Test/Import.hs
+++ b/test/Common/Test/Import.hs
@ -1,87 +0,0 @@
-{-# LANGUAGE CPP, AllowAmbiguousTypes #-}
-{-# LANGUAGE ConstraintKinds #-}
-{-# LANGUAGE DataKinds #-}
-{-# LANGUAGE DeriveGeneric #-}
-{-# LANGUAGE DerivingStrategies #-}
-{-# LANGUAGE EmptyDataDecls #-}
-{-# LANGUAGE FlexibleContexts #-}
-{-# LANGUAGE FlexibleInstances #-}
-{-# LANGUAGE GADTs #-}
-{-# LANGUAGE GeneralizedNewtypeDeriving #-}
-{-# LANGUAGE MultiParamTypeClasses #-}
-{-# LANGUAGE OverloadedStrings #-}
-{-# LANGUAGE PartialTypeSignatures #-}
-{-# LANGUAGE QuasiQuotes #-}
-{-# LANGUAGE ScopedTypeVariables #-}
-{-# LANGUAGE StandaloneDeriving #-}
-{-# LANGUAGE TemplateHaskell #-}
-{-# LANGUAGE TypeApplications #-}
-{-# LANGUAGE TypeFamilies #-}
-{-# LANGUAGE TypeSynonymInstances #-}
-{-# LANGUAGE UndecidableInstances #-}
-
-module Common.Test.Import
-    ( module Common.Test.Import
-    , module X
-    ) where
-
-import System.Environment
-import Control.Applicative
-import Common.Test.Models as X
-import Database.Esqueleto.Experimental as X hiding (random_)
-import Test.Hspec as X
-import UnliftIO as X
-import Control.Monad
-import Test.QuickCheck
-import Data.Text  as X (Text)
-import Control.Monad.Trans.Reader as X (ReaderT, mapReaderT, ask)
-
-type SpecDb = SpecWith ConnectionPool
-
-asserting :: MonadIO f => IO () -> SqlPersistT f ()
-asserting a = liftIO a
-
-noExceptions :: Expectation
-noExceptions = pure ()
-
-itDb
-    :: (HasCallStack)
-    => String
-    -> SqlPersistT IO x
-    -> SpecDb
-itDb message action = do
-    it message $ \connection -> do
-        void $ testDb connection action
-
-propDb
-    :: (HasCallStack, Testable a)
-    => String
-    -> ((SqlPersistT IO () -> IO ()) -> a )
-    -> SpecDb
-propDb message action = do
-    it message $ \connection -> do
-        property (action (testDb connection))
-
-testDb :: ConnectionPool -> SqlPersistT IO a -> IO a
-testDb conn action =
-    liftIO $ flip runSqlPool conn $ do
-        a <- action
-        transactionUndo
-        pure a
-
-setDatabaseState
-    :: SqlPersistT IO a
-    -> SqlPersistT IO ()
-    -> SpecWith ConnectionPool
-    -> SpecWith ConnectionPool
-setDatabaseState create clean test =
-    beforeWith (\conn -> runSqlPool create conn >> pure conn) $
-    after (\conn -> runSqlPool clean conn) $
-    test
-
-isCI :: IO Bool
-isCI =  do
-    env <- getEnvironment
-    return $ case lookup "TRAVIS" env <|> lookup "CI" env of
-        Just "true" -> True
-        _ -> False
--- a/test/Common/Test/Models.hs
+++ b/test/Common/Test/Models.hs
@ -1,189 +0,0 @@
-{-# LANGUAGE CPP #-}
-{-# LANGUAGE ConstraintKinds #-}
-{-# LANGUAGE DataKinds #-}
-{-# LANGUAGE DeriveGeneric #-}
-{-# LANGUAGE DerivingStrategies #-}
-{-# LANGUAGE EmptyDataDecls #-}
-{-# LANGUAGE FlexibleContexts #-}
-{-# LANGUAGE FlexibleInstances #-}
-{-# LANGUAGE GADTs #-}
-{-# LANGUAGE GeneralizedNewtypeDeriving #-}
-{-# LANGUAGE MultiParamTypeClasses #-}
-{-# LANGUAGE OverloadedStrings #-}
-{-# LANGUAGE PartialTypeSignatures #-}
-{-# LANGUAGE QuasiQuotes #-}
-{-# LANGUAGE ScopedTypeVariables #-}
-{-# LANGUAGE StandaloneDeriving #-}
-{-# LANGUAGE TemplateHaskell #-}
-{-# LANGUAGE TypeApplications #-}
-{-# LANGUAGE TypeFamilies #-}
-{-# LANGUAGE TypeSynonymInstances #-}
-{-# LANGUAGE UndecidableInstances #-}
-
-module Common.Test.Models where
-
-import Data.Time
-import Database.Esqueleto.Experimental
-import Database.Persist.Sql
-import Database.Persist.TH
-
-share [mkPersist sqlSettings, mkMigrate "migrateAll"] [persistUpperCase|
-  Foo
-    name Int
-    Primary name
-    deriving Show Eq Ord
-  Bar
-    quux FooId
-    deriving Show Eq Ord
-  Baz
-    blargh FooId
-    deriving Show Eq
-  Shoop
-    baz BazId
-    deriving Show Eq
-  Asdf
-    shoop ShoopId
-    deriving Show Eq
-  Another
-    why BazId
-  YetAnother
-    argh ShoopId
-
-  Person
-    name String
-    age Int Maybe
-    weight Int Maybe
-    favNum Int
-    deriving Eq Show Ord
-  BlogPost
-    title String
-    authorId PersonId
-    deriving Eq Show
-  Comment
-    body String
-    blog BlogPostId
-    deriving Eq Show
-  CommentReply
-    body String
-    comment CommentId
-  Profile
-    name String
-    person PersonId
-    deriving Eq Show
-  Reply
-    guy PersonId
-    body String
-    deriving Eq Show
-
-  Lord
-    county String maxlen=100
-    dogs Int Maybe
-    Primary county
-    deriving Eq Show
-
-  Deed
-    contract String maxlen=100
-    ownerId LordId maxlen=100
-    Primary contract
-    deriving Eq Show
-
-  Follow
-    follower PersonId
-    followed PersonId
-    deriving Eq Show
-
-  CcList
-    names [String]
-
-  Frontcover
-    number Int
-    title String
-    Primary number
-    deriving Eq Show
-  Article
-    title String
-    frontcoverNumber Int
-    Foreign Frontcover fkfrontcover frontcoverNumber
-    deriving Eq Show
-  ArticleMetadata
-    articleId ArticleId
-    Primary articleId
-    deriving Eq Show
-  Tag
-    name String maxlen=100
-    Primary name
-    deriving Eq Show
-  ArticleTag
-    articleId ArticleId
-    tagId     TagId maxlen=100
-    Primary   articleId tagId
-    deriving Eq Show
-  Article2
-    title String
-    frontcoverId FrontcoverId
-    deriving Eq Show
-  Point
-    x Int
-    y Int
-    name String
-    Primary x y
-    deriving Eq Show
-  Circle
-    centerX Int
-    centerY Int
-    name String
-    Foreign Point fkpoint centerX centerY
-    deriving Eq Show
-  Numbers
-    int    Int
-    double Double
-    deriving Eq Show
-
-  JoinOne
-    name    String
-    deriving Eq Show
-
-  JoinTwo
-    joinOne JoinOneId
-    name    String
-    deriving Eq Show
-
-  JoinThree
-    joinTwo JoinTwoId
-    name    String
-    deriving Eq Show
-
-  JoinFour
-    name    String
-    joinThree JoinThreeId
-    deriving Eq Show
-
-  JoinOther
-    name    String
-    deriving Eq Show
-
-  JoinMany
-    name      String
-    joinOther JoinOtherId
-    joinOne   JoinOneId
-    deriving Eq Show
-
-  DateTruncTest
-    created   UTCTime
-    deriving Eq Show
-|]
-
-- Unique Test schema
-share [mkPersist sqlSettings, mkMigrate "migrateUnique"] [persistUpperCase|
-  OneUnique
-    name String
-    value Int
-    UniqueValue value
-    deriving Eq Show
-|]
-
-
-instance ToBaseId ArticleMetadata where
-    type BaseEnt ArticleMetadata = Article
-    toBaseIdWitness articleId = ArticleMetadataKey articleId
-
--- a/test/Common/Test/Select.hs
+++ b/test/Common/Test/Select.hs
@ -1,22 +0,0 @@
-module Common.Test.Select where
-
-import Common.Test.Import
-
-testSelect :: SpecDb
-testSelect = do
-    describe "select" $ do
-        itDb "works for a single value" $ do
-            ret <- select $ return $ val (3 :: Int)
-            asserting $ ret `shouldBe` [ Value 3 ]
-
-        itDb "works for a pair of a single value and ()" $ do
-            ret <- select $ return (val (3 :: Int), ())
-            asserting $ ret `shouldBe` [ (Value 3, ()) ]
-
-        itDb "works for a single ()" $ do
-            ret <- select $ return ()
-            asserting $ ret `shouldBe` [ () ]
-
-        itDb "works for a single NULL value" $ do
-            ret <- select $ return nothing
-            asserting $ ret `shouldBe` [ Value (Nothing :: Maybe Int) ]
--- a/test/MySQL/Test.hs
+++ b/test/MySQL/Test.hs
@ -4,15 +4,13 @@
 {-# LANGUAGE TypeApplications #-}
 {-# LANGUAGE TypeFamilies #-}

-module MySQL.Test where
-
-import Common.Test.Import hiding (from, on)
+module Main (main) where

 import Control.Applicative
 import Control.Monad (void)
 import Control.Monad.IO.Class (MonadIO(liftIO))
 import Control.Monad.Logger (runNoLoggingT, runStderrLoggingT)
-import Control.Monad.Trans.Reader (ReaderT, mapReaderT)
+import Control.Monad.Trans.Reader (ReaderT)
 import qualified Control.Monad.Trans.Resource as R
 import Database.Esqueleto
 import Database.Esqueleto.Experimental hiding (from, on)
@ -25,16 +23,29 @@ import Database.Persist.MySQL
       , connectUser
       , defaultConnectInfo
       , withMySQLConn
-       , createMySQLPool
       )
-
+import System.Environment
 import Test.Hspec

 import Common.Test

-testMysqlSum :: SpecDb
+
+-- testMysqlRandom :: Spec
+-- testMysqlRandom = do
+--   -- This is known not to work until
+--   -- we can differentiate behavior by database
+--   it "works with random_" $
+--     run $ do
+--       _ <- select $ return (random_ :: SqlExpr (Value Double))
+--       return ()
+
+
+
+
+testMysqlSum :: Spec
 testMysqlSum = do
-  itDb "works with sum_" $ do
+  it "works with sum_" $
+    run $ do
      _ <- insert' p1
      _ <- insert' p2
      _ <- insert' p3
@ -44,9 +55,13 @@ testMysqlSum = do
             return $ joinV $ sum_ (p ^. PersonAge)
      liftIO $ ret `shouldBe` [ Value $ Just (36 + 17 + 17 :: Double ) ]

-testMysqlTwoAscFields :: SpecDb
+
+
+
+testMysqlTwoAscFields :: Spec
 testMysqlTwoAscFields = do
-  itDb "works with two ASC fields (one call)" $ do
+  it "works with two ASC fields (one call)" $
+    run $ do
      p1e <- insert' p1
      p2e <- insert' p2
      p3e <- insert' p3
@ -57,9 +72,13 @@ testMysqlTwoAscFields = do
             return p
      liftIO $ ret `shouldBe` [ p2e, p4e, p3e, p1e ]

-testMysqlOneAscOneDesc :: SpecDb
+
+
+
+testMysqlOneAscOneDesc :: Spec
 testMysqlOneAscOneDesc = do
-  itDb "works with one ASC and one DESC field (two calls)" $ do
+  it "works with one ASC and one DESC field (two calls)" $
+    run $ do
      p1e <- insert' p1
      p2e <- insert' p2
      p3e <- insert' p3
@ -74,9 +93,10 @@ testMysqlOneAscOneDesc = do



-testMysqlCoalesce :: SpecDb
+testMysqlCoalesce :: Spec
 testMysqlCoalesce = do
-  itDb "works on PostgreSQL and MySQL with <2 arguments" $ do
+  it "works on PostgreSQL and MySQL with <2 arguments" $
+    run $ do
      _ :: [Value (Maybe Int)] <-
        select $
        from $ \p -> do
@ -86,9 +106,10 @@ testMysqlCoalesce = do



-testMysqlUpdate :: SpecDb
+testMysqlUpdate :: Spec
 testMysqlUpdate = do
-  itDb "works on a simple example" $ do
+  it "works on a simple example" $
+    run $ do
      p1k <- insert p1
      p2k <- insert p2
      p3k <- insert p3
@ -111,13 +132,20 @@ testMysqlUpdate = do
                              , Entity p1k (Person anon (Just 73) Nothing 1)
                              , Entity p3k p3 ]

-nameContains :: (SqlString s)
+
+
+
+nameContains :: (BaseBackend backend ~ SqlBackend,
+                 BackendCompatible SqlBackend backend,
+                 MonadIO m, SqlString s,
+                 IsPersistBackend backend, PersistQueryRead backend,
+                 PersistUniqueRead backend)
             => (SqlExpr (Value [Char])
             -> SqlExpr (Value s)
             -> SqlExpr (Value Bool))
             -> s
             -> [Entity Person]
-             -> SqlPersistT IO ()
+             -> ReaderT backend m ()
 nameContains f t expected = do
  ret <- select $
         from $ \p -> do
@ -129,20 +157,22 @@ nameContains f t expected = do
  liftIO $ ret `shouldBe` expected


-testMysqlTextFunctions :: SpecDb
+testMysqlTextFunctions :: Spec
 testMysqlTextFunctions = do
  describe "text functions" $ do
-    itDb "like, (%) and (++.) work on a simple example" $ do
+    it "like, (%) and (++.) work on a simple example" $
+       run $ do
         [p1e, p2e, p3e, p4e] <- mapM insert' [p1, p2, p3, p4]
         nameContains like "h"  [p1e, p2e]
         nameContains like "i"  [p4e, p3e]
         nameContains like "iv" [p4e]


-testMysqlUnionWithLimits :: SpecDb
+testMysqlUnionWithLimits :: Spec
 testMysqlUnionWithLimits = do
  describe "MySQL Union" $ do
-    itDb "supports limit/orderBy by parenthesizing" $ do
+    it "supports limit/orderBy by parenthesizing" $ do
+      run $ do
        mapM_ (insert . Foo) [1..6]

        let q1 = do
@ -160,35 +190,58 @@ testMysqlUnionWithLimits = do
              pure $ foo ^. FooName


-        ret <- select $ Experimental.from $ q1 `union_` q2
+        ret <- select $ Experimental.from $ SelectQuery q1 `Union` SelectQuery q2
        liftIO $ ret `shouldMatchList` [Value 1, Value 2, Value 4, Value 5]

-spec :: Spec
-spec = beforeAll mkConnectionPool $ do
-    tests
+
+main :: IO ()
+main = do
+  hspec $ do
+    tests run
+
+    describe "Test MySQL locking" $ do
+      testLocking withConn

    describe "MySQL specific tests" $ do
-        -- definitely doesn't work at the moment
-        -- testMysqlRandom
-        testMysqlSum
-        testMysqlTwoAscFields
-        testMysqlOneAscOneDesc
-        testMysqlCoalesce
-        testMysqlUpdate
-        testMysqlTextFunctions
-        testMysqlUnionWithLimits
+      -- definitely doesn't work at the moment
+      -- testMysqlRandom
+      testMysqlSum
+      testMysqlTwoAscFields
+      testMysqlOneAscOneDesc
+      testMysqlCoalesce
+      testMysqlUpdate
+      testMysqlTextFunctions
+      testMysqlUnionWithLimits
+
+
+
+
+run, runSilent, runVerbose :: Run
+runSilent  act = runNoLoggingT     $ run_worker act
+runVerbose act = runStderrLoggingT $ run_worker act
+run =
+  if verbose
+  then runVerbose
+  else runSilent
+

 verbose :: Bool
 verbose = False

-migrateIt :: R.MonadUnliftIO m => SqlPersistT m ()
+
+run_worker :: RunDbMonad m => SqlPersistT (R.ResourceT m) a -> m a
+run_worker act = withConn $ runSqlConn (migrateIt >> act)
+
+
+migrateIt :: RunDbMonad m => SqlPersistT (R.ResourceT m) ()
 migrateIt = do
-  mapReaderT R.runResourceT $ void $ runMigrationSilent migrateAll
+  void $ runMigrationSilent migrateAll
  cleanDB

-mkConnectionPool :: IO ConnectionPool
-mkConnectionPool = do
-    ci <- isCI
+
+withConn :: RunDbMonad m => (SqlBackend -> R.ResourceT m a) -> m a
+withConn f = do
+    ci <- liftIO isCI
    let connInfo
            | ci =
                defaultConnectInfo
@ -206,18 +259,12 @@ mkConnectionPool = do
                    , connectDatabase = "esqutest"
                    , connectPort     = 3306
                    }
-    pool <-
-        if verbose
-        then
-            runStderrLoggingT $
-                createMySQLPool connInfo 4
-        else
-            runNoLoggingT $
-                createMySQLPool connInfo 4
+    R.runResourceT $ withMySQLConn connInfo f

+isCI :: IO Bool
+isCI =  do
+    env <- getEnvironment
+    return $ case lookup "TRAVIS" env <|> lookup "CI" env of
+        Just "true" -> True
+        _ -> False

-    flip runSqlPool pool $ do
-        migrateIt
-        cleanDB
-
-    pure pool
--- a/test/PostgreSQL/MigrateJSON.hs
+++ b/test/PostgreSQL/MigrateJSON.hs
@ -16,13 +16,16 @@

 module PostgreSQL.MigrateJSON where

-import Common.Test.Import hiding (Value, from, on)
-
+import Control.Monad.Trans.Resource (ResourceT)
 import Data.Aeson (Value)
-import Database.Esqueleto.Legacy (from)
+import Database.Esqueleto (SqlExpr, delete, from)
 import Database.Esqueleto.PostgreSQL.JSON (JSONB)
+import Database.Persist (Entity)
+import Database.Persist.Sql (SqlPersistT)
 import Database.Persist.TH

+import Common.Test (RunDbMonad)
+
 -- JSON Table for PostgreSQL
 share [mkPersist sqlSettings, mkMigrate "migrateJSON"] [persistUpperCase|
 Json
@ -31,6 +34,6 @@ Json
 |]

 cleanJSON
-    :: forall m. MonadIO m
-    => SqlPersistT m ()
+  :: (forall m. RunDbMonad m
+  => SqlPersistT (ResourceT m) ())
 cleanJSON = delete $ from $ \(_ :: SqlExpr (Entity Json)) -> return ()
--- a/test/PostgreSQL/Test.hs
+++ b/test/PostgreSQL/Test.hs
--- a/test/SQLite/Test.hs
+++ b/test/SQLite/Test.hs
@ -1,140 +1,177 @@
-{-# LANGUAGE FlexibleContexts #-}
-{-# LANGUAGE OverloadedStrings #-}
-{-# LANGUAGE RankNTypes #-}
-{-# LANGUAGE ScopedTypeVariables #-}
-{-# LANGUAGE TypeFamilies #-}
+{-# LANGUAGE ScopedTypeVariables
+           , FlexibleContexts
+           , RankNTypes
+           , TypeFamilies
+           , OverloadedStrings
+#-}

-module SQLite.Test where
-
-import Common.Test.Import hiding (from, on)
+module Main (main) where

 import Control.Monad (void)
-import Control.Monad.Logger (runNoLoggingT, runStderrLoggingT)
-import Database.Esqueleto.Legacy hiding (random_)
-import Database.Esqueleto.SQLite (random_)
-import Database.Persist.Sqlite (createSqlitePool)
+import Control.Monad.IO.Class (MonadIO(liftIO))
+import Control.Monad.Logger (runStderrLoggingT, runNoLoggingT)
+import Control.Monad.Trans.Reader (ReaderT)
+import Database.Persist.Sqlite (withSqliteConn)
 import Database.Sqlite (SqliteException)
+import Database.Esqueleto hiding (random_)
+import Database.Esqueleto.SQLite (random_)
+import qualified Control.Monad.Trans.Resource as R
+import Test.Hspec

 import Common.Test

-testSqliteRandom :: SpecDb
+
+
+
+testSqliteRandom :: Spec
 testSqliteRandom = do
-    itDb "works with random_" $ do
-        _ <- select $ return (random_ :: SqlExpr (Value Int))
-        asserting noExceptions
+  it "works with random_" $
+    run $ do
+      _ <- select $ return (random_ :: SqlExpr (Value Int))
+      return ()

-testSqliteSum :: SpecDb
+
+
+
+
+testSqliteSum :: Spec
 testSqliteSum = do
-    itDb "works with sum_" $ do
-        _ <- insert' p1
-        _ <- insert' p2
-        _ <- insert' p3
-        _ <- insert' p4
-        ret <- select $
-               from $ \p->
-               return $ joinV $ sum_ (p ^. PersonAge)
-        asserting $ ret `shouldBe` [ Value $ Just (36 + 17 + 17 :: Int) ]
+  it "works with sum_" $
+    run $ do
+      _ <- insert' p1
+      _ <- insert' p2
+      _ <- insert' p3
+      _ <- insert' p4
+      ret <- select $
+             from $ \p->
+             return $ joinV $ sum_ (p ^. PersonAge)
+      liftIO $ ret `shouldBe` [ Value $ Just (36 + 17 + 17 :: Int) ]





-testSqliteTwoAscFields :: SpecDb
+testSqliteTwoAscFields :: Spec
 testSqliteTwoAscFields = do
-    itDb "works with two ASC fields (one call)" $ do
-        p1e <- insert' p1
-        p2e <- insert' p2
-        p3e <- insert' p3
-        p4e <- insert' p4
-        ret <- select $
-               from $ \p -> do
-               orderBy [asc (p ^. PersonAge), asc (p ^. PersonName)]
-               return p
-        -- in SQLite and MySQL, its the reverse
-        asserting $ ret `shouldBe` [ p2e, p4e, p3e, p1e ]
+  it "works with two ASC fields (one call)" $
+    run $ do
+      p1e <- insert' p1
+      p2e <- insert' p2
+      p3e <- insert' p3
+      p4e <- insert' p4
+      ret <- select $
+             from $ \p -> do
+             orderBy [asc (p ^. PersonAge), asc (p ^. PersonName)]
+             return p
+      -- in SQLite and MySQL, its the reverse
+      liftIO $ ret `shouldBe` [ p2e, p4e, p3e, p1e ]

-testSqliteOneAscOneDesc :: SpecDb
+
+
+
+
+testSqliteOneAscOneDesc :: Spec
 testSqliteOneAscOneDesc = do
-    itDb "works with one ASC and one DESC field (two calls)" $ do
-        p1e <- insert' p1
-        p2e <- insert' p2
-        p3e <- insert' p3
-        p4e <- insert' p4
-        ret <- select $
-               from $ \p -> do
-               orderBy [desc (p ^. PersonAge)]
-               orderBy [asc (p ^. PersonName)]
-               return p
-        asserting $ ret `shouldBe` [ p1e, p4e, p3e, p2e ]
+  it "works with one ASC and one DESC field (two calls)" $
+    run $ do
+      p1e <- insert' p1
+      p2e <- insert' p2
+      p3e <- insert' p3
+      p4e <- insert' p4
+      ret <- select $
+             from $ \p -> do
+             orderBy [desc (p ^. PersonAge)]
+             orderBy [asc (p ^. PersonName)]
+             return p
+      liftIO $ ret `shouldBe` [ p1e, p4e, p3e, p2e ]

-testSqliteCoalesce :: SpecDb
+
+
+
+
+testSqliteCoalesce :: Spec
 testSqliteCoalesce = do
-    itDb "throws an exception on SQLite with <2 arguments" $ do
-        eres <- try $ select $
-               from $ \p -> do
-               return (coalesce [p ^. PersonAge]) :: SqlQuery (SqlExpr (Value (Maybe Int)))
-        asserting $ case eres of
-            Left (_ :: SqliteException) ->
-                pure ()
-            Right _ ->
-                expectationFailure "Expected SqliteException with <2 args to coalesce"
+  it "throws an exception on SQLite with <2 arguments" $
+    run (select $
+         from $ \p -> do
+         return (coalesce [p ^. PersonAge]) :: SqlQuery (SqlExpr (Value (Maybe Int))))
+    `shouldThrow` (\(_ :: SqliteException) -> True)

-testSqliteUpdate :: SpecDb
+
+
+
+
+testSqliteUpdate :: Spec
 testSqliteUpdate = do
-    itDb "works on a simple example" $ do
-        p1k <- insert p1
-        p2k <- insert p2
-        p3k <- insert p3
-        let anon = "Anonymous" :: String
-        ()  <- update $ \p -> do
-               set p [ PersonName =. val anon
-                     , PersonAge *=. just (val 2) ]
-               where_ (p ^. PersonName !=. val "Mike")
-        n   <- updateCount $ \p -> do
-               set p [ PersonAge +=. just (val 1) ]
-               where_ (p ^. PersonName !=. val "Mike")
-        ret <- select $
-               from $ \p -> do
-               orderBy [ asc (p ^. PersonName), asc (p ^. PersonAge) ]
-               return p
-        -- SQLite: nulls appear first, update returns matched rows.
-        asserting $ do
-            n `shouldBe` 2
-            ret `shouldMatchList`
-                [ Entity p2k (Person anon Nothing (Just 37) 2)
-                , Entity p1k (Person anon (Just 73) Nothing 1)
-                , Entity p3k p3
-                ]
+  it "works on a simple example" $
+    run $ do
+      p1k <- insert p1
+      p2k <- insert p2
+      p3k <- insert p3
+      let anon = "Anonymous"
+      ()  <- update $ \p -> do
+             set p [ PersonName =. val anon
+                   , PersonAge *=. just (val 2) ]
+             where_ (p ^. PersonName !=. val "Mike")
+      n   <- updateCount $ \p -> do
+             set p [ PersonAge +=. just (val 1) ]
+             where_ (p ^. PersonName !=. val "Mike")
+      ret <- select $
+             from $ \p -> do
+             orderBy [ asc (p ^. PersonName), asc (p ^. PersonAge) ]
+             return p
+      -- SQLite: nulls appear first, update returns matched rows.
+      liftIO $ n `shouldBe` 2
+      liftIO $ ret `shouldBe` [ Entity p2k (Person anon Nothing (Just 37) 2)
+                              , Entity p1k (Person anon (Just 73) Nothing 1)
+                              , Entity p3k p3 ]

-testSqliteTextFunctions :: SpecDb
+
+
+
+
+nameContains :: (BaseBackend backend ~ SqlBackend,
+                 BackendCompatible SqlBackend backend,
+                 MonadIO m, SqlString s,
+                 IsPersistBackend backend, PersistQueryRead backend,
+                 PersistUniqueRead backend)
+             => (SqlExpr (Value [Char])
+             -> SqlExpr (Value s)
+             -> SqlExpr (Value Bool))
+             -> s
+             -> [Entity Person]
+             -> ReaderT backend m ()
+nameContains f t expected = do
+  ret <- select $
+         from $ \p -> do
+         where_ (f
+                  (p ^. PersonName)
+                  ((%) ++. val t ++. (%)))
+         orderBy [asc (p ^. PersonName)]
+         return p
+  liftIO $ ret `shouldBe` expected
+
+testSqliteTextFunctions :: Spec
 testSqliteTextFunctions = do
-    describe "text functions" $ do
-        itDb "like, (%) and (++.) work on a simple example" $ do
-            let query :: String -> SqlPersistT IO [Entity Person]
-                query t =
-                    select $
-                    from $ \p -> do
-                    where_ (like
-                             (p ^. PersonName)
-                             ((%) ++. val t ++. (%)))
-                    orderBy [asc (p ^. PersonName)]
-                    return p
-            [p1e, p2e, p3e, p4e] <- mapM insert' [p1, p2, p3, p4]
-            r0 <- query "h"
-            r1 <- query "i"
-            r2 <- query "iv"
-            asserting $ do
-                r0 `shouldBe` [p1e, p2e]
-                r1 `shouldBe` [p4e, p3e]
-                r2 `shouldBe` [p4e]
+  describe "text functions" $ do
+    it "like, (%) and (++.) work on a simple example" $
+       run $ do
+         [p1e, p2e, p3e, p4e] <- mapM insert' [p1, p2, p3, p4]
+         nameContains like "h"  [p1e, p2e]
+         nameContains like "i"  [p4e, p3e]
+         nameContains like "iv" [p4e]

-spec :: HasCallStack => Spec
-spec = beforeAll mkConnectionPool $ do
-    tests
+main :: IO ()
+main = do
+  hspec $ do
+    tests run

-    describe "SQLite specific tests" $ do
-      testAscRandom random_
-      testRandomMath
+    describe "Test SQLite locking" $ do
+      testLocking withConn
+
+    fdescribe "SQLite specific tests" $ do
+      testAscRandom random_ run
+      testRandomMath run
      testSqliteRandom
      testSqliteSum
      testSqliteTwoAscFields
@ -143,23 +180,24 @@ spec = beforeAll mkConnectionPool $ do
      testSqliteUpdate
      testSqliteTextFunctions

-mkConnectionPool :: IO ConnectionPool
-mkConnectionPool = do
-    conn <-
-        if verbose
-        then runStderrLoggingT $
-            createSqlitePool ".esqueleto-test.sqlite" 4
-        else runNoLoggingT $
-            createSqlitePool ".esqueleto-test.sqlite" 4
-    flip runSqlPool conn $ do
-        migrateIt
-
-    pure conn
+run, runSilent, runVerbose :: Run
+runSilent  act = runNoLoggingT     $ run_worker act
+runVerbose act = runStderrLoggingT $ run_worker act
+run =
+  if verbose
+  then runVerbose
+  else runSilent

 verbose :: Bool
 verbose = False

-migrateIt :: MonadUnliftIO m => SqlPersistT m ()
+run_worker :: RunDbMonad m => SqlPersistT (R.ResourceT m) a -> m a
+run_worker act = withConn $ runSqlConn (migrateIt >> act)
+
+migrateIt :: RunDbMonad m => SqlPersistT (R.ResourceT m) ()
 migrateIt = do
  void $ runMigrationSilent migrateAll
-  cleanDB
+
+withConn :: RunDbMonad m => (SqlBackend -> R.ResourceT m a) -> m a
+withConn =
+  R.runResourceT . withSqliteConn ":memory:"
--- a/test/Spec.hs
+++ b/test/Spec.hs
@ -1,22 +0,0 @@
-module Main where
-
-import Test.Hspec
-import Test.Hspec.Core.Spec
-
-import qualified SQLite.Test as SQLite
-import qualified MySQL.Test as MySQL
-import qualified PostgreSQL.Test as Postgres
-
-main :: IO ()
-main = hspec spec
-
-spec :: Spec
-spec = do
-    parallel $ describe "Esqueleto" $ do
-        describe "SQLite" $ do
-            sequential $ SQLite.spec
-        describe "MySQL" $ do
-            sequential $ MySQL.spec
-        describe "Postgresql" $ do
-            sequential $ Postgres.spec
-
Author	SHA1	Message	Date
parsonsmatt	2fe75183ce	changelog, vbump	2021-05-20 16:02:16 -06:00
parsonsmatt	8430785ae7	test case	2021-05-20 10:30:12 -06:00
parsonsmatt	79b4ade4a5	remove failing test with bad behavior	2021-05-20 10:20:10 -06:00