Make postgres tests pass

src/Database/Esqueleto/Experimental/ToAlias.hs

@@ -23,7 +23,7 @@ instance ToAlias (SqlExpr (Value a)) where
                 ident <- newIdentFor (DBName "v")
                 pure $ ERaw noMeta{sqlExprMetaAlias = Just ident} $ \_ info ->
                     let (b, v) = f Never info
-                    in (b <> " AS " <> useIdent info ident, [])
+                    in (b <> " AS " <> useIdent info ident, v)
 
 
 instance ToAlias (SqlExpr (Entity a)) where

src/Database/Esqueleto/Experimental/ToAliasReference.hs

@@ -19,22 +19,22 @@ class ToAliasReference a where
 instance ToAliasReference (SqlExpr (Value a)) where
     toAliasReference aliasSource (ERaw m _)
       | Just alias <- sqlExprMetaAlias m = pure $ ERaw m $ \_ info ->
-            (useIdent info aliasSource <> "." <> useIdent info alias, [])
+          (useIdent info aliasSource <> "." <> useIdent info alias, [])
     toAliasReference _ e = pure e
 
 instance ToAliasReference (SqlExpr (Entity a)) where
     toAliasReference aliasSource (ERaw m _)
       | Just _ <- sqlExprMetaAlias m, False <- sqlExprMetaIsReference m =
           pure $ ERaw m{sqlExprMetaIsReference = True} $ \_ info ->
-              (useIdent info aliasSource, [])
+            (useIdent info aliasSource, [])
     toAliasReference _ e = pure e
 
 instance ToAliasReference (SqlExpr (Maybe (Entity a))) where
     -- FIXME: Code duplication because the compiler doesnt like half final encoding
-    toAliasReference aliasSource (ERaw m f)
+    toAliasReference aliasSource (ERaw m _)
       | Just _ <- sqlExprMetaAlias m, False <- sqlExprMetaIsReference m =
           pure $ ERaw m{sqlExprMetaIsReference = True} $ \_ info ->
-              (useIdent info aliasSource, [])
+            (useIdent info aliasSource, [])
     toAliasReference s e = pure e
 
 

src/Database/Esqueleto/Internal/Internal.hs

@@ -363,7 +363,9 @@ distinctOnOrderBy exprs act =
         act
   where
     toDistinctOn :: SqlExpr OrderBy -> SqlExpr DistinctOn
-    toDistinctOn = coerce
+    toDistinctOn (ERaw m f) = ERaw m $ \p info ->
+        let (b, vals) = f p info
+        in (TLB.fromLazyText $ head $ TL.splitOn " " $ TLB.toLazyText b, vals)
 
 -- | @ORDER BY random()@ clause.
 --
@@ -918,7 +920,11 @@ in_ :: PersistField typ => SqlExpr (Value typ) -> SqlExpr (ValueList typ) -> Sql
     ERaw noMeta $ \p info ->
         let (b1, vals1) = v Parens info 
             (b2, vals2) = list Parens info 
-        in (b1 <> " IN " <> b2, vals1 <> vals2)
+        in 
+        if b2 == "()" then
+            ("FALSE", [])
+        else 
+            (b1 <> " IN " <> b2, vals1 <> vals2)
 
 -- | @NOT IN@ operator.
 notIn :: PersistField typ => SqlExpr (Value typ) -> SqlExpr (ValueList typ) -> SqlExpr (Value Bool)
@@ -3042,7 +3048,7 @@ materializeExpr info v
     | ERaw m _ <- v, Just f <- sqlExprMetaCompositeFields m = 
         let bs = f info
         in (uncommas $ map (parensM Parens) bs, [])
-    | ERaw _ f <- v = f Never info
+    | ERaw _ f <- v = f Parens info
 
 
 -- | You may return tuples (up to 16-tuples) and tuples of tuples

test/Common/Test.hs

@@ -894,7 +894,6 @@ testSelectSubQuery run = describe "select subquery" $ do
                       `Experimental.on` (\(l :& d) -> just (l ^. LordId) ==. d ?. DeedOwnerId)
                   pure (lords, deeds)
 
-        liftIO . print =<< renderQuerySelect q
         ret <- select q
         liftIO $ ret `shouldMatchList` ((l3e, Nothing) : l1WithDeeds)