squeal-postgresql 0.3.2.0 → 0.4.0.0

raw patch · 14 files changed

+2107/−1438 lines, 14 filesdep +hspecdep +records-sopdep −profunctorsdep ~basedep ~generics-sopdep ~textPVP ok

version bump matches the API change (PVP)

Dependencies added: hspec, records-sop

Dependencies removed: profunctors

Dependency ranges changed: base, generics-sop, text

API changes (from Hackage documentation)

Files

• exe/Example.hs +3/−3
• squeal-postgresql.cabal +21/−3
• src/Squeal/PostgreSQL/Binary.hs +331/−204
• src/Squeal/PostgreSQL/Definition.hs +31/−24
• src/Squeal/PostgreSQL/Expression.hs +502/−450
• src/Squeal/PostgreSQL/Manipulation.hs +66/−74
• src/Squeal/PostgreSQL/Migration.hs +0/−21
• src/Squeal/PostgreSQL/PQ.hs +102/−45
• src/Squeal/PostgreSQL/Query.hs +604/−263
• src/Squeal/PostgreSQL/Render.hs +11/−3
• src/Squeal/PostgreSQL/Schema.hs +302/−343
• src/Squeal/PostgreSQL/Transaction.hs +6/−5
• test/Specs/ExceptionHandling.hs +121/−0
• test/Specs/Specs.hs +7/−0

@@ -29,7 +29,7 @@        '[ "pk_users" ::: 'PrimaryKey '["id"] ] :=>        '[ "id" ::: 'Def :=> 'NotNull 'PGint4         , "name" ::: 'NoDef :=> 'NotNull 'PGtext-        , "vec" ::: 'NoDef :=> 'NotNull ('PGvararray 'PGint2)+        , "vec" ::: 'NoDef :=> 'NotNull ('PGvararray ('Null 'PGint2))         ])    , "emails" ::: 'Table (        '[  "pk_emails" ::: 'PrimaryKey '["id"]@@ -60,7 +60,7 @@ teardown :: Definition Schema '[] teardown = dropTable #emails >>> dropTable #users -insertUser :: Manipulation Schema '[ 'NotNull 'PGtext, 'NotNull ('PGvararray 'PGint2)]+insertUser :: Manipulation Schema '[ 'NotNull 'PGtext, 'NotNull ('PGvararray ('Null 'PGint2))]   '[ "fromOnly" ::: 'NotNull 'PGint4 ] insertUser = insertRows #users   (Default `as` #id :* Set (param @1) `as` #name :* Set (param @2) `as` #vec) []@@ -76,7 +76,7 @@ getUsers :: Query Schema '[]   '[ "userName" ::: 'NotNull 'PGtext    , "userEmail" ::: 'Null 'PGtext-   , "userVec" ::: 'NotNull ('PGvararray 'PGint2)]+   , "userVec" ::: 'NotNull ('PGvararray ('Null 'PGint2))] getUsers = select   (#u ! #name `as` #userName :* #e ! #email `as` #userEmail :* #u ! #vec `as` #userVec)   ( from (table (#users `as` #u)

@@ -1,5 +1,5 @@ name: squeal-postgresql-version: 0.3.2.0+version: 0.4.0.0 synopsis: Squeal PostgreSQL Library description: Squeal is a type-safe embedding of PostgreSQL in Haskell homepage: https://github.com/morphismtech/squeal@@ -37,7 +37,7 @@   ghc-options: -Wall   build-depends:       aeson >= 1.2.4.0-    , base >= 4.10.1.0 && < 5.0+    , base >= 4.11.1.0 && < 5.0     , binary-parser >= 0.5.5     , bytestring >= 0.10.8.2     , bytestring-strict-builder >= 0.4.5@@ -50,7 +50,7 @@     , network-ip >= 0.3.0.2     , postgresql-binary >= 0.12.1     , postgresql-libpq >= 0.9.4.1-    , profunctors >= 5.2.2+    , records-sop >= 0.1.0.0     , resource-pool >= 0.2.3.2     , scientific >= 0.3.5.3     , text >= 1.2.3.0@@ -69,6 +69,24 @@   build-depends:       base >= 4.10.0.0     , doctest >= 0.11.4++test-suite squeal-postgresql-specs+  default-language: Haskell2010+  type: exitcode-stdio-1.0+  hs-source-dirs: test/Specs+  ghc-options: -Wall  -main-is Specs+  main-is: Specs.hs+  other-modules: ExceptionHandling+  build-depends:+      base >= 4.10.0.0+    , bytestring >= 0.10.8.2+    , generics-sop >= 0.3.1.0+    , hspec >= 2.4.8+    , squeal-postgresql+    , text >= 1.2.2.2+    , transformers >= 0.5.2.0+    , transformers-base >= 0.4.4+    , vector >= 0.12.0.1  executable squeal-postgresql-example   default-language: Haskell2010

@@ -11,65 +11,104 @@ do not need to define your own instances to decode retrieved rows into Haskell values or to encode Haskell values into statement parameters. +Let's see some examples. We'll need some imports+ >>> import Data.Int (Int16) >>> import Data.Text (Text)-->>> data Row = Row { col1 :: Int16, col2 :: Text } deriving (Eq, GHC.Generic)->>> instance Generic Row->>> instance HasDatatypeInfo Row- >>> import Control.Monad (void) >>> import Control.Monad.Base (liftBase) >>> import Squeal.PostgreSQL +Define a Haskell datatype `Row` that will serve as both the input and output of a simple+round trip query.++>>> data Row = Row { col1 :: Int16, col2 :: Text, col3 :: Maybe Bool } deriving (Eq, GHC.Generic)+>>> instance Generic Row+>>> instance HasDatatypeInfo Row >>> :{ let-  query :: Query '[]-    '[ 'NotNull 'PGint2, 'NotNull 'PGtext]-    '["col1" ::: 'NotNull 'PGint2, "col2" ::: 'NotNull 'PGtext]-  query = values_ (param @1 `as` #col1 :* param @2 `as` #col2)+  roundTrip :: Query '[] (TuplePG Row) (RowPG Row)+  roundTrip = values_ $+    parameter @1 int2 `as` #col1 :*+    parameter @2 text `as` #col2 :*+    parameter @3 bool `as` #col3 :} +So long as we can encode the parameters and then decode the result of the query,+the input and output should be equal.++>>> let input = Row 2 "hi" (Just True) >>> :{+void . withConnection "host=localhost port=5432 dbname=exampledb" $ do+  result <- runQueryParams roundTrip input+  Just output <- firstRow result+  liftBase . print $ input == output+:}+True++In addition to being able to encode and decode basic Haskell types+like `Int16` and `Text`, Squeal permits you to encode and decode Haskell types to+Postgres array, enumerated and composite types and json. Let's see another example,+this time using the `Vector` type which corresponds to variable length arrays+and homogeneous tuples which correspond to fixed length arrays. We can even+create multi-dimensional fixed length arrays.++>>> :{+data Row = Row+  { col1 :: Vector Int16+  , col2 :: (Maybe Int16,Maybe Int16)+  , col3 :: ((Int16,Int16),(Int16,Int16),(Int16,Int16))+  } deriving (Eq, GHC.Generic)+:}++>>> instance Generic Row+>>> instance HasDatatypeInfo Row++Once again, we define a simple round trip query.++>>> :{ let-  roundtrip :: IO ()-  roundtrip = void . withConnection "host=localhost port=5432 dbname=exampledb" $ do-    result <- runQueryParams query (2 :: Int16, "hi" :: Text)-    Just row <- firstRow result-    liftBase . print $ row == Row 2 "hi"+  roundTrip :: Query '[] (TuplePG Row) (RowPG Row)+  roundTrip = values_ $+    parameter @1 (int2 & vararray)                  `as` #col1 :*+    parameter @2 (int2 & fixarray @2)               `as` #col2 :*+    parameter @3 (int2 & fixarray @2 & fixarray @3) `as` #col3 :} ->>> roundtrip+>>> :set -XOverloadedLists+>>> let input = Row [1,2] (Just 1,Nothing) ((1,2),(3,4),(5,6))+>>> :{+void . withConnection "host=localhost port=5432 dbname=exampledb" $ do+  result <- runQueryParams roundTrip input+  Just output <- firstRow result+  liftBase . print $ input == output+:} True -In addition to being able to encode and decode basic Haskell types like `Int16` and `Text`,-Squeal permits you to encode and decode Haskell types which are equivalent to-Postgres enumerated and composite types.- Enumerated (enum) types are data types that comprise a static, ordered set of values. They are equivalent to Haskell algebraic data types whose constructors are nullary. An example of an enum type might be the days of the week, or a set of status values for a piece of data. ->>> data Schwarma = Beef | Lamb | Chicken deriving (Show, GHC.Generic)+>>> data Schwarma = Beef | Lamb | Chicken deriving (Eq, Show, GHC.Generic) >>> instance Generic Schwarma >>> instance HasDatatypeInfo Schwarma  A composite type represents the structure of a row or record;-it is essentially just a list of field names and their data types. They are almost-equivalent to Haskell record types. However, because of the potential presence of @NULL@-all the record fields must be `Maybe`s of basic types.+it is essentially just a list of field names and their data types. ->>> data Person = Person {name :: Maybe Text, age :: Maybe Int32} deriving (Show, GHC.Generic)+>>> data Person = Person {name :: Text, age :: Int32} deriving (Eq, Show, GHC.Generic) >>> instance Generic Person >>> instance HasDatatypeInfo Person+>>> instance Aeson.FromJSON Person+>>> instance Aeson.ToJSON Person  We can create the equivalent Postgres types directly from their Haskell types.  >>> :{ type Schema =-  '[ "schwarma" ::: 'Typedef (EnumFrom Schwarma)-   , "person" ::: 'Typedef (CompositeFrom Person)+  '[ "schwarma" ::: 'Typedef (PG (Enumerated Schwarma))+   , "person" ::: 'Typedef (PG (Composite Person))    ] :} @@ -81,25 +120,40 @@     createTypeCompositeFrom @Person #person :} -Then we can perform roundtrip queries;+Let's demonstrate how to associate our Haskell types `Schwarma` and `Person`+with enumerated, composite or json types in Postgres. First create a Haskell+`Row` type using the `Enumerated`, `Composite` and `Json` newtypes as fields.  >>> :{+data Row = Row+  { schwarma :: Enumerated Schwarma+  , person1 :: Composite Person+  , person2 :: Json Person+  } deriving (Eq, GHC.Generic)+:}++>>> instance Generic Row+>>> instance HasDatatypeInfo Row+>>> :{ let-  querySchwarma :: Query Schema-    '[ 'NotNull (EnumFrom Schwarma)]-    '["fromOnly" ::: 'NotNull (EnumFrom Schwarma)]-  querySchwarma = values_ (parameter @1 #schwarma `as` #fromOnly)+  input = Row+    (Enumerated Chicken)+    (Composite (Person "Faisal" 24))+    (Json (Person "Ahmad" 48)) :} +Once again, define a round trip query.+ >>> :{ let-  queryPerson :: Query Schema-    '[ 'NotNull (CompositeFrom Person)]-    '["fromOnly" ::: 'NotNull (CompositeFrom Person)]-  queryPerson = values_ (parameter @1 #person `as` #fromOnly)+  roundTrip :: Query Schema (TuplePG Row) (RowPG Row)+  roundTrip = values_ $+    parameter @1 (typedef #schwarma) `as` #schwarma :*+    parameter @2 (typedef #person)   `as` #person1  :*+    parameter @3 json                `as` #person2 :} -And finally drop the types.+Finally, we can drop our type definitions.  >>> :{ let@@ -112,20 +166,16 @@ >>> :{ let   session = do-    result1 <- runQueryParams querySchwarma (Only Chicken)-    Just (Only schwarma) <- firstRow result1-    liftBase $ print (schwarma :: Schwarma)-    result2 <- runQueryParams queryPerson (Only (Person (Just "Faisal") (Just 24)))-    Just (Only person) <- firstRow result2-    liftBase $ print (person :: Person)+    result <- runQueryParams roundTrip input+    Just output <- firstRow result+    liftBase . print $ input == output in   void . withConnection "host=localhost port=5432 dbname=exampledb" $     define setup     & pqThen session     & pqThen (define teardown) :}-Chicken-Person {name = Just "Faisal", age = Just 24}+True -}  {-# LANGUAGE@@ -134,10 +184,13 @@   , DeriveFunctor   , DeriveGeneric   , DeriveTraversable+  , DefaultSignatures   , FlexibleContexts   , FlexibleInstances+  , FunctionalDependencies   , GADTs   , LambdaCase+  , OverloadedStrings   , MultiParamTypeClasses   , ScopedTypeVariables   , TypeApplications@@ -149,35 +202,37 @@ module Squeal.PostgreSQL.Binary   ( -- * Encoding     ToParam (..)-  , ToColumnParam (..)   , ToParams (..)     -- * Decoding   , FromValue (..)-  , FromColumnValue (..)   , FromRow (..)     -- * Only   , Only (..)   ) where  import BinaryParser-import ByteString.StrictBuilder-import Data.Aeson hiding (Null)+import ByteString.StrictBuilder (builderLength, int32BE, int64BE, word32BE)+import Control.Arrow (left)+import Control.Monad import Data.Int import Data.Kind-import Data.Monoid hiding (All) import Data.Scientific import Data.Time import Data.UUID.Types import Data.Vector (Vector) import Data.Word import Generics.SOP+import Generics.SOP.Record import GHC.TypeLits import Network.IP.Addr -import qualified Data.ByteString.Lazy as Lazy-import qualified Data.ByteString as Strict hiding (pack, unpack)-import qualified Data.Text.Lazy as Lazy-import qualified Data.Text as Strict+import qualified Data.Aeson as Aeson+import qualified Data.ByteString.Lazy as Lazy (ByteString)+import qualified Data.ByteString.Lazy as Lazy.ByteString+import qualified Data.ByteString as Strict (ByteString)+import qualified Data.Text.Lazy as Lazy (Text)+import qualified Data.Text as Strict (Text)+import qualified Data.Text as Strict.Text import qualified Data.Vector as Vector import qualified GHC.Generics as GHC import qualified PostgreSQL.Binary.Decoding as Decoding@@ -219,6 +274,8 @@ instance ToParam Char ('PGchar 1) where toParam = K . Encoding.char_utf8 instance ToParam Strict.Text 'PGtext where toParam = K . Encoding.text_strict instance ToParam Lazy.Text 'PGtext where toParam = K . Encoding.text_lazy+instance ToParam String 'PGtext where+  toParam = K . Encoding.text_strict . Strict.Text.pack instance ToParam Strict.ByteString 'PGbytea where   toParam = K . Encoding.bytea_strict instance ToParam Lazy.ByteString 'PGbytea where@@ -232,17 +289,29 @@ instance ToParam UTCTime 'PGtimestamptz where   toParam = K . Encoding.timestamptz_int instance ToParam DiffTime 'PGinterval where toParam = K . Encoding.interval_int-instance ToParam Value 'PGjson where toParam = K . Encoding.json_ast-instance ToParam Value 'PGjsonb where toParam = K . Encoding.jsonb_ast-instance (HasOid pg, ToParam x pg)-  => ToParam (Vector (Maybe x)) ('PGvararray pg) where-    toParam = K . Encoding.nullableArray_vector-      (oid @pg) (unK . toParam @x @pg)+instance ToParam Aeson.Value 'PGjson where toParam = K . Encoding.json_ast+instance ToParam Aeson.Value 'PGjsonb where toParam = K . Encoding.jsonb_ast+instance Aeson.ToJSON x => ToParam (Json x) 'PGjson where+  toParam = K . Encoding.json_bytes+    . Lazy.ByteString.toStrict . Aeson.encode . getJson+instance Aeson.ToJSON x => ToParam (Jsonb x) 'PGjsonb where+  toParam = K . Encoding.jsonb_bytes+    . Lazy.ByteString.toStrict . Aeson.encode . getJsonb+instance ToArray x ('NotNull ('PGvararray ty))+  => ToParam x ('PGvararray ty) where+    toParam+      = K . Encoding.array (baseOid @x @('NotNull ('PGvararray ty)))+      . unK . toArray @x @('NotNull ('PGvararray ty))+instance ToArray x ('NotNull ('PGfixarray n ty))+  => ToParam x ('PGfixarray n ty) where+    toParam+      = K . Encoding.array (baseOid @x @('NotNull ('PGfixarray n ty)))+      . unK . toArray @x @('NotNull ('PGfixarray n ty)) instance   ( IsEnumType x   , HasDatatypeInfo x-  , LabelsFrom x ~ labels-  ) => ToParam x ('PGenum labels) where+  , LabelsPG x ~ labels+  ) => ToParam (Enumerated x) ('PGenum labels) where     toParam =       let         gshowConstructor :: NP ConstructorInfo xss -> SOP I xss -> String@@ -253,21 +322,20 @@           gshowConstructor constructors (SOP xs)       in         K . Encoding.text_strict-        . Strict.pack+        . Strict.Text.pack         . gshowConstructor (constructorInfo (datatypeInfo (Proxy @x)))         . from+        . getEnumerated instance   ( SListI fields-  , MapMaybes xs-  , IsProductType x (Maybes xs)-  , AllZip ToAliasedParam xs fields-  , FieldNamesFrom x ~ AliasesOf fields+  , IsRecord x xs+  , AllZip ToField xs fields   , All HasAliasedOid fields-  ) => ToParam x ('PGcomposite fields) where+  ) => ToParam (Composite x) ('PGcomposite fields) where     toParam =       let -        encoders = htrans (Proxy @ToAliasedParam) toAliasedParam+        encoders = htrans (Proxy @ToField) toField          composite           :: All HasAliasedOid row@@ -301,36 +369,66 @@               hcfoldMap (Proxy @HasAliasedOid) each fields        in-        composite . encoders . unMaybes . unZ . unSOP . from+        composite . encoders . toRecord . getComposite -class HasAliasedOid (field :: (Symbol, PGType)) where aliasedOid :: Word32-instance HasOid ty => HasAliasedOid (alias ::: ty) where aliasedOid = oid @ty+class HasAliasedOid (field :: (Symbol, NullityType)) where+  aliasedOid :: Word32+instance HasOid ty => HasAliasedOid (alias ::: nullity ty) where+  aliasedOid = oid @ty -class ToAliasedParam (x :: Type) (field :: (Symbol, PGType)) where-  toAliasedParam :: Maybe x -> K (Maybe Encoding.Encoding) field-instance ToParam x ty => ToAliasedParam x (alias ::: ty) where-  toAliasedParam = \case-    Nothing -> K Nothing-    Just x -> K . Just . unK $ toParam @x @ty x+class ToNullityParam (x :: Type) (ty :: NullityType) where+  toNullityParam :: x -> K (Maybe Encoding.Encoding) ty+instance ToParam x pg => ToNullityParam x ('NotNull pg) where+  toNullityParam = K . Just . unK . toParam @x @pg+instance ToParam x pg => ToNullityParam (Maybe x) ('Null pg) where+  toNullityParam = K . fmap (unK . toParam @x @pg) --- | A `ToColumnParam` constraint lifts the `ToParam` encoding--- of a `Type` to a `NullityType`, encoding `Maybe`s to `Null`s. You should--- not define instances of `ToColumnParam`, just use the provided instances.-class ToColumnParam (x :: Type) (ty :: NullityType) where-  -- | >>> toColumnParam @Int16 @('NotNull 'PGint2) 0-  -- K (Just "\NUL\NUL")-  ---  -- >>> toColumnParam @(Maybe Int16) @('Null 'PGint2) (Just 0)-  -- K (Just "\NUL\NUL")-  ---  -- >>> toColumnParam @(Maybe Int16) @('Null 'PGint2) Nothing-  -- K Nothing-  toColumnParam :: x -> K (Maybe Strict.ByteString) ty-instance ToParam x pg => ToColumnParam x ('NotNull pg) where-  toColumnParam = K . Just . Encoding.encodingBytes . unK . toParam @x @pg-instance ToParam x pg => ToColumnParam (Maybe x) ('Null pg) where-  toColumnParam = K . fmap (Encoding.encodingBytes . unK . toParam @x @pg)+class ToField (x :: (Symbol, Type)) (field :: (Symbol, NullityType)) where+  toField :: P x -> K (Maybe Encoding.Encoding) field+instance ToNullityParam x ty => ToField (alias ::: x) (alias ::: ty) where+  toField (P x) = K . unK $ toNullityParam @x @ty x +class ToArray (x :: Type) (array :: NullityType) where+  toArray :: x -> K Encoding.Array array+  baseOid :: Word32+  default baseOid :: HasOid (PGTypeOf array) => Word32+  baseOid = oid @(PGTypeOf array)+instance {-# OVERLAPPABLE #-} (HasOid pg, ToParam x pg)+  => ToArray x ('NotNull pg) where+    toArray = K . Encoding.encodingArray . unK . toParam @x @pg+instance {-# OVERLAPPABLE #-} (HasOid pg, ToParam x pg)+  => ToArray (Maybe x) ('Null pg) where+    toArray = K . maybe Encoding.nullArray+      (Encoding.encodingArray . unK . toParam @x @pg)+instance {-# OVERLAPPING #-} ToArray x array+  => ToArray (Vector x) ('NotNull ('PGvararray array)) where+    toArray = K . Encoding.dimensionArray Vector.foldl'+      (unK . toArray @x @array)+    baseOid = baseOid @x @array+instance {-# OVERLAPPING #-} ToArray x array+  => ToArray (Maybe (Vector x)) ('Null ('PGvararray array)) where+    toArray = K . maybe Encoding.nullArray+      (Encoding.dimensionArray Vector.foldl' (unK . toArray @x @array))+    baseOid = baseOid @x @array+instance {-# OVERLAPPING #-}+  ( IsProductType product xs+  , Length xs ~ n+  , All ((~) x) xs+  , ToArray x array )+  => ToArray product ('NotNull ('PGfixarray n array)) where+    toArray = K . Encoding.dimensionArray foldlN+      (unK . toArray @x @array) . unZ . unSOP . from+    baseOid = baseOid @x @array+instance {-# OVERLAPPING #-}+  ( IsProductType product xs+  , Length xs ~ n+  , All ((~) x) xs+  , ToArray x array )+  => ToArray (Maybe product) ('Null ('PGfixarray n array)) where+    toArray = K . maybe Encoding.nullArray+      (Encoding.dimensionArray foldlN (unK . toArray @x @array) . unZ . unSOP . from)+    baseOid = baseOid @x @array+ -- | A `ToParams` constraint generically sequences the encodings of `Type`s -- of the fields of a tuple or record to a row of `ColumnType`s. You should -- not define instances of `ToParams`. Instead define `Generic` instances@@ -345,61 +443,67 @@   -- >>> instance Generic Tuple   -- >>> toParams @Tuple @Params (Tuple False (Just 0))   -- K (Just "\NUL") :* K (Just "\NUL\NUL") :* Nil-  toParams :: x -> NP (K (Maybe Strict.ByteString)) tys-instance (SListI tys, IsProductType x xs, AllZip ToColumnParam xs tys)+  toParams :: x -> NP (K (Maybe Encoding.Encoding)) tys+instance (SListI tys, IsProductType x xs, AllZip ToNullityParam xs tys)   => ToParams x tys where       toParams-        = htrans (Proxy @ToColumnParam) (toColumnParam . unI)+        = htrans (Proxy @ToNullityParam) (toNullityParam . unI)         . unZ . unSOP . from  -- | A `FromValue` constraint gives a parser from the binary format of -- a PostgreSQL `PGType` into a Haskell `Type`. class FromValue (pg :: PGType) (y :: Type) where   -- | >>> newtype Id = Id { getId :: Int16 } deriving Show-  -- >>> instance FromValue 'PGint2 Id where fromValue = fmap Id . fromValue-  fromValue :: proxy pg -> Decoding.Value y-instance FromValue 'PGbool Bool where fromValue _ = Decoding.bool-instance FromValue 'PGint2 Int16 where fromValue _ = Decoding.int-instance FromValue 'PGint4 Int32 where fromValue _ = Decoding.int-instance FromValue 'PGint8 Int64 where fromValue _ = Decoding.int-instance FromValue 'PGfloat4 Float where fromValue _ = Decoding.float4-instance FromValue 'PGfloat8 Double where fromValue _ = Decoding.float8-instance FromValue 'PGnumeric Scientific where fromValue _ = Decoding.numeric-instance FromValue 'PGuuid UUID where fromValue _ = Decoding.uuid-instance FromValue 'PGinet (NetAddr IP) where fromValue _ = Decoding.inet-instance FromValue ('PGchar 1) Char where fromValue _ = Decoding.char-instance FromValue 'PGtext Strict.Text where fromValue _ = Decoding.text_strict-instance FromValue 'PGtext Lazy.Text where fromValue _ = Decoding.text_lazy+  -- >>> instance FromValue 'PGint2 Id where fromValue = Id <$> fromValue @'PGint2+  fromValue :: Decoding.Value y+instance FromValue 'PGbool Bool where fromValue = Decoding.bool+instance FromValue 'PGint2 Int16 where fromValue = Decoding.int+instance FromValue 'PGint4 Int32 where fromValue = Decoding.int+instance FromValue 'PGint8 Int64 where fromValue = Decoding.int+instance FromValue 'PGfloat4 Float where fromValue = Decoding.float4+instance FromValue 'PGfloat8 Double where fromValue = Decoding.float8+instance FromValue 'PGnumeric Scientific where fromValue = Decoding.numeric+instance FromValue 'PGuuid UUID where fromValue = Decoding.uuid+instance FromValue 'PGinet (NetAddr IP) where fromValue = Decoding.inet+instance FromValue ('PGchar 1) Char where fromValue = Decoding.char+instance FromValue 'PGtext Strict.Text where fromValue = Decoding.text_strict+instance FromValue 'PGtext Lazy.Text where fromValue = Decoding.text_lazy+instance FromValue 'PGtext String where+  fromValue = Strict.Text.unpack <$> Decoding.text_strict instance FromValue 'PGbytea Strict.ByteString where-  fromValue _ = Decoding.bytea_strict+  fromValue = Decoding.bytea_strict instance FromValue 'PGbytea Lazy.ByteString where-  fromValue _ = Decoding.bytea_lazy-instance FromValue 'PGdate Day where fromValue _ = Decoding.date-instance FromValue 'PGtime TimeOfDay where fromValue _ = Decoding.time_int+  fromValue = Decoding.bytea_lazy+instance FromValue 'PGdate Day where fromValue = Decoding.date+instance FromValue 'PGtime TimeOfDay where fromValue = Decoding.time_int instance FromValue 'PGtimetz (TimeOfDay, TimeZone) where-  fromValue _ = Decoding.timetz_int+  fromValue = Decoding.timetz_int instance FromValue 'PGtimestamp LocalTime where-  fromValue _ = Decoding.timestamp_int+  fromValue = Decoding.timestamp_int instance FromValue 'PGtimestamptz UTCTime where-  fromValue _ = Decoding.timestamptz_int+  fromValue = Decoding.timestamptz_int instance FromValue 'PGinterval DiffTime where-  fromValue _ = Decoding.interval_int-instance FromValue 'PGjson Value where fromValue _ = Decoding.json_ast-instance FromValue 'PGjsonb Value where fromValue _ = Decoding.jsonb_ast-instance FromValue pg y => FromValue ('PGvararray pg) (Vector (Maybe y)) where-  fromValue _ = Decoding.array-    (Decoding.dimensionArray Vector.replicateM-      (Decoding.nullableValueArray (fromValue (Proxy @pg))))-instance FromValue pg y => FromValue ('PGfixarray n pg) (Vector (Maybe y)) where-  fromValue _ = Decoding.array-    (Decoding.dimensionArray Vector.replicateM-      (Decoding.nullableValueArray (fromValue (Proxy @pg))))+  fromValue = Decoding.interval_int+instance FromValue 'PGjson Aeson.Value where fromValue = Decoding.json_ast+instance FromValue 'PGjsonb Aeson.Value where fromValue = Decoding.jsonb_ast+instance Aeson.FromJSON x => FromValue 'PGjson (Json x) where+  fromValue = Json <$>+    Decoding.json_bytes (left Strict.Text.pack . Aeson.eitherDecodeStrict)+instance Aeson.FromJSON x => FromValue 'PGjsonb (Jsonb x) where+  fromValue = Jsonb <$>+    Decoding.jsonb_bytes (left Strict.Text.pack . Aeson.eitherDecodeStrict)+instance FromArray ('NotNull ('PGvararray ty)) y+  => FromValue ('PGvararray ty) y where+    fromValue = Decoding.array (fromArray @('NotNull ('PGvararray ty)) @y)+instance FromArray ('NotNull ('PGfixarray n ty)) y+  => FromValue ('PGfixarray n ty) y where+    fromValue = Decoding.array (fromArray @('NotNull ('PGfixarray n ty)) @y) instance   ( IsEnumType y   , HasDatatypeInfo y-  , LabelsFrom y ~ labels-  ) => FromValue ('PGenum labels) y where-    fromValue _ =+  , LabelsPG y ~ labels+  ) => FromValue ('PGenum labels) (Enumerated y) where+    fromValue =       let         greadConstructor           :: All ((~) '[]) xss@@ -412,29 +516,16 @@             then Just (SOP (Z Nil))             else SOP . S . unSOP <$> greadConstructor constructors name       in-        Decoding.enum+        fmap Enumerated+        . Decoding.enum         $ fmap to         . greadConstructor (constructorInfo (datatypeInfo (Proxy @y)))-        . Strict.unpack-+        . Strict.Text.unpack instance-  ( SListI fields-  , MapMaybes ys-  , IsProductType y (Maybes ys)-  , AllZip FromAliasedValue fields ys-  , FieldNamesFrom y ~ AliasesOf fields-  ) => FromValue ('PGcomposite fields) y where+  ( FromRow fields y+  ) => FromValue ('PGcomposite fields) (Composite y) where     fromValue =       let-        decoders-          :: forall pgs zs proxy-          . AllZip FromAliasedValue pgs zs-          => proxy ('PGcomposite pgs)-          -> NP Decoding.Value zs-        decoders _ = htrans (Proxy @FromAliasedValue) fromAliasedValue-          (hpure Proxy :: NP Proxy pgs)--        composite fields = do         -- <number of fields: 4 bytes>         -- [for each field]         --  <OID of field's type: sizeof(Oid) bytes>@@ -445,80 +536,103 @@         --    <value: <length> bytes>         --  [end if]         -- [end for]+        composite = Decoding.valueParser $ do           unitOfSize 4-          let-            each field = do-              unitOfSize 4-              len <- sized 4 Decoding.int-              if len == -1 then return Nothing else Just <$> sized len field-          htraverse' each fields--      in fmap (to . SOP . Z . maybes) . composite . decoders--class FromAliasedValue (pg :: (Symbol,PGType)) (y :: Type) where-  fromAliasedValue :: proxy pg -> Decoding.Value y-instance FromValue pg y => FromAliasedValue (alias ::: pg) y where-  fromAliasedValue _ = fromValue (Proxy @pg)+          hsequence' $ hpure $ Comp $ do+            unitOfSize 4+            len <- sized 4 Decoding.int+            if len == -1+              then return (K Nothing)+              else K . Just <$> bytesOfSize len+      in+        fmap Composite (Decoding.fn (fromRow @fields <=< composite)) --- | A `FromColumnValue` constraint lifts the `FromValue` parser+-- | A `FromField` constraint lifts the `FromValue` parser -- to a decoding of a @(Symbol, NullityType)@ to a `Type`, -- decoding `Null`s to `Maybe`s. You should not define instances for--- `FromColumnValue`, just use the provided instances.-class FromColumnValue (colty :: (Symbol,NullityType)) (y :: Type) where-  -- | >>> :set -XTypeOperators -XOverloadedStrings-  -- >>> newtype Id = Id { getId :: Int16 } deriving Show-  -- >>> instance FromValue 'PGint2 Id where fromValue = fmap Id . fromValue-  -- >>> fromColumnValue @("col" ::: 'NotNull 'PGint2) @Id (K (Just "\NUL\SOH"))-  -- Id {getId = 1}-  ---  -- >>> fromColumnValue @("col" ::: 'Null 'PGint2) @(Maybe Id) (K (Just "\NUL\SOH"))-  -- Just (Id {getId = 1})-  fromColumnValue :: K (Maybe Strict.ByteString) colty -> y+-- `FromField`, just use the provided instances.+class FromField (pg :: (Symbol, NullityType)) (y :: (Symbol, Type)) where+  fromField+    :: K (Maybe Strict.ByteString) pg+    -> (Either Strict.Text :.: P) y instance FromValue pg y-  => FromColumnValue (column ::: ('NotNull pg)) y where-    fromColumnValue = \case-      K Nothing -> error "fromColumnValue: saw NULL when expecting NOT NULL"-      K (Just bs) ->-        let-          errOrValue =-            Decoding.valueParser (fromValue @pg @y Proxy) bs-          err str = error $ "fromColumnValue: " ++ Strict.unpack str-        in-          either err id errOrValue+  => FromField (column ::: ('NotNull pg)) (column ::: y) where+    fromField = Comp . \case+      K Nothing -> Left "fromField: saw NULL when expecting NOT NULL"+      K (Just bytestring) -> P <$>+        Decoding.valueParser (fromValue @pg) bytestring instance FromValue pg y-  => FromColumnValue (column ::: ('Null pg)) (Maybe y) where-    fromColumnValue (K nullOrBytes)-      = either err id-      . Decoding.valueParser (fromValue @pg @y Proxy)-      <$> nullOrBytes-      where-        err str = error $ "fromColumnValue: " ++ Strict.unpack str+  => FromField (column ::: 'Null pg) (column ::: Maybe y) where+    fromField = Comp . \case+      K Nothing -> Right $ P Nothing+      K (Just bytestring) -> P . Just <$>+        Decoding.valueParser (fromValue @pg) bytestring +class FromArray (ty :: NullityType) (y :: Type) where+  fromArray :: Decoding.Array y+instance {-# OVERLAPPABLE #-} FromValue pg y+  => FromArray ('NotNull pg) y where+    fromArray = Decoding.valueArray (fromValue @pg @y)+instance {-# OVERLAPPABLE #-} FromValue pg y+  => FromArray ('Null pg) (Maybe y) where+    fromArray = Decoding.nullableValueArray (fromValue @pg @y)+instance {-# OVERLAPPING #-} FromArray array y+  => FromArray ('NotNull ('PGvararray array)) (Vector y) where+    fromArray =+      Decoding.dimensionArray Vector.replicateM (fromArray @array @y)+instance {-# OVERLAPPING #-} FromArray array y+  => FromArray ('Null ('PGvararray array)) (Maybe (Vector y)) where+    fromArray = Just <$> +      Decoding.dimensionArray Vector.replicateM (fromArray @array @y)+instance {-# OVERLAPPING #-}+  ( FromArray array y+  , All ((~) y) ys+  , SListI ys+  , IsProductType product ys )+  => FromArray ('NotNull ('PGfixarray n array)) product where+    fromArray =+      let+        rep _ = fmap (to . SOP . Z) . replicateMN+      in+        Decoding.dimensionArray rep (fromArray @array @y)+instance {-# OVERLAPPING #-}+  ( FromArray array y+  , All ((~) y) ys+  , SListI ys+  , IsProductType product ys )+  => FromArray ('Null ('PGfixarray n array)) (Maybe product) where+    fromArray =+      let+        rep _ = fmap (to . SOP . Z) . replicateMN+      in+        Just <$> Decoding.dimensionArray rep (fromArray @array @y)+ -- | A `FromRow` constraint generically sequences the parsings of the columns--- of a `RelationType` into the fields of a record `Type` provided they have+-- of a `RowType` into the fields of a record `Type` provided they have -- the same field names. You should not define instances of `FromRow`. -- Instead define `Generic` and `HasDatatypeInfo` instances which in turn -- provide `FromRow` instances.-class SListI results => FromRow (results :: RelationType) y where+class SListI result => FromRow (result :: RowType) y where   -- | >>> :set -XOverloadedStrings   -- >>> import Data.Text   -- >>> newtype UserId = UserId { getUserId :: Int16 } deriving Show-  -- >>> instance FromValue 'PGint2 UserId where fromValue = fmap UserId . fromValue+  -- >>> instance FromValue 'PGint2 UserId where fromValue = UserId <$> fromValue @'PGint2   -- >>> data UserRow = UserRow { userId :: UserId, userName :: Maybe Text } deriving (Show, GHC.Generic)   -- >>> instance Generic UserRow   -- >>> instance HasDatatypeInfo UserRow   -- >>> type User = '["userId" ::: 'NotNull 'PGint2, "userName" ::: 'Null 'PGtext]   -- >>> fromRow @User @UserRow (K (Just "\NUL\SOH") :* K (Just "bloodninja") :* Nil)-  -- UserRow {userId = UserId {getUserId = 1}, userName = Just "bloodninja"}-  fromRow :: NP (K (Maybe Strict.ByteString)) results -> y+  -- Right (UserRow {userId = UserId {getUserId = 1}, userName = Just "bloodninja"})+  fromRow :: NP (K (Maybe Strict.ByteString)) result -> Either Strict.Text y instance-  ( SListI results-  , IsProductType y ys-  , AllZip FromColumnValue results ys-  , FieldNamesFrom y ~ AliasesOf results-  ) => FromRow results y where+  ( SListI result+  , IsRecord y ys+  , AllZip FromField result ys+  ) => FromRow result y where     fromRow-      = to . SOP . Z . htrans (Proxy @FromColumnValue) (I . fromColumnValue)+      = fmap fromRecord+      . hsequence'+      . htrans (Proxy @FromField) fromField  -- | `Only` is a 1-tuple type, useful for encoding a single parameter with -- `toParams` or decoding a single value with `fromRow`.@@ -528,8 +642,21 @@ -- K (Just "foo") :* Nil -- -- >>> fromRow @'["fromOnly" ::: 'Null 'PGtext] @(Only (Maybe Text)) (K (Just "bar") :* Nil)--- Only {fromOnly = Just "bar"}+-- Right (Only {fromOnly = Just "bar"}) newtype Only x = Only { fromOnly :: x }   deriving (Functor,Foldable,Traversable,Eq,Ord,Read,Show,GHC.Generic) instance Generic (Only x) instance HasDatatypeInfo (Only x)++foldlN+  :: All ((~) x) xs+  => (z -> x -> z) -> z -> NP I xs -> z+foldlN f z = \case+  Nil -> z+  I x :* xs -> let z' = f z x in seq z' $ foldlN f z' xs++replicateMN+  :: forall x xs m. (All ((~) x) xs, Monad m, SListI xs)+  => m x -> m (NP I xs)+replicateMN mx = hsequence' $+  hcpure (Proxy :: Proxy ((~) x)) (Comp (I <$> mx)) 

@@ -270,7 +270,7 @@ -} check   :: ( Has alias schema ('Table table)-     , HasAll aliases (TableToRelation table) subcolumns )+     , HasAll aliases (TableToRow table) subcolumns )   => NP Alias aliases   -- ^ specify the subcolumns which are getting checked   -> (forall tab. Condition schema '[tab ::: subcolumns] 'Ungrouped '[])@@ -304,7 +304,7 @@ -} unique   :: ( Has alias schema ('Table table)-     , HasAll aliases (TableToRelation table) subcolumns )+     , HasAll aliases (TableToRow table) subcolumns )   => NP Alias aliases   -- ^ specify subcolumns which together are unique for each row   -> TableConstraintExpression schema alias ('Unique aliases)@@ -807,9 +807,9 @@ createView   :: KnownSymbol view   => Alias view -- ^ the name of the view to add-  -> Query schema '[] relation+  -> Query schema '[] row     -- ^ query-  -> Definition schema (Create view ('View relation) schema)+  -> Definition schema (Create view ('View row) schema) createView alias query = UnsafeDefinition $   "CREATE" <+> "VIEW" <+> renderAlias alias <+> "AS"   <+> renderQuery query <> ";"@@ -857,19 +857,23 @@ createTypeEnumFrom   :: forall hask enum schema.   ( SOP.Generic hask-  , SOP.All KnownSymbol (LabelsFrom hask)+  , SOP.All KnownSymbol (LabelsPG hask)   , KnownSymbol enum   )   => Alias enum   -- ^ name of the user defined enumerated type-  -> Definition schema (Create enum ('Typedef (EnumFrom hask)) schema)+  -> Definition schema (Create enum ('Typedef (PG (Enumerated hask))) schema) createTypeEnumFrom enum = createTypeEnum enum-  (SOP.hpure label :: NP PGlabel (LabelsFrom hask))+  (SOP.hpure label :: NP PGlabel (LabelsPG hask))  {- | `createTypeComposite` creates a composite type. The composite type is specified by a list of attribute names and data types. ->>> type PGcomplex = 'PGcomposite '["real" ::: 'PGfloat8, "imaginary" ::: 'PGfloat8]+>>> :{+type PGcomplex = 'PGcomposite+  '[ "real"      ::: 'NotNull 'PGfloat8+   , "imaginary" ::: 'NotNull 'PGfloat8 ]+:}  >>> :{ let@@ -892,36 +896,39 @@   (renderCommaSeparated renderField fields) <> ";"   where     renderField :: Aliased (TypeExpression schema) x -> ByteString-    renderField (typ `As` field) =-      renderAlias field <+> renderTypeExpression typ+    renderField (typ `As` alias) =+      renderAlias alias <+> renderTypeExpression typ  -- | Composite types can also be generated from a Haskell type, for example ----- >>> data Complex = Complex {real :: Maybe Double, imaginary :: Maybe Double} deriving GHC.Generic+-- >>> data Complex = Complex {real :: Double, imaginary :: Double} deriving GHC.Generic -- >>> instance SOP.Generic Complex -- >>> instance SOP.HasDatatypeInfo Complex -- >>> printSQL $ createTypeCompositeFrom @Complex #complex -- CREATE TYPE "complex" AS ("real" float8, "imaginary" float8); createTypeCompositeFrom   :: forall hask ty schema.-  ( ZipAliased (FieldNamesFrom hask) (FieldTypesFrom hask)-  , SOP.All (PGTyped schema) (FieldTypesFrom hask)-  , KnownSymbol ty-  )+  ( SOP.All (FieldTyped schema) (RowPG hask)+  , KnownSymbol ty )   => Alias ty   -- ^ name of the user defined composite type-  -> Definition schema (Create ty ( 'Typedef (CompositeFrom hask)) schema)-createTypeCompositeFrom ty = createTypeComposite ty $ zipAs-  (SOP.hpure Alias :: NP Alias (FieldNamesFrom hask))-  (SOP.hcpure (SOP.Proxy :: SOP.Proxy (PGTyped schema)) pgtype-    :: NP (TypeExpression schema) (FieldTypesFrom hask))+  -> Definition schema (Create ty ( 'Typedef (PG (Composite hask))) schema)+createTypeCompositeFrom ty = createTypeComposite ty+  (SOP.hcpure (SOP.Proxy :: SOP.Proxy (FieldTyped schema)) fieldtype+    :: NP (Aliased (TypeExpression schema)) (RowPG hask)) +class FieldTyped schema ty where+  fieldtype :: Aliased (TypeExpression schema) ty+instance (KnownSymbol alias, PGTyped schema ty)+  => FieldTyped schema (alias ::: ty) where+    fieldtype = pgtype `As` Alias+ -- | Drop a type. -- -- >>> data Schwarma = Beef | Lamb | Chicken deriving GHC.Generic -- >>> instance SOP.Generic Schwarma -- >>> instance SOP.HasDatatypeInfo Schwarma--- >>> printSQL (dropType #schwarma :: Definition '["schwarma" ::: 'Typedef (EnumFrom Schwarma)] '[])+-- >>> printSQL (dropType #schwarma :: Definition '["schwarma" ::: 'Typedef (PG (Enumerated Schwarma))] '[]) -- DROP TYPE "schwarma"; dropType   :: Has tydef schema ('Typedef ty)@@ -938,15 +945,15 @@ -- | used in `createTable` commands as a column constraint to note that -- @NULL@ may be present in a column nullable-  :: TypeExpression schema ty+  :: TypeExpression schema (nullity ty)   -> ColumnTypeExpression schema ('NoDef :=> 'Null ty) nullable ty = UnsafeColumnTypeExpression $ renderTypeExpression ty <+> "NULL"  -- | used in `createTable` commands as a column constraint to ensure -- @NULL@ is not present in a column notNullable-  :: TypeExpression schema ty-  -> ColumnTypeExpression schema (def :=> 'NotNull ty)+  :: TypeExpression schema (nullity ty)+  -> ColumnTypeExpression schema ('NoDef :=> 'NotNull ty) notNullable ty = UnsafeColumnTypeExpression $ renderTypeExpression ty <+> "NOT NULL"  -- | used in `createTable` commands as a column constraint to give a default

@@ -45,7 +45,9 @@   , nullIf     -- ** Collections   , array+  , index   , row+  , field     -- ** Functions   , unsafeBinaryOp   , unsafeUnaryOp@@ -61,12 +63,12 @@   , greatest   , least     -- ** Conditions-  , Condition   , true   , false   , not_   , (.&&)   , (.||)+  , Condition   , caseWhenThenElse   , ifThenElse   , (.==)@@ -86,16 +88,13 @@   , upper   , charLength   , like-    -- ** json or jsonb operators-  , PGarray-  , PGarrayOf-  , PGjsonKey-  , PGjson_+    -- ** Json+    -- *** Json and Jsonb operators   , (.->)   , (.->>)   , (.#>)   , (.#>>)-    -- *** jsonb only operators+    -- *** Jsonb operators   , (.@>)   , (.<@)   , (.?)@@ -124,8 +123,6 @@   , jsonbExtractPath   , jsonExtractPathAsText   , jsonbExtractPathAsText-  , jsonObjectKeys-  , jsonbObjectKeys   , jsonTypeof   , jsonbTypeof   , jsonStripNulls@@ -146,6 +143,9 @@     -- * Types   , TypeExpression (UnsafeTypeExpression, renderTypeExpression)   , PGTyped (pgtype)+  , typedef+  , typetable+  , typeview   , bool   , int2   , smallint@@ -191,6 +191,7 @@ import qualified Data.Aeson as JSON import Data.Ratio import Data.String+import Data.Word import Generics.SOP hiding (from) import GHC.OverloadedLabels import GHC.TypeLits@@ -217,14 +218,14 @@ -} newtype Expression   (schema :: SchemaType)-  (relations :: RelationsType)+  (from :: FromType)   (grouping :: Grouping)   (params :: [NullityType])   (ty :: NullityType)     = UnsafeExpression { renderExpression :: ByteString }     deriving (GHC.Generic,Show,Eq,Ord,NFData) -instance RenderSQL (Expression schema relations grouping params ty) where+instance RenderSQL (Expression schema from grouping params ty) where   renderSQL = renderExpression  {- | A `HasParameter` constraint is used to indicate a value that is@@ -247,10 +248,10 @@     -- >>> printSQL expr     -- ($1 :: int4)     parameter-      :: TypeExpression schema (PGTypeOf ty)-      -> Expression schema relations grouping params ty+      :: TypeExpression schema ty+      -> Expression schema from grouping params ty     parameter ty = UnsafeExpression $ parenthesized $-      "$" <> renderNat (Proxy @n) <+> "::"+      "$" <> renderNat @n <+> "::"         <+> renderTypeExpression ty instance {-# OVERLAPPING #-} HasParameter 1 schema (ty1:tys) ty1 instance {-# OVERLAPPABLE #-} (KnownNat n, HasParameter (n-1) schema params ty)@@ -263,84 +264,84 @@ -- >>> printSQL expr -- ($1 :: int4) param-  :: forall n schema params relations grouping ty-   . (PGTyped schema (PGTypeOf ty), HasParameter n schema params ty)-  => Expression schema relations grouping params ty -- ^ param+  :: forall n schema params from grouping ty+   . (PGTyped schema ty, HasParameter n schema params ty)+  => Expression schema from grouping params ty -- ^ param param = parameter @n pgtype -instance (HasUnique relation relations columns, Has column columns ty)-  => IsLabel column (Expression schema relations 'Ungrouped params ty) where+instance (HasUnique table from columns, Has column columns ty)+  => IsLabel column (Expression schema from 'Ungrouped params ty) where     fromLabel = UnsafeExpression $ renderAlias (Alias @column)-instance (HasUnique relation relations columns, Has column columns ty)+instance (HasUnique table from columns, Has column columns ty)   => IsLabel column-    (Aliased (Expression schema relations 'Ungrouped params) (column ::: ty)) where+    (Aliased (Expression schema from 'Ungrouped params) (column ::: ty)) where     fromLabel = fromLabel @column `As` Alias @column-instance (HasUnique relation relations columns, Has column columns ty)+instance (HasUnique table from columns, Has column columns ty)   => IsLabel column-    (NP (Aliased (Expression schema relations 'Ungrouped params)) '[column ::: ty]) where+    (NP (Aliased (Expression schema from 'Ungrouped params)) '[column ::: ty]) where     fromLabel = fromLabel @column :* Nil -instance (Has relation relations columns, Has column columns ty)-  => IsQualified relation column (Expression schema relations 'Ungrouped params ty) where-    relation ! column = UnsafeExpression $-      renderAlias relation <> "." <> renderAlias column-instance (Has relation relations columns, Has column columns ty)-  => IsQualified relation column-    (Aliased (Expression schema relations 'Ungrouped params) (column ::: ty)) where-    relation ! column = relation ! column `As` column-instance (Has relation relations columns, Has column columns ty)-  => IsQualified relation column-    (NP (Aliased (Expression schema relations 'Ungrouped params)) '[column ::: ty]) where-    relation ! column = relation ! column :* Nil+instance (Has table from columns, Has column columns ty)+  => IsQualified table column (Expression schema from 'Ungrouped params ty) where+    table ! column = UnsafeExpression $+      renderAlias table <> "." <> renderAlias column+instance (Has table from columns, Has column columns ty)+  => IsQualified table column+    (Aliased (Expression schema from 'Ungrouped params) (column ::: ty)) where+    table ! column = table ! column `As` column+instance (Has table from columns, Has column columns ty)+  => IsQualified table column+    (NP (Aliased (Expression schema from 'Ungrouped params)) '[column ::: ty]) where+    table ! column = table ! column :* Nil  instance-  ( HasUnique relation relations columns+  ( HasUnique table from columns   , Has column columns ty-  , GroupedBy relation column bys+  , GroupedBy table column bys   ) => IsLabel column-    (Expression schema relations ('Grouped bys) params ty) where+    (Expression schema from ('Grouped bys) params ty) where       fromLabel = UnsafeExpression $ renderAlias (Alias @column) instance-  ( HasUnique relation relations columns+  ( HasUnique table from columns   , Has column columns ty-  , GroupedBy relation column bys+  , GroupedBy table column bys   ) => IsLabel column-    ( Aliased (Expression schema relations ('Grouped bys) params)+    ( Aliased (Expression schema from ('Grouped bys) params)       (column ::: ty) ) where       fromLabel = fromLabel @column `As` Alias @column instance-  ( HasUnique relation relations columns+  ( HasUnique table from columns   , Has column columns ty-  , GroupedBy relation column bys+  , GroupedBy table column bys   ) => IsLabel column-    ( NP (Aliased (Expression schema relations ('Grouped bys) params))+    ( NP (Aliased (Expression schema from ('Grouped bys) params))       '[column ::: ty] ) where       fromLabel = fromLabel @column :* Nil  instance-  ( Has relation relations columns+  ( Has table from columns   , Has column columns ty-  , GroupedBy relation column bys-  ) => IsQualified relation column-    (Expression schema relations ('Grouped bys) params ty) where-      relation ! column = UnsafeExpression $-        renderAlias relation <> "." <> renderAlias column+  , GroupedBy table column bys+  ) => IsQualified table column+    (Expression schema from ('Grouped bys) params ty) where+      table ! column = UnsafeExpression $+        renderAlias table <> "." <> renderAlias column instance-  ( Has relation relations columns+  ( Has table from columns   , Has column columns ty-  , GroupedBy relation column bys-  ) => IsQualified relation column-    (Aliased (Expression schema relations ('Grouped bys) params)+  , GroupedBy table column bys+  ) => IsQualified table column+    (Aliased (Expression schema from ('Grouped bys) params)       (column ::: ty)) where-        relation ! column = relation ! column `As` column+        table ! column = table ! column `As` column instance-  ( Has relation relations columns+  ( Has table from columns   , Has column columns ty-  , GroupedBy relation column bys-  ) => IsQualified relation column-    ( NP (Aliased (Expression schema relations ('Grouped bys) params))+  , GroupedBy table column bys+  ) => IsQualified table column+    ( NP (Aliased (Expression schema from ('Grouped bys) params))       '[column ::: ty]) where-        relation ! column = relation ! column :* Nil+        table ! column = table ! column :* Nil  -- | analagous to `Nothing` --@@ -360,14 +361,14 @@  -- | return the leftmost value which is not NULL ----- >>> printSQL $ coalesce [null_, notNull true] false+-- >>> printSQL $ coalesce [null_, true] false -- COALESCE(NULL, TRUE, FALSE) coalesce-  :: [Expression schema relations grouping params ('Null ty)]+  :: [Expression schema from grouping params ('Null ty)]   -- ^ @NULL@s may be present-  -> Expression schema relations grouping params ('NotNull ty)+  -> Expression schema from grouping params ('NotNull ty)   -- ^ @NULL@ is absent-  -> Expression schema relations grouping params ('NotNull ty)+  -> Expression schema from grouping params ('NotNull ty) coalesce nullxs notNullx = UnsafeExpression $   "COALESCE" <> parenthesized (commaSeparated     ((renderExpression <$> nullxs) <> [renderExpression notNullx]))@@ -377,26 +378,26 @@ -- >>> printSQL $ fromNull true null_ -- COALESCE(NULL, TRUE) fromNull-  :: Expression schema relations grouping params ('NotNull ty)+  :: Expression schema from grouping params ('NotNull ty)   -- ^ what to convert @NULL@ to-  -> Expression schema relations grouping params ('Null ty)-  -> Expression schema relations grouping params ('NotNull ty)+  -> Expression schema from grouping params ('Null ty)+  -> Expression schema from grouping params ('NotNull ty) fromNull notNullx nullx = coalesce [nullx] notNullx  -- | >>> printSQL $ null_ & isNull -- NULL IS NULL isNull-  :: Expression schema relations grouping params ('Null ty)+  :: Expression schema from grouping params ('Null ty)   -- ^ possibly @NULL@-  -> Condition schema relations grouping params+  -> Condition schema from grouping params isNull x = UnsafeExpression $ renderExpression x <+> "IS NULL"  -- | >>> printSQL $ null_ & isNotNull -- NULL IS NOT NULL isNotNull-  :: Expression schema relations grouping params ('Null ty)+  :: Expression schema from grouping params ('Null ty)   -- ^ possibly @NULL@-  -> Condition schema relations grouping params+  -> Condition schema from grouping params isNotNull x = UnsafeExpression $ renderExpression x <+> "IS NOT NULL"  -- | analagous to `maybe` using @IS NULL@@@ -404,13 +405,13 @@ -- >>> printSQL $ matchNull true not_ null_ -- CASE WHEN NULL IS NULL THEN TRUE ELSE (NOT NULL) END matchNull-  :: Expression schema relations grouping params (nullty)+  :: Expression schema from grouping params (nullty)   -- ^ what to convert @NULL@ to-  -> ( Expression schema relations grouping params ('NotNull ty)-       -> Expression schema relations grouping params (nullty) )+  -> ( Expression schema from grouping params ('NotNull ty)+       -> Expression schema from grouping params (nullty) )   -- ^ function to perform when @NULL@ is absent-  -> Expression schema relations grouping params ('Null ty)-  -> Expression schema relations grouping params (nullty)+  -> Expression schema from grouping params ('Null ty)+  -> Expression schema from grouping params (nullty) matchNull y f x = ifThenElse (isNull x) y   (f (UnsafeExpression (renderExpression x))) @@ -423,55 +424,81 @@ NULL IF (FALSE, ($1 :: bool)) -} nullIf-  :: Expression schema relations grouping params ('NotNull ty)+  :: Expression schema from grouping params ('NotNull ty)   -- ^ @NULL@ is absent-  -> Expression schema relations grouping params ('NotNull ty)+  -> Expression schema from grouping params ('NotNull ty)   -- ^ @NULL@ is absent-  -> Expression schema relations grouping params ('Null ty)+  -> Expression schema from grouping params ('Null ty) nullIf x y = UnsafeExpression $ "NULL IF" <+> parenthesized   (renderExpression x <> ", " <> renderExpression y) --- | >>> printSQL $ array [null_, notNull false, notNull true]+-- | >>> printSQL $ array [null_, false, true] -- ARRAY[NULL, FALSE, TRUE] array-  :: [Expression schema relations grouping params ('Null ty)]+  :: [Expression schema from grouping params ty]   -- ^ array elements-  -> Expression schema relations grouping params (nullity ('PGvararray ty))+  -> Expression schema from grouping params (nullity ('PGvararray ty)) array xs = UnsafeExpression $   "ARRAY[" <> commaSeparated (renderExpression <$> xs) <> "]" +-- | >>> printSQL $ array [null_, false, true] & index 2+-- (ARRAY[NULL, FALSE, TRUE])[2]+index+  :: Word64 -- ^ index+  -> Expression schema from grouping params (nullity ('PGvararray ty)) -- ^ array+  -> Expression schema from grouping params (NullifyType ty)+index n expr = UnsafeExpression $+  parenthesized (renderExpression expr) <> "[" <> fromString (show n) <> "]"+ instance (KnownSymbol label, label `In` labels) => IsPGlabel label-  (Expression schema relations grouping params (nullity ('PGenum labels))) where+  (Expression schema from grouping params (nullity ('PGenum labels))) where   label = UnsafeExpression $ renderLabel (PGlabel @label)  -- | A row constructor is an expression that builds a row value -- (also called a composite value) using values for its member fields. ----- >>> type Complex = PGcomposite '["real" ::: 'PGfloat8, "imaginary" ::: 'PGfloat8]+-- >>> :{+-- type Complex = 'PGcomposite+--   '[ "real"      ::: 'NotNull 'PGfloat8+--    , "imaginary" ::: 'NotNull 'PGfloat8 ]+-- :}+-- -- >>> let i = row (0 `as` #real :* 1 `as` #imaginary) :: Expression '[] '[] 'Ungrouped '[] ('NotNull Complex) -- >>> printSQL i -- ROW(0, 1) row-  :: SListI (Nulls fields)-  => NP (Aliased (Expression schema relations grouping params)) (Nulls fields)+  :: SListI row+  => NP (Aliased (Expression schema from grouping params)) row   -- ^ zero or more expressions for the row field values-  -> Expression schema relations grouping params (nullity ('PGcomposite fields))+  -> Expression schema from grouping params (nullity ('PGcomposite row)) row exprs = UnsafeExpression $ "ROW" <> parenthesized   (renderCommaSeparated (\ (expr `As` _) -> renderExpression expr) exprs) -instance Has field fields ty => IsLabel field-  (   Expression schema relation grouping params (nullity ('PGcomposite fields))-   -> Expression schema relation grouping params ('Null ty) ) where-    fromLabel expr = UnsafeExpression $-      parenthesized (renderExpression expr) <> "." <>-        fromString (symbolVal (Proxy @field))+-- | >>> :{+-- type Complex = 'PGcomposite+--   '[ "real"      ::: 'NotNull 'PGfloat8+--    , "imaginary" ::: 'NotNull 'PGfloat8 ]+-- :}+--+-- >>> let i = row (0 `as` #real :* 1 `as` #imaginary) :: Expression '["complex" ::: 'Typedef Complex] '[] 'Ungrouped '[] ('NotNull Complex)+-- >>> printSQL $ i & field #complex #imaginary+-- (ROW(0, 1)::"complex")."imaginary"+field+  :: (Has tydef schema ('Typedef ('PGcomposite row)), Has field row ty)+  => Alias tydef -- ^ row type+  -> Alias field -- ^ field name+  -> Expression schema from grouping params ('NotNull ('PGcomposite row))+  -> Expression schema from grouping params ty+field td fld expr = UnsafeExpression $+  parenthesized (renderExpression expr <> "::" <> renderAlias td)+    <> "." <> renderAlias fld  instance Semigroup-  (Expression schema relations grouping params (nullity ('PGvararray ty))) where+  (Expression schema from grouping params (nullity ('PGvararray ty))) where     (<>) = unsafeBinaryOp "||"  instance Monoid-  (Expression schema relations grouping params (nullity ('PGvararray ty))) where+  (Expression schema from grouping params (nullity ('PGvararray ty))) where     mempty = array []     mappend = (<>) @@ -479,22 +506,22 @@ -- >>> printSQL expr -- GREATEST(CURRENT_TIMESTAMP, ($1 :: timestamp with time zone)) greatest-  :: Expression schema relations grouping params (nullty)+  :: Expression schema from grouping params (nullty)   -- ^ needs at least 1 argument-  -> [Expression schema relations grouping params (nullty)]+  -> [Expression schema from grouping params (nullty)]   -- ^ or more-  -> Expression schema relations grouping params (nullty)+  -> Expression schema from grouping params (nullty) greatest x xs = UnsafeExpression $ "GREATEST("   <> commaSeparated (renderExpression <$> (x:xs)) <> ")"  -- | >>> printSQL $ least currentTimestamp [null_] -- LEAST(CURRENT_TIMESTAMP, NULL) least-  :: Expression schema relations grouping params (nullty)+  :: Expression schema from grouping params (nullty)   -- ^ needs at least 1 argument-  -> [Expression schema relations grouping params (nullty)]+  -> [Expression schema from grouping params (nullty)]   -- ^ or more-  -> Expression schema relations grouping params (nullty)+  -> Expression schema from grouping params (nullty) least x xs = UnsafeExpression $ "LEAST("   <> commaSeparated (renderExpression <$> (x:xs)) <> ")" @@ -503,9 +530,9 @@ unsafeBinaryOp   :: ByteString   -- ^ operator-  -> Expression schema relations grouping params (ty0)-  -> Expression schema relations grouping params (ty1)-  -> Expression schema relations grouping params (ty2)+  -> Expression schema from grouping params (ty0)+  -> Expression schema from grouping params (ty1)+  -> Expression schema from grouping params (ty2) unsafeBinaryOp op x y = UnsafeExpression $ parenthesized $   renderExpression x <+> op <+> renderExpression y @@ -514,8 +541,8 @@ unsafeUnaryOp   :: ByteString   -- ^ operator-  -> Expression schema relations grouping params (ty0)-  -> Expression schema relations grouping params (ty1)+  -> Expression schema from grouping params (ty0)+  -> Expression schema from grouping params (ty1) unsafeUnaryOp op x = UnsafeExpression $ parenthesized $   op <+> renderExpression x @@ -524,8 +551,8 @@ unsafeFunction   :: ByteString   -- ^ function-  -> Expression schema relations grouping params (xty)-  -> Expression schema relations grouping params (yty)+  -> Expression schema from grouping params (xty)+  -> Expression schema from grouping params (yty) unsafeFunction fun x = UnsafeExpression $   fun <> parenthesized (renderExpression x) @@ -534,13 +561,13 @@   :: SListI elems   => ByteString   -- ^ function-  -> NP (Expression schema relations grouping params) elems-  -> Expression schema relations grouping params ret+  -> NP (Expression schema from grouping params) elems+  -> Expression schema from grouping params ret unsafeVariadicFunction fun x = UnsafeExpression $   fun <> parenthesized (commaSeparated (hcollapse (hmap (K . renderExpression) x))) -instance PGNum ty-  => Num (Expression schema relations grouping params (nullity ty)) where+instance ty `In` PGNum+  => Num (Expression schema from grouping params (nullity ty)) where     (+) = unsafeBinaryOp "+"     (-) = unsafeBinaryOp "-"     (*) = unsafeBinaryOp "*"@@ -551,13 +578,13 @@       . fromString       . show -instance (PGNum ty, PGFloating ty) => Fractional-  (Expression schema relations grouping params (nullity ty)) where+instance (ty `In` PGNum, ty `In` PGFloating) => Fractional+  (Expression schema from grouping params (nullity ty)) where     (/) = unsafeBinaryOp "/"     fromRational x = fromInteger (numerator x) / fromInteger (denominator x) -instance (PGNum ty, PGFloating ty) => Floating-  (Expression schema relations grouping params (nullity ty)) where+instance (ty `In` PGNum, ty `In` PGFloating) => Floating+  (Expression schema from grouping params (nullity ty)) where     pi = UnsafeExpression "pi()"     exp = unsafeFunction "exp"     log = unsafeFunction "ln"@@ -580,18 +607,18 @@  -- | >>> :{ -- let---   expression :: Expression schema relations grouping params (nullity 'PGfloat4)+--   expression :: Expression schema from grouping params (nullity 'PGfloat4) --   expression = atan2_ pi 2 -- in printSQL expression -- :} -- atan2(pi(), 2) atan2_-  :: PGFloating float-  => Expression schema relations grouping params (nullity float)+  :: float `In` PGFloating+  => Expression schema from grouping params (nullity float)   -- ^ numerator-  -> Expression schema relations grouping params (nullity float)+  -> Expression schema from grouping params (nullity float)   -- ^ denominator-  -> Expression schema relations grouping params (nullity float)+  -> Expression schema from grouping params (nullity float) atan2_ y x = UnsafeExpression $   "atan2(" <> renderExpression y <> ", " <> renderExpression x <> ")" @@ -604,9 +631,9 @@ cast   :: TypeExpression schema ty1   -- ^ type to cast as-  -> Expression schema relations grouping params (nullity ty0)+  -> Expression schema from grouping params ty0   -- ^ value to convert-  -> Expression schema relations grouping params (nullity ty1)+  -> Expression schema from grouping params ty1 cast ty x = UnsafeExpression $ parenthesized $   renderExpression x <+> "::" <+> renderTypeExpression ty @@ -614,135 +641,136 @@ -- -- >>> :{ -- let---   expression :: Expression schema relations grouping params (nullity 'PGint2)+--   expression :: Expression schema from grouping params (nullity 'PGint2) --   expression = 5 `quot_` 2 -- in printSQL expression -- :} -- (5 / 2) quot_-  :: PGIntegral int-  => Expression schema relations grouping params (nullity int)+  :: int `In` PGIntegral+  => Expression schema from grouping params (nullity int)   -- ^ numerator-  -> Expression schema relations grouping params (nullity int)+  -> Expression schema from grouping params (nullity int)   -- ^ denominator-  -> Expression schema relations grouping params (nullity int)+  -> Expression schema from grouping params (nullity int) quot_ = unsafeBinaryOp "/"  -- | remainder upon integer division -- -- >>> :{ -- let---   expression :: Expression schema relations grouping params (nullity 'PGint2)+--   expression :: Expression schema from grouping params (nullity 'PGint2) --   expression = 5 `rem_` 2 -- in printSQL expression -- :} -- (5 % 2) rem_-  :: PGIntegral int-  => Expression schema relations grouping params (nullity int)+  :: int `In` PGIntegral+  => Expression schema from grouping params (nullity int)   -- ^ numerator-  -> Expression schema relations grouping params (nullity int)+  -> Expression schema from grouping params (nullity int)   -- ^ denominator-  -> Expression schema relations grouping params (nullity int)+  -> Expression schema from grouping params (nullity int) rem_ = unsafeBinaryOp "%"  -- | >>> :{ -- let---   expression :: Expression schema relations grouping params (nullity 'PGfloat4)+--   expression :: Expression schema from grouping params (nullity 'PGfloat4) --   expression = trunc pi -- in printSQL expression -- :} -- trunc(pi()) trunc-  :: PGFloating frac-  => Expression schema relations grouping params (nullity frac)+  :: frac `In` PGFloating+  => Expression schema from grouping params (nullity frac)   -- ^ fractional number-  -> Expression schema relations grouping params (nullity frac)+  -> Expression schema from grouping params (nullity frac) trunc = unsafeFunction "trunc"  -- | >>> :{ -- let---   expression :: Expression schema relations grouping params (nullity 'PGfloat4)+--   expression :: Expression schema from grouping params (nullity 'PGfloat4) --   expression = round_ pi -- in printSQL expression -- :} -- round(pi()) round_-  :: PGFloating frac-  => Expression schema relations grouping params (nullity frac)+  :: frac `In` PGFloating+  => Expression schema from grouping params (nullity frac)   -- ^ fractional number-  -> Expression schema relations grouping params (nullity frac)+  -> Expression schema from grouping params (nullity frac) round_ = unsafeFunction "round"  -- | >>> :{ -- let---   expression :: Expression schema relations grouping params (nullity 'PGfloat4)+--   expression :: Expression schema from grouping params (nullity 'PGfloat4) --   expression = ceiling_ pi -- in printSQL expression -- :} -- ceiling(pi()) ceiling_-  :: PGFloating frac-  => Expression schema relations grouping params (nullity frac)+  :: frac `In` PGFloating+  => Expression schema from grouping params (nullity frac)   -- ^ fractional number-  -> Expression schema relations grouping params (nullity frac)+  -> Expression schema from grouping params (nullity frac) ceiling_ = unsafeFunction "ceiling" --- | A `Condition` is a boolean valued `Expression`. While SQL allows--- conditions to have @NULL@, Squeal instead chooses to disallow @NULL@,--- forcing one to handle the case of @NULL@ explicitly to produce--- a `Condition`.-type Condition schema relations grouping params =-  Expression schema relations grouping params ('NotNull 'PGbool)+-- | A `Condition` is an `Expression`, which can evaluate+-- to `true`, `false` or `null_`. This is because SQL uses+-- a three valued logic.+type Condition schema from grouping params =+  Expression schema from grouping params ('Null 'PGbool)  -- | >>> printSQL true -- TRUE-true :: Condition schema relations grouping params+true :: Expression schema from grouping params (nullity 'PGbool) true = UnsafeExpression "TRUE"  -- | >>> printSQL false -- FALSE-false :: Condition schema relations grouping params+false :: Expression schema from grouping params (nullity 'PGbool) false = UnsafeExpression "FALSE"  -- | >>> printSQL $ not_ true -- (NOT TRUE) not_-  :: Condition schema relations grouping params-  -> Condition schema relations grouping params+  :: Expression schema from grouping params (nullity 'PGbool)+  -> Expression schema from grouping params (nullity 'PGbool) not_ = unsafeUnaryOp "NOT"  -- | >>> printSQL $ true .&& false -- (TRUE AND FALSE) (.&&)-  :: Condition schema relations grouping params-  -> Condition schema relations grouping params-  -> Condition schema relations grouping params+  :: Expression schema from grouping params (nullity 'PGbool)+  -> Expression schema from grouping params (nullity 'PGbool)+  -> Expression schema from grouping params (nullity 'PGbool)+infixr 3 .&& (.&&) = unsafeBinaryOp "AND"  -- | >>> printSQL $ true .|| false -- (TRUE OR FALSE) (.||)-  :: Condition schema relations grouping params-  -> Condition schema relations grouping params-  -> Condition schema relations grouping params+  :: Expression schema from grouping params (nullity 'PGbool)+  -> Expression schema from grouping params (nullity 'PGbool)+  -> Expression schema from grouping params (nullity 'PGbool)+infixr 2 .|| (.||) = unsafeBinaryOp "OR"  -- | >>> :{ -- let---   expression :: Expression schema relations grouping params (nullity 'PGint2)+--   expression :: Expression schema from grouping params (nullity 'PGint2) --   expression = caseWhenThenElse [(true, 1), (false, 2)] 3 -- in printSQL expression -- :} -- CASE WHEN TRUE THEN 1 WHEN FALSE THEN 2 ELSE 3 END caseWhenThenElse-  :: [ ( Condition schema relations grouping params-       , Expression schema relations grouping params (ty)+  :: [ ( Condition schema from grouping params+       , Expression schema from grouping params ty      ) ]   -- ^ whens and thens-  -> Expression schema relations grouping params (ty)+  -> Expression schema from grouping params ty   -- ^ else-  -> Expression schema relations grouping params (ty)+  -> Expression schema from grouping params ty caseWhenThenElse whenThens else_ = UnsafeExpression $ mconcat   [ "CASE"   , mconcat@@ -758,103 +786,103 @@  -- | >>> :{ -- let---   expression :: Expression schema relations grouping params (nullity 'PGint2)+--   expression :: Expression schema from grouping params (nullity 'PGint2) --   expression = ifThenElse true 1 0 -- in printSQL expression -- :} -- CASE WHEN TRUE THEN 1 ELSE 0 END ifThenElse-  :: Condition schema relations grouping params-  -> Expression schema relations grouping params (ty) -- ^ then-  -> Expression schema relations grouping params (ty) -- ^ else-  -> Expression schema relations grouping params (ty)+  :: Condition schema from grouping params+  -> Expression schema from grouping params ty -- ^ then+  -> Expression schema from grouping params ty -- ^ else+  -> Expression schema from grouping params ty ifThenElse if_ then_ else_ = caseWhenThenElse [(if_,then_)] else_  -- | Comparison operations like `.==`, `./=`, `.>`, `.>=`, `.<` and `.<=` -- will produce @NULL@s if one of their arguments is @NULL@. ----- >>> printSQL $ notNull true .== null_+-- >>> printSQL $ true .== null_ -- (TRUE = NULL) (.==)-  :: Expression schema relations grouping params (nullity ty) -- ^ lhs-  -> Expression schema relations grouping params (nullity ty) -- ^ rhs-  -> Expression schema relations grouping params (nullity 'PGbool)+  :: Expression schema from grouping params (nullity0 ty) -- ^ lhs+  -> Expression schema from grouping params (nullity1 ty) -- ^ rhs+  -> Condition schema from grouping params (.==) = unsafeBinaryOp "=" infix 4 .== --- | >>> printSQL $ notNull true ./= null_+-- | >>> printSQL $ true ./= null_ -- (TRUE <> NULL) (./=)-  :: Expression schema relations grouping params (nullity ty) -- ^ lhs-  -> Expression schema relations grouping params (nullity ty) -- ^ rhs-  -> Expression schema relations grouping params (nullity 'PGbool)+  :: Expression schema from grouping params (nullity0 ty) -- ^ lhs+  -> Expression schema from grouping params (nullity1 ty) -- ^ rhs+  -> Condition schema from grouping params (./=) = unsafeBinaryOp "<>" infix 4 ./= --- | >>> printSQL $ notNull true .>= null_+-- | >>> printSQL $ true .>= null_ -- (TRUE >= NULL) (.>=)-  :: Expression schema relations grouping params (nullity ty) -- ^ lhs-  -> Expression schema relations grouping params (nullity ty) -- ^ rhs-  -> Expression schema relations grouping params (nullity 'PGbool)+  :: Expression schema from grouping params (nullity0 ty) -- ^ lhs+  -> Expression schema from grouping params (nullity1 ty) -- ^ rhs+  -> Condition schema from grouping params (.>=) = unsafeBinaryOp ">=" infix 4 .>= --- | >>> printSQL $ notNull true .< null_+-- | >>> printSQL $ true .< null_ -- (TRUE < NULL) (.<)-  :: Expression schema relations grouping params (nullity ty) -- ^ lhs-  -> Expression schema relations grouping params (nullity ty) -- ^ rhs-  -> Expression schema relations grouping params (nullity 'PGbool)+  :: Expression schema from grouping params (nullity0 ty) -- ^ lhs+  -> Expression schema from grouping params (nullity1 ty) -- ^ rhs+  -> Condition schema from grouping params (.<) = unsafeBinaryOp "<" infix 4 .< --- | >>> printSQL $ notNull true .<= null_+-- | >>> printSQL $ true .<= null_ -- (TRUE <= NULL) (.<=)-  :: Expression schema relations grouping params (nullity ty) -- ^ lhs-  -> Expression schema relations grouping params (nullity ty) -- ^ rhs-  -> Expression schema relations grouping params (nullity 'PGbool)+  :: Expression schema from grouping params (nullity0 ty) -- ^ lhs+  -> Expression schema from grouping params (nullity1 ty) -- ^ rhs+  -> Condition schema from grouping params (.<=) = unsafeBinaryOp "<=" infix 4 .<= --- | >>> printSQL $ notNull true .> null_+-- | >>> printSQL $ true .> null_ -- (TRUE > NULL) (.>)-  :: Expression schema relations grouping params (nullity ty) -- ^ lhs-  -> Expression schema relations grouping params (nullity ty) -- ^ rhs-  -> Expression schema relations grouping params (nullity 'PGbool)+  :: Expression schema from grouping params (nullity0 ty) -- ^ lhs+  -> Expression schema from grouping params (nullity1 ty) -- ^ rhs+  -> Condition schema from grouping params (.>) = unsafeBinaryOp ">" infix 4 .>  -- | >>> printSQL currentDate -- CURRENT_DATE currentDate-  :: Expression schema relations grouping params (nullity 'PGdate)+  :: Expression schema from grouping params (nullity 'PGdate) currentDate = UnsafeExpression "CURRENT_DATE"  -- | >>> printSQL currentTime -- CURRENT_TIME currentTime-  :: Expression schema relations grouping params (nullity 'PGtimetz)+  :: Expression schema from grouping params (nullity 'PGtimetz) currentTime = UnsafeExpression "CURRENT_TIME"  -- | >>> printSQL currentTimestamp -- CURRENT_TIMESTAMP currentTimestamp-  :: Expression schema relations grouping params (nullity 'PGtimestamptz)+  :: Expression schema from grouping params (nullity 'PGtimestamptz) currentTimestamp = UnsafeExpression "CURRENT_TIMESTAMP"  -- | >>> printSQL localTime -- LOCALTIME localTime-  :: Expression schema relations grouping params (nullity 'PGtime)+  :: Expression schema from grouping params (nullity 'PGtime) localTime = UnsafeExpression "LOCALTIME"  -- | >>> printSQL localTimestamp -- LOCALTIMESTAMP localTimestamp-  :: Expression schema relations grouping params (nullity 'PGtimestamp)+  :: Expression schema from grouping params (nullity 'PGtimestamp) localTimestamp = UnsafeExpression "LOCALTIMESTAMP"  {-----------------------------------------@@ -862,7 +890,7 @@ -----------------------------------------}  instance IsString-  (Expression schema relations grouping params (nullity 'PGtext)) where+  (Expression schema from grouping params (nullity 'PGtext)) where     fromString str = UnsafeExpression $       "E\'" <> fromString (escape =<< str) <> "\'"       where@@ -878,36 +906,36 @@           c -> [c]  instance Semigroup-  (Expression schema relations grouping params (nullity 'PGtext)) where+  (Expression schema from grouping params (nullity 'PGtext)) where     (<>) = unsafeBinaryOp "||"  instance Monoid-  (Expression schema relations grouping params (nullity 'PGtext)) where+  (Expression schema from grouping params (nullity 'PGtext)) where     mempty = fromString ""     mappend = (<>)  -- | >>> printSQL $ lower "ARRRGGG" -- lower(E'ARRRGGG') lower-  :: Expression schema relations grouping params (nullity 'PGtext)+  :: Expression schema from grouping params (nullity 'PGtext)   -- ^ string to lower case-  -> Expression schema relations grouping params (nullity 'PGtext)+  -> Expression schema from grouping params (nullity 'PGtext) lower = unsafeFunction "lower"  -- | >>> printSQL $ upper "eeee" -- upper(E'eeee') upper-  :: Expression schema relations grouping params (nullity 'PGtext)+  :: Expression schema from grouping params (nullity 'PGtext)   -- ^ string to upper case-  -> Expression schema relations grouping params (nullity 'PGtext)+  -> Expression schema from grouping params (nullity 'PGtext) upper = unsafeFunction "upper"  -- | >>> printSQL $ charLength "four" -- char_length(E'four') charLength-  :: Expression schema relations grouping params (nullity 'PGtext)+  :: Expression schema from grouping params (nullity 'PGtext)   -- ^ string to measure-  -> Expression schema relations grouping params (nullity 'PGint4)+  -> Expression schema from grouping params (nullity 'PGint4) charLength = unsafeFunction "char_length"  -- | The `like` expression returns true if the @string@ matches@@ -920,11 +948,11 @@ -- >>> printSQL $ "abc" `like` "a%" -- (E'abc' LIKE E'a%') like-  :: Expression schema relations grouping params (nullity 'PGtext)+  :: Expression schema from grouping params (nullity 'PGtext)   -- ^ string-  -> Expression schema relations grouping params (nullity 'PGtext)+  -> Expression schema from grouping params (nullity 'PGtext)   -- ^ pattern-  -> Expression schema relations grouping params (nullity 'PGbool)+  -> Expression schema from grouping params (nullity 'PGbool) like = unsafeBinaryOp "LIKE"  {-----------------------------------------@@ -938,34 +966,38 @@  -- | Get JSON value (object field or array element) at a key. (.->)-  :: (PGjson_ json, PGjsonKey key)-  => Expression schema relations grouping params (nullity json)-  -> Expression schema relations grouping params (nullity key)-  -> Expression schema relations grouping params ('Null json)+  :: (json `In` PGJsonType, key `In` PGJsonKey)+  => Expression schema from grouping params (nullity json)+  -> Expression schema from grouping params (nullity key)+  -> Expression schema from grouping params ('Null json)+infixl 8 .-> (.->) = unsafeBinaryOp "->"  -- | Get JSON value (object field or array element) at a key, as text. (.->>)-  :: (PGjson_ json, PGjsonKey key)-  => Expression schema relations grouping params (nullity json)-  -> Expression schema relations grouping params (nullity key)-  -> Expression schema relations grouping params ('Null 'PGtext)+  :: (json `In` PGJsonType, key `In` PGJsonKey)+  => Expression schema from grouping params (nullity json)+  -> Expression schema from grouping params (nullity key)+  -> Expression schema from grouping params ('Null 'PGtext)+infixl 8 .->> (.->>) = unsafeBinaryOp "->>"  -- | Get JSON value at a specified path. (.#>)-  :: (PGjson_ json, PGtextArray "(.#>)" path)-  => Expression schema relations grouping params (nullity json)-  -> Expression schema relations grouping params (nullity path)-  -> Expression schema relations grouping params ('Null json)+  :: (json `In` PGJsonType, PGTextArray "(.#>)" path)+  => Expression schema from grouping params (nullity json)+  -> Expression schema from grouping params (nullity path)+  -> Expression schema from grouping params ('Null json)+infixl 8 .#> (.#>) = unsafeBinaryOp "#>"  -- | Get JSON value at a specified path as text. (.#>>)-  :: (PGjson_ json, PGtextArray "(.#>>)" path)-  => Expression schema relations grouping params (nullity json)-  -> Expression schema relations grouping params (nullity path)-  -> Expression schema relations grouping params ('Null 'PGtext)+  :: (json `In` PGJsonType, PGTextArray "(.#>>)" path)+  => Expression schema from grouping params (nullity json)+  -> Expression schema from grouping params (nullity path)+  -> Expression schema from grouping params ('Null 'PGtext)+infixl 8 .#>> (.#>>) = unsafeBinaryOp "#>>"  -- Additional jsonb operators@@ -973,43 +1005,48 @@ -- | Does the left JSON value contain the right JSON path/value entries at the -- top level? (.@>)-  :: Expression schema relations grouping params (nullity 'PGjsonb)-  -> Expression schema relations grouping params (nullity 'PGjsonb)-  -> Condition schema relations grouping params+  :: Expression schema from grouping params (nullity 'PGjsonb)+  -> Expression schema from grouping params (nullity 'PGjsonb)+  -> Condition schema from grouping params+infixl 9 .@> (.@>) = unsafeBinaryOp "@>"  -- | Are the left JSON path/value entries contained at the top level within the -- right JSON value? (.<@)-  :: Expression schema relations grouping params (nullity 'PGjsonb)-  -> Expression schema relations grouping params (nullity 'PGjsonb)-  -> Condition schema relations grouping params+  :: Expression schema from grouping params (nullity 'PGjsonb)+  -> Expression schema from grouping params (nullity 'PGjsonb)+  -> Condition schema from grouping params+infixl 9 .<@ (.<@) = unsafeBinaryOp "<@"  -- | Does the string exist as a top-level key within the JSON value? (.?)-  :: Expression schema relations grouping params (nullity 'PGjsonb)-  -> Expression schema relations grouping params (nullity 'PGtext)-  -> Condition schema relations grouping params+  :: Expression schema from grouping params (nullity 'PGjsonb)+  -> Expression schema from grouping params (nullity 'PGtext)+  -> Condition schema from grouping params+infixl 9 .? (.?) = unsafeBinaryOp "?"  -- | Do any of these array strings exist as top-level keys? (.?|)-  :: Expression schema relations grouping params (nullity 'PGjsonb)-  -> Expression schema relations grouping params (nullity ('PGvararray 'PGtext))-  -> Condition schema relations grouping params+  :: Expression schema from grouping params (nullity 'PGjsonb)+  -> Expression schema from grouping params (nullity ('PGvararray ('NotNull 'PGtext)))+  -> Condition schema from grouping params+infixl 9 .?| (.?|) = unsafeBinaryOp "?|"  -- | Do all of these array strings exist as top-level keys? (.?&)-  :: Expression schema relations grouping params (nullity 'PGjsonb)-  -> Expression schema relations grouping params (nullity ('PGvararray 'PGtext))-  -> Condition schema relations grouping params+  :: Expression schema from grouping params (nullity 'PGjsonb)+  -> Expression schema from grouping params (nullity ('PGvararray ('NotNull 'PGtext)))+  -> Condition schema from grouping params+infixl 9 .?& (.?&) = unsafeBinaryOp "?&"  -- | Concatenate two jsonb values into a new jsonb value. instance-  Semigroup (Expression schema relations grouping param (nullity 'PGjsonb)) where+  Semigroup (Expression schema from grouping param (nullity 'PGjsonb)) where   (<>) = unsafeBinaryOp "||"  -- | Delete a key or keys from a JSON object, or remove an array element.@@ -1025,19 +1062,21 @@ -- @ integer @: Delete the array element with specified index (Negative integers -- count from the end). Throws an error if top level container is not an array. (.-.)-  :: (key `In` '[ 'PGtext, 'PGvararray 'PGtext, 'PGint4, 'PGint2 ]) -- hlint error without parens here-  => Expression schema relations grouping params (nullity 'PGjsonb)-  -> Expression schema relations grouping params (nullity key)-  -> Expression schema relations grouping params (nullity 'PGjsonb)+  :: (key `In` '[ 'PGtext, 'PGvararray ('NotNull 'PGtext), 'PGint4, 'PGint2 ]) -- hlint error without parens here+  => Expression schema from grouping params (nullity 'PGjsonb)+  -> Expression schema from grouping params (nullity key)+  -> Expression schema from grouping params (nullity 'PGjsonb)+infixl 6 .-. (.-.) = unsafeBinaryOp "-"  -- | Delete the field or element with specified path (for JSON arrays, negative -- integers count from the end) (#-.)-  :: PGtextArray "(#-.)" arrayty-  => Expression schema relations grouping params (nullity 'PGjsonb)-  -> Expression schema relations grouping params (nullity arrayty)-  -> Expression schema relations grouping params (nullity 'PGjsonb)+  :: PGTextArray "(#-.)" arrayty+  => Expression schema from grouping params (nullity 'PGjsonb)+  -> Expression schema from grouping params (nullity arrayty)+  -> Expression schema from grouping params (nullity 'PGjsonb)+infixl 6 #-. (#-.) = unsafeBinaryOp "#-"  {-----------------------------------------@@ -1045,12 +1084,18 @@ -----------------------------------------}  -- | Literal binary JSON-jsonbLit :: JSON.Value -> Expression schema relations grouping params (nullity 'PGjsonb)-jsonbLit = cast jsonb . UnsafeExpression . singleQuotedUtf8 . toStrict . JSON.encode+jsonbLit+  :: JSON.ToJSON x+  => x -> Expression schema from grouping params (nullity 'PGjsonb)+jsonbLit = cast jsonb . UnsafeExpression+  . singleQuotedUtf8 . toStrict . JSON.encode  -- | Literal JSON-jsonLit :: JSON.Value -> Expression schema relations grouping params (nullity 'PGjson)-jsonLit = cast json . UnsafeExpression . singleQuotedUtf8 . toStrict . JSON.encode+jsonLit+  :: JSON.ToJSON x+  => x -> Expression schema from grouping params (nullity 'PGjson)+jsonLit = cast json . UnsafeExpression+  . singleQuotedUtf8 . toStrict . JSON.encode  -- | Returns the value as json. Arrays and composites are converted -- (recursively) to arrays and objects; otherwise, if there is a cast from the@@ -1059,8 +1104,8 @@ -- number, a Boolean, or a null value, the text representation will be used, in -- such a fashion that it is a valid json value. toJson-  :: Expression schema relations grouping params (nullity ty)-  -> Expression schema relations grouping params (nullity 'PGjson)+  :: Expression schema from grouping params (nullity ty)+  -> Expression schema from grouping params (nullity 'PGjson) toJson = unsafeFunction "to_json"  -- | Returns the value as jsonb. Arrays and composites are converted@@ -1070,43 +1115,43 @@ -- number, a Boolean, or a null value, the text representation will be used, in -- such a fashion that it is a valid jsonb value. toJsonb-  :: Expression schema relations grouping params (nullity ty)-  -> Expression schema relations grouping params (nullity 'PGjsonb)+  :: Expression schema from grouping params (nullity ty)+  -> Expression schema from grouping params (nullity 'PGjsonb) toJsonb = unsafeFunction "to_jsonb"  -- | Returns the array as a JSON array. A PostgreSQL multidimensional array -- becomes a JSON array of arrays. arrayToJson-  :: PGarray "arrayToJson" arr-  => Expression schema relations grouping params (nullity arr)-  -> Expression schema relations grouping params (nullity 'PGjson)+  :: PGArray "arrayToJson" arr+  => Expression schema from grouping params (nullity arr)+  -> Expression schema from grouping params (nullity 'PGjson) arrayToJson = unsafeFunction "array_to_json"  -- | Returns the row as a JSON object. rowToJson-  :: Expression schema relations grouping params (nullity ('PGcomposite ty))-  -> Expression schema relations grouping params (nullity 'PGjson)+  :: Expression schema from grouping params (nullity ('PGcomposite ty))+  -> Expression schema from grouping params (nullity 'PGjson) rowToJson = unsafeFunction "row_to_json"  -- | Builds a possibly-heterogeneously-typed JSON array out of a variadic -- argument list. jsonBuildArray   :: SListI elems-  => NP (Expression schema relations grouping params) elems-  -> Expression schema relations grouping params (nullity 'PGjson)+  => NP (Expression schema from grouping params) elems+  -> Expression schema from grouping params (nullity 'PGjson) jsonBuildArray = unsafeVariadicFunction "json_build_array"  -- | Builds a possibly-heterogeneously-typed (binary) JSON array out of a -- variadic argument list. jsonbBuildArray   :: SListI elems-  => NP (Expression schema relations grouping params) elems-  -> Expression schema relations grouping params (nullity 'PGjsonb)+  => NP (Expression schema from grouping params) elems+  -> Expression schema from grouping params (nullity 'PGjsonb) jsonbBuildArray = unsafeVariadicFunction "jsonb_build_array"  unsafeRowFunction   :: All Top elems-  => NP (Aliased (Expression schema relations grouping params)) elems+  => NP (Aliased (Expression schema from grouping params)) elems   -> [ByteString] unsafeRowFunction =   (`appEndo` []) . hcfoldMap (Proxy :: Proxy Top)@@ -1118,8 +1163,8 @@ -- and values. jsonBuildObject   :: All Top elems-  => NP (Aliased (Expression schema relations grouping params)) elems-  -> Expression schema relations grouping params (nullity 'PGjson)+  => NP (Aliased (Expression schema from grouping params)) elems+  -> Expression schema from grouping params (nullity 'PGjson) jsonBuildObject   = unsafeFunction "json_build_object"   . UnsafeExpression@@ -1131,8 +1176,8 @@ -- between text and values. jsonbBuildObject   :: All Top elems-  => NP (Aliased (Expression schema relations grouping params)) elems-  -> Expression schema relations grouping params (nullity 'PGjsonb)+  => NP (Aliased (Expression schema from grouping params)) elems+  -> Expression schema from grouping params (nullity 'PGjsonb) jsonbBuildObject   = unsafeFunction "jsonb_build_object"   . UnsafeExpression@@ -1144,9 +1189,9 @@ -- taken as alternating key/value pairs, or two dimensions such that each inner -- array has exactly two elements, which are taken as a key/value pair. jsonObject-  :: PGarrayOf "jsonObject" arr 'PGtext-  => Expression schema relations grouping params (nullity arr)-  -> Expression schema relations grouping params (nullity 'PGjson)+  :: PGArrayOf "jsonObject" arr ('NotNull 'PGtext)+  => Expression schema from grouping params (nullity arr)+  -> Expression schema from grouping params (nullity 'PGjson) jsonObject = unsafeFunction "json_object"  -- | Builds a binary JSON object out of a text array. The array must have either@@ -1154,19 +1199,19 @@ -- taken as alternating key/value pairs, or two dimensions such that each inner -- array has exactly two elements, which are taken as a key/value pair. jsonbObject-  :: PGarrayOf "jsonbObject" arr 'PGtext-  => Expression schema relations grouping params (nullity arr)-  -> Expression schema relations grouping params (nullity 'PGjsonb)+  :: PGArrayOf "jsonbObject" arr ('NotNull 'PGtext)+  => Expression schema from grouping params (nullity arr)+  -> Expression schema from grouping params (nullity 'PGjsonb) jsonbObject = unsafeFunction "jsonb_object"  -- | This is an alternate form of 'jsonObject' that takes two arrays; one for -- keys and one for values, that are zipped pairwise to create a JSON object. jsonZipObject-  :: ( PGarrayOf "jsonZipObject" keysArray 'PGtext-     , PGarrayOf "jsonZipObject" valuesArray 'PGtext)-  => Expression schema relations grouping params (nullity keysArray)-  -> Expression schema relations grouping params (nullity valuesArray)-  -> Expression schema relations grouping params (nullity 'PGjson)+  :: ( PGArrayOf "jsonZipObject" keysArray ('NotNull 'PGtext)+     , PGArrayOf "jsonZipObject" valuesArray ('NotNull 'PGtext))+  => Expression schema from grouping params (nullity keysArray)+  -> Expression schema from grouping params (nullity valuesArray)+  -> Expression schema from grouping params (nullity 'PGjson) jsonZipObject ks vs =   unsafeVariadicFunction "json_object" (ks :* vs :* Nil) @@ -1174,11 +1219,11 @@ -- keys and one for values, that are zipped pairwise to create a binary JSON -- object. jsonbZipObject-  :: ( PGarrayOf "jsonbZipObject" keysArray 'PGtext-     , PGarrayOf "jsonbZipObject" valuesArray 'PGtext)-  => Expression schema relations grouping params (nullity keysArray)-  -> Expression schema relations grouping params (nullity valuesArray)-  -> Expression schema relations grouping params (nullity 'PGjsonb)+  :: ( PGArrayOf "jsonbZipObject" keysArray ('NotNull 'PGtext)+     , PGArrayOf "jsonbZipObject" valuesArray ('NotNull 'PGtext))+  => Expression schema from grouping params (nullity keysArray)+  -> Expression schema from grouping params (nullity valuesArray)+  -> Expression schema from grouping params (nullity 'PGjsonb) jsonbZipObject ks vs =   unsafeVariadicFunction "jsonb_object" (ks :* vs :* Nil) @@ -1188,23 +1233,23 @@  -- | Returns the number of elements in the outermost JSON array. jsonArrayLength-  :: Expression schema relations grouping params (nullity 'PGjson)-  -> Expression schema relations grouping params (nullity 'PGint4)+  :: Expression schema from grouping params (nullity 'PGjson)+  -> Expression schema from grouping params (nullity 'PGint4) jsonArrayLength = unsafeFunction "json_array_length"  -- | Returns the number of elements in the outermost binary JSON array. jsonbArrayLength-  :: Expression schema relations grouping params (nullity 'PGjsonb)-  -> Expression schema relations grouping params (nullity 'PGint4)+  :: Expression schema from grouping params (nullity 'PGjsonb)+  -> Expression schema from grouping params (nullity 'PGint4) jsonbArrayLength = unsafeFunction "jsonb_array_length"  -- | Returns JSON value pointed to by the given path (equivalent to #> -- operator). jsonExtractPath   :: SListI elems-  => Expression schema relations grouping params (nullity 'PGjson)-  -> NP (Expression schema relations grouping params) elems-  -> Expression schema relations grouping params (nullity 'PGjsonb)+  => Expression schema from grouping params (nullity 'PGjson)+  -> NP (Expression schema from grouping params) elems+  -> Expression schema from grouping params (nullity 'PGjsonb) jsonExtractPath x xs =   unsafeVariadicFunction "json_extract_path" (x :* xs) @@ -1212,9 +1257,9 @@ -- operator). jsonbExtractPath   :: SListI elems-  => Expression schema relations grouping params (nullity 'PGjsonb)-  -> NP (Expression schema relations grouping params) elems-  -> Expression schema relations grouping params (nullity 'PGjsonb)+  => Expression schema from grouping params (nullity 'PGjsonb)+  -> NP (Expression schema from grouping params) elems+  -> Expression schema from grouping params (nullity 'PGjsonb) jsonbExtractPath x xs =   unsafeVariadicFunction "jsonb_extract_path" (x :* xs) @@ -1222,9 +1267,9 @@ -- operator), as text. jsonExtractPathAsText   :: SListI elems-  => Expression schema relations grouping params (nullity 'PGjson)-  -> NP (Expression schema relations grouping params) elems-  -> Expression schema relations grouping params (nullity 'PGjson)+  => Expression schema from grouping params (nullity 'PGjson)+  -> NP (Expression schema from grouping params) elems+  -> Expression schema from grouping params (nullity 'PGjson) jsonExtractPathAsText x xs =   unsafeVariadicFunction "json_extract_path_text" (x :* xs) @@ -1232,50 +1277,38 @@ -- operator), as text. jsonbExtractPathAsText   :: SListI elems-  => Expression schema relations grouping params (nullity 'PGjsonb)-  -> NP (Expression schema relations grouping params) elems-  -> Expression schema relations grouping params (nullity 'PGjsonb)+  => Expression schema from grouping params (nullity 'PGjsonb)+  -> NP (Expression schema from grouping params) elems+  -> Expression schema from grouping params (nullity 'PGjsonb) jsonbExtractPathAsText x xs =   unsafeVariadicFunction "jsonb_extract_path_text" (x :* xs) --- | Returns set of keys in the outermost JSON object.-jsonObjectKeys-  :: Expression schema relations grouping params (nullity 'PGjson)-  -> Expression schema relations grouping params (nullity 'PGtext)-jsonObjectKeys = unsafeFunction "json_object_keys"---- | Returns set of keys in the outermost JSON object.-jsonbObjectKeys-  :: Expression schema relations grouping params (nullity 'PGjsonb)-  -> Expression schema relations grouping params (nullity 'PGtext)-jsonbObjectKeys = unsafeFunction "jsonb_object_keys"- -- | Returns the type of the outermost JSON value as a text string. Possible -- types are object, array, string, number, boolean, and null. jsonTypeof-  :: Expression schema relations grouping params (nullity 'PGjson)-  -> Expression schema relations grouping params (nullity 'PGtext)+  :: Expression schema from grouping params (nullity 'PGjson)+  -> Expression schema from grouping params (nullity 'PGtext) jsonTypeof = unsafeFunction "json_typeof"  -- | Returns the type of the outermost binary JSON value as a text string. -- Possible types are object, array, string, number, boolean, and null. jsonbTypeof-  :: Expression schema relations grouping params (nullity 'PGjsonb)-  -> Expression schema relations grouping params (nullity 'PGtext)+  :: Expression schema from grouping params (nullity 'PGjsonb)+  -> Expression schema from grouping params (nullity 'PGtext) jsonbTypeof = unsafeFunction "jsonb_typeof"  -- | Returns its argument with all object fields that have null values omitted. -- Other null values are untouched. jsonStripNulls-  :: Expression schema relations grouping params (nullity 'PGjson)-  -> Expression schema relations grouping params (nullity 'PGjson)+  :: Expression schema from grouping params (nullity 'PGjson)+  -> Expression schema from grouping params (nullity 'PGjson) jsonStripNulls = unsafeFunction "json_strip_nulls"  -- | Returns its argument with all object fields that have null values omitted. -- Other null values are untouched. jsonbStripNulls-  :: Expression schema relations grouping params (nullity 'PGjsonb)-  -> Expression schema relations grouping params (nullity 'PGjsonb)+  :: Expression schema from grouping params (nullity 'PGjsonb)+  -> Expression schema from grouping params (nullity 'PGjsonb) jsonbStripNulls = unsafeFunction "jsonb_strip_nulls"  -- | @ jsonbSet target path new_value create_missing @@@ -1286,12 +1319,12 @@ -- operators, negative integers that appear in path count from the end of JSON -- arrays. jsonbSet-  :: PGtextArray "jsonbSet" arr-  => Expression schema relations grouping params (nullity 'PGjsonb)-  -> Expression schema relations grouping params (nullity arr)-  -> Expression schema relations grouping params (nullity 'PGjsonb)-  -> Maybe (Expression schema relations grouping params (nullity 'PGbool))-  -> Expression schema relations grouping params (nullity 'PGjsonb)+  :: PGTextArray "jsonbSet" arr+  => Expression schema from grouping params (nullity 'PGjsonb)+  -> Expression schema from grouping params (nullity arr)+  -> Expression schema from grouping params (nullity 'PGjsonb)+  -> Maybe (Expression schema from grouping params (nullity 'PGbool))+  -> Expression schema from grouping params (nullity 'PGjsonb) jsonbSet tgt path val createMissing = case createMissing of   Just m -> unsafeVariadicFunction "jsonb_set" (tgt :* path :* val :* m :* Nil)   Nothing -> unsafeVariadicFunction "jsonb_set" (tgt :* path :* val :* Nil)@@ -1305,20 +1338,20 @@ -- exist. As with the path orientated operators, negative integers that appear -- in path count from the end of JSON arrays. jsonbInsert-  :: PGtextArray "jsonbInsert" arr-  => Expression schema relations grouping params (nullity 'PGjsonb)-  -> Expression schema relations grouping params (nullity arr)-  -> Expression schema relations grouping params (nullity 'PGjsonb)-  -> Maybe (Expression schema relations grouping params (nullity 'PGbool))-  -> Expression schema relations grouping params (nullity 'PGjsonb)+  :: PGTextArray "jsonbInsert" arr+  => Expression schema from grouping params (nullity 'PGjsonb)+  -> Expression schema from grouping params (nullity arr)+  -> Expression schema from grouping params (nullity 'PGjsonb)+  -> Maybe (Expression schema from grouping params (nullity 'PGbool))+  -> Expression schema from grouping params (nullity 'PGjsonb) jsonbInsert tgt path val insertAfter = case insertAfter of   Just i -> unsafeVariadicFunction "jsonb_insert" (tgt :* path :* val :* i :* Nil)   Nothing -> unsafeVariadicFunction "jsonb_insert" (tgt :* path :* val :* Nil)  -- | Returns its argument as indented JSON text. jsonbPretty-  :: Expression schema relations grouping params (nullity 'PGjsonb)-  -> Expression schema relations grouping params (nullity 'PGtext)+  :: Expression schema from grouping params (nullity 'PGjsonb)+  -> Expression schema from grouping params (nullity 'PGtext) jsonbPretty = unsafeFunction "jsonb_pretty"  {-----------------------------------------@@ -1328,16 +1361,16 @@ -- | escape hatch to define aggregate functions unsafeAggregate   :: ByteString -- ^ aggregate function-  -> Expression schema relations 'Ungrouped params (xty)-  -> Expression schema relations ('Grouped bys) params (yty)+  -> Expression schema from 'Ungrouped params (xty)+  -> Expression schema from ('Grouped bys) params (yty) unsafeAggregate fun x = UnsafeExpression $ mconcat   [fun, "(", renderExpression x, ")"]  -- | escape hatch to define aggregate functions over distinct values unsafeAggregateDistinct   :: ByteString -- ^ aggregate function-  -> Expression schema relations 'Ungrouped params (xty)-  -> Expression schema relations ('Grouped bys) params (yty)+  -> Expression schema from 'Ungrouped params (xty)+  -> Expression schema from ('Grouped bys) params (yty) unsafeAggregateDistinct fun x = UnsafeExpression $ mconcat   [fun, "(DISTINCT ", renderExpression x, ")"] @@ -1349,10 +1382,10 @@ -- :} -- sum("col") sum_-  :: PGNum ty-  => Expression schema relations 'Ungrouped params (nullity ty)+  :: ty `In` PGNum+  => Expression schema from 'Ungrouped params (nullity ty)   -- ^ what to sum-  -> Expression schema relations ('Grouped bys) params (nullity ty)+  -> Expression schema from ('Grouped bys) params (nullity ty) sum_ = unsafeAggregate "sum"  -- | >>> :{@@ -1363,19 +1396,19 @@ -- :} -- sum(DISTINCT "col") sumDistinct-  :: PGNum ty-  => Expression schema relations 'Ungrouped params (nullity ty)+  :: ty `In` PGNum+  => Expression schema from 'Ungrouped params (nullity ty)   -- ^ what to sum-  -> Expression schema relations ('Grouped bys) params (nullity ty)+  -> Expression schema from ('Grouped bys) params (nullity ty) sumDistinct = unsafeAggregateDistinct "sum"  -- | A constraint for `PGType`s that you can take averages of and the resulting -- `PGType`. class PGAvg ty avg | ty -> avg where   avg, avgDistinct-    :: Expression schema relations 'Ungrouped params (nullity ty)+    :: Expression schema from 'Ungrouped params (nullity ty)     -- ^ what to average-    -> Expression schema relations ('Grouped bys) params (nullity avg)+    -> Expression schema from ('Grouped bys) params (nullity avg)   avg = unsafeAggregate "avg"   avgDistinct = unsafeAggregateDistinct "avg" instance PGAvg 'PGint2 'PGnumeric@@ -1394,10 +1427,10 @@ -- :} -- bit_and("col") bitAnd-  :: PGIntegral int-  => Expression schema relations 'Ungrouped params (nullity int)+  :: int `In` PGIntegral+  => Expression schema from 'Ungrouped params (nullity int)   -- ^ what to aggregate-  -> Expression schema relations ('Grouped bys) params (nullity int)+  -> Expression schema from ('Grouped bys) params (nullity int) bitAnd = unsafeAggregate "bit_and"  -- | >>> :{@@ -1408,10 +1441,10 @@ -- :} -- bit_or("col") bitOr-  :: PGIntegral int-  => Expression schema relations 'Ungrouped params (nullity int)+  :: int `In` PGIntegral+  => Expression schema from 'Ungrouped params (nullity int)   -- ^ what to aggregate-  -> Expression schema relations ('Grouped bys) params (nullity int)+  -> Expression schema from ('Grouped bys) params (nullity int) bitOr = unsafeAggregate "bit_or"  -- | >>> :{@@ -1422,10 +1455,10 @@ -- :} -- bit_and(DISTINCT "col") bitAndDistinct-  :: PGIntegral int-  => Expression schema relations 'Ungrouped params (nullity int)+  :: int `In` PGIntegral+  => Expression schema from 'Ungrouped params (nullity int)   -- ^ what to aggregate-  -> Expression schema relations ('Grouped bys) params (nullity int)+  -> Expression schema from ('Grouped bys) params (nullity int) bitAndDistinct = unsafeAggregateDistinct "bit_and"  -- | >>> :{@@ -1436,10 +1469,10 @@ -- :} -- bit_or(DISTINCT "col") bitOrDistinct-  :: PGIntegral int-  => Expression schema relations 'Ungrouped params (nullity int)+  :: int `In` PGIntegral+  => Expression schema from 'Ungrouped params (nullity int)   -- ^ what to aggregate-  -> Expression schema relations ('Grouped bys) params (nullity int)+  -> Expression schema from ('Grouped bys) params (nullity int) bitOrDistinct = unsafeAggregateDistinct "bit_or"  -- | >>> :{@@ -1450,9 +1483,9 @@ -- :} -- bool_and("col") boolAnd-  :: Expression schema relations 'Ungrouped params (nullity 'PGbool)+  :: Expression schema from 'Ungrouped params (nullity 'PGbool)   -- ^ what to aggregate-  -> Expression schema relations ('Grouped bys) params (nullity 'PGbool)+  -> Expression schema from ('Grouped bys) params (nullity 'PGbool) boolAnd = unsafeAggregate "bool_and"  -- | >>> :{@@ -1463,9 +1496,9 @@ -- :} -- bool_or("col") boolOr-  :: Expression schema relations 'Ungrouped params (nullity 'PGbool)+  :: Expression schema from 'Ungrouped params (nullity 'PGbool)   -- ^ what to aggregate-  -> Expression schema relations ('Grouped bys) params (nullity 'PGbool)+  -> Expression schema from ('Grouped bys) params (nullity 'PGbool) boolOr = unsafeAggregate "bool_or"  -- | >>> :{@@ -1476,9 +1509,9 @@ -- :} -- bool_and(DISTINCT "col") boolAndDistinct-  :: Expression schema relations 'Ungrouped params (nullity 'PGbool)+  :: Expression schema from 'Ungrouped params (nullity 'PGbool)   -- ^ what to aggregate-  -> Expression schema relations ('Grouped bys) params (nullity 'PGbool)+  -> Expression schema from ('Grouped bys) params (nullity 'PGbool) boolAndDistinct = unsafeAggregateDistinct "bool_and"  -- | >>> :{@@ -1489,9 +1522,9 @@ -- :} -- bool_or(DISTINCT "col") boolOrDistinct-  :: Expression schema relations 'Ungrouped params (nullity 'PGbool)+  :: Expression schema from 'Ungrouped params (nullity 'PGbool)   -- ^ what to aggregate-  -> Expression schema relations ('Grouped bys) params (nullity 'PGbool)+  -> Expression schema from ('Grouped bys) params (nullity 'PGbool) boolOrDistinct = unsafeAggregateDistinct "bool_or"  -- | A special aggregation that does not require an input@@ -1499,7 +1532,7 @@ -- >>> printSQL countStar -- count(*) countStar-  :: Expression schema relations ('Grouped bys) params ('NotNull 'PGint8)+  :: Expression schema from ('Grouped bys) params ('NotNull 'PGint8) countStar = UnsafeExpression $ "count(*)"  -- | >>> :{@@ -1510,9 +1543,9 @@ -- :} -- count("col") count-  :: Expression schema relations 'Ungrouped params ty+  :: Expression schema from 'Ungrouped params ty   -- ^ what to count-  -> Expression schema relations ('Grouped bys) params ('NotNull 'PGint8)+  -> Expression schema from ('Grouped bys) params ('NotNull 'PGint8) count = unsafeAggregate "count"  -- | >>> :{@@ -1523,9 +1556,9 @@ -- :} -- count(DISTINCT "col") countDistinct-  :: Expression schema relations 'Ungrouped params ty+  :: Expression schema from 'Ungrouped params ty   -- ^ what to count-  -> Expression schema relations ('Grouped bys) params ('NotNull 'PGint8)+  -> Expression schema from ('Grouped bys) params ('NotNull 'PGint8) countDistinct = unsafeAggregateDistinct "count"  -- | synonym for `boolAnd`@@ -1538,9 +1571,9 @@ -- :} -- every("col") every-  :: Expression schema relations 'Ungrouped params (nullity 'PGbool)+  :: Expression schema from 'Ungrouped params (nullity 'PGbool)   -- ^ what to aggregate-  -> Expression schema relations ('Grouped bys) params (nullity 'PGbool)+  -> Expression schema from ('Grouped bys) params (nullity 'PGbool) every = unsafeAggregate "every"  -- | synonym for `boolAndDistinct`@@ -1553,16 +1586,16 @@ -- :} -- every(DISTINCT "col") everyDistinct-  :: Expression schema relations 'Ungrouped params (nullity 'PGbool)+  :: Expression schema from 'Ungrouped params (nullity 'PGbool)   -- ^ what to aggregate-  -> Expression schema relations ('Grouped bys) params (nullity 'PGbool)+  -> Expression schema from ('Grouped bys) params (nullity 'PGbool) everyDistinct = unsafeAggregateDistinct "every"  -- | minimum and maximum aggregation max_, min_, maxDistinct, minDistinct-  :: Expression schema relations 'Ungrouped params (nullity ty)+  :: Expression schema from 'Ungrouped params (nullity ty)   -- ^ what to aggregate-  -> Expression schema relations ('Grouped bys) params (nullity ty)+  -> Expression schema from ('Grouped bys) params (nullity ty) max_ = unsafeAggregate "max" min_ = unsafeAggregate "min" maxDistinct = unsafeAggregateDistinct "max"@@ -1573,134 +1606,153 @@ -----------------------------------------}  -- | `TypeExpression`s are used in `cast`s and `createTable` commands.-newtype TypeExpression (schema :: SchemaType) (ty :: PGType)+newtype TypeExpression (schema :: SchemaType) (ty :: NullityType)   = UnsafeTypeExpression { renderTypeExpression :: ByteString }   deriving (GHC.Generic,Show,Eq,Ord,NFData) -instance (Has alias schema ('Typedef ty))-  => IsLabel alias (TypeExpression schema ty) where-    fromLabel = UnsafeTypeExpression (renderAlias (fromLabel @alias))+-- | The enum or composite type in a `Typedef` can be expressed by its alias.+typedef+  :: Has alias schema ('Typedef ty)+  => Alias alias+  -> TypeExpression schema (nullity ty)+typedef = UnsafeTypeExpression . renderAlias +-- | The composite type corresponding to a `Table` definition can be expressed+-- by its alias.+typetable+  :: Has alias schema ('Table tab)+  => Alias alias+  -> TypeExpression schema (nullity ('PGcomposite (TableToRow tab)))+typetable = UnsafeTypeExpression . renderAlias++-- | The composite type corresponding to a `View` definition can be expressed+-- by its alias.+typeview+  :: Has alias schema ('View view)+  => Alias alias+  -> TypeExpression schema (nullity ('PGcomposite view))+typeview = UnsafeTypeExpression . renderAlias+ -- | logical Boolean (true/false)-bool :: TypeExpression schema 'PGbool+bool :: TypeExpression schema (nullity 'PGbool) bool = UnsafeTypeExpression "bool" -- | signed two-byte integer-int2, smallint :: TypeExpression schema 'PGint2+int2, smallint :: TypeExpression schema (nullity 'PGint2) int2 = UnsafeTypeExpression "int2" smallint = UnsafeTypeExpression "smallint" -- | signed four-byte integer-int4, int, integer :: TypeExpression schema 'PGint4+int4, int, integer :: TypeExpression schema (nullity 'PGint4) int4 = UnsafeTypeExpression "int4" int = UnsafeTypeExpression "int" integer = UnsafeTypeExpression "integer" -- | signed eight-byte integer-int8, bigint :: TypeExpression schema 'PGint8+int8, bigint :: TypeExpression schema (nullity 'PGint8) int8 = UnsafeTypeExpression "int8" bigint = UnsafeTypeExpression "bigint" -- | arbitrary precision numeric type-numeric :: TypeExpression schema 'PGnumeric+numeric :: TypeExpression schema (nullity 'PGnumeric) numeric = UnsafeTypeExpression "numeric" -- | single precision floating-point number (4 bytes)-float4, real :: TypeExpression schema 'PGfloat4+float4, real :: TypeExpression schema (nullity 'PGfloat4) float4 = UnsafeTypeExpression "float4" real = UnsafeTypeExpression "real" -- | double precision floating-point number (8 bytes)-float8, doublePrecision :: TypeExpression schema 'PGfloat8+float8, doublePrecision :: TypeExpression schema (nullity 'PGfloat8) float8 = UnsafeTypeExpression "float8" doublePrecision = UnsafeTypeExpression "double precision" -- | variable-length character string-text :: TypeExpression schema 'PGtext+text :: TypeExpression schema (nullity 'PGtext) text = UnsafeTypeExpression "text" -- | fixed-length character string char, character-  :: (KnownNat n, 1 <= n)-  => proxy n-  -> TypeExpression schema ('PGchar n)-char p = UnsafeTypeExpression $ "char(" <> renderNat p <> ")"-character p = UnsafeTypeExpression $  "character(" <> renderNat p <> ")"+  :: forall n schema nullity. (KnownNat n, 1 <= n)+  => TypeExpression schema (nullity ('PGchar n))+char = UnsafeTypeExpression $ "char(" <> renderNat @n <> ")"+character = UnsafeTypeExpression $  "character(" <> renderNat @n <> ")" -- | variable-length character string varchar, characterVarying-  :: (KnownNat n, 1 <= n)-  => proxy n-  -> TypeExpression schema ('PGvarchar n)-varchar p = UnsafeTypeExpression $ "varchar(" <> renderNat p <> ")"-characterVarying p = UnsafeTypeExpression $-  "character varying(" <> renderNat p <> ")"+  :: forall n schema nullity. (KnownNat n, 1 <= n)+  => TypeExpression schema (nullity ('PGvarchar n))+varchar = UnsafeTypeExpression $ "varchar(" <> renderNat @n <> ")"+characterVarying = UnsafeTypeExpression $+  "character varying(" <> renderNat @n <> ")" -- | binary data ("byte array")-bytea :: TypeExpression schema 'PGbytea+bytea :: TypeExpression schema (nullity 'PGbytea) bytea = UnsafeTypeExpression "bytea" -- | date and time (no time zone)-timestamp :: TypeExpression schema 'PGtimestamp+timestamp :: TypeExpression schema (nullity 'PGtimestamp) timestamp = UnsafeTypeExpression "timestamp" -- | date and time, including time zone-timestampWithTimeZone :: TypeExpression schema 'PGtimestamptz+timestampWithTimeZone :: TypeExpression schema (nullity 'PGtimestamptz) timestampWithTimeZone = UnsafeTypeExpression "timestamp with time zone" -- | calendar date (year, month, day)-date :: TypeExpression schema 'PGdate+date :: TypeExpression schema (nullity 'PGdate) date = UnsafeTypeExpression "date" -- | time of day (no time zone)-time :: TypeExpression schema 'PGtime+time :: TypeExpression schema (nullity 'PGtime) time = UnsafeTypeExpression "time" -- | time of day, including time zone-timeWithTimeZone :: TypeExpression schema 'PGtimetz+timeWithTimeZone :: TypeExpression schema (nullity 'PGtimetz) timeWithTimeZone = UnsafeTypeExpression "time with time zone" -- | time span-interval :: TypeExpression schema 'PGinterval+interval :: TypeExpression schema (nullity 'PGinterval) interval = UnsafeTypeExpression "interval" -- | universally unique identifier-uuid :: TypeExpression schema 'PGuuid+uuid :: TypeExpression schema (nullity 'PGuuid) uuid = UnsafeTypeExpression "uuid" -- | IPv4 or IPv6 host address-inet :: TypeExpression schema 'PGinet+inet :: TypeExpression schema (nullity 'PGinet) inet = UnsafeTypeExpression "inet" -- | textual JSON data-json :: TypeExpression schema 'PGjson+json :: TypeExpression schema (nullity 'PGjson) json = UnsafeTypeExpression "json" -- | binary JSON data, decomposed-jsonb :: TypeExpression schema 'PGjsonb+jsonb :: TypeExpression schema (nullity 'PGjsonb) jsonb = UnsafeTypeExpression "jsonb" -- | variable length array vararray   :: TypeExpression schema pg-  -> TypeExpression schema ('PGvararray pg)+  -> TypeExpression schema (nullity ('PGvararray pg)) vararray ty = UnsafeTypeExpression $ renderTypeExpression ty <> "[]" -- | fixed length array ----- >>> renderTypeExpression (fixarray (Proxy @2) json)+-- >>> renderTypeExpression (fixarray @2 json) -- "json[2]" fixarray-  :: KnownNat n-  => proxy n-  -> TypeExpression schema pg-  -> TypeExpression schema ('PGfixarray n pg)-fixarray p ty = UnsafeTypeExpression $-  renderTypeExpression ty <> "[" <> renderNat p <> "]"+  :: forall n schema nullity pg. KnownNat n+  => TypeExpression schema pg+  -> TypeExpression schema (nullity ('PGfixarray n pg))+fixarray ty = UnsafeTypeExpression $+  renderTypeExpression ty <> "[" <> renderNat @n <> "]"  -- | `pgtype` is a demoted version of a `PGType`-class PGTyped schema (ty :: PGType) where pgtype :: TypeExpression schema ty-instance PGTyped schema 'PGbool where pgtype = bool-instance PGTyped schema 'PGint2 where pgtype = int2-instance PGTyped schema 'PGint4 where pgtype = int4-instance PGTyped schema 'PGint8 where pgtype = int8-instance PGTyped schema 'PGnumeric where pgtype = numeric-instance PGTyped schema 'PGfloat4 where pgtype = float4-instance PGTyped schema 'PGfloat8 where pgtype = float8-instance PGTyped schema 'PGtext where pgtype = text+class PGTyped schema (ty :: NullityType) where+  pgtype :: TypeExpression schema ty+instance PGTyped schema (nullity 'PGbool) where pgtype = bool+instance PGTyped schema (nullity 'PGint2) where pgtype = int2+instance PGTyped schema (nullity 'PGint4) where pgtype = int4+instance PGTyped schema (nullity 'PGint8) where pgtype = int8+instance PGTyped schema (nullity 'PGnumeric) where pgtype = numeric+instance PGTyped schema (nullity 'PGfloat4) where pgtype = float4+instance PGTyped schema (nullity 'PGfloat8) where pgtype = float8+instance PGTyped schema (nullity 'PGtext) where pgtype = text instance (KnownNat n, 1 <= n)-  => PGTyped schema ('PGchar n) where pgtype = char (Proxy @n)+  => PGTyped schema (nullity ('PGchar n)) where pgtype = char @n instance (KnownNat n, 1 <= n)-  => PGTyped schema ('PGvarchar n) where pgtype = varchar (Proxy @n)-instance PGTyped schema 'PGbytea where pgtype = bytea-instance PGTyped schema 'PGtimestamp where pgtype = timestamp-instance PGTyped schema 'PGtimestamptz where pgtype = timestampWithTimeZone-instance PGTyped schema 'PGdate where pgtype = date-instance PGTyped schema 'PGtime where pgtype = time-instance PGTyped schema 'PGtimetz where pgtype = timeWithTimeZone-instance PGTyped schema 'PGinterval where pgtype = interval-instance PGTyped schema 'PGuuid where pgtype = uuid-instance PGTyped schema 'PGjson where pgtype = json-instance PGTyped schema 'PGjsonb where pgtype = jsonb-instance PGTyped schema ty => PGTyped schema ('PGvararray ty) where-  pgtype = vararray (pgtype @schema @ty)-instance (KnownNat n, PGTyped schema ty) => PGTyped schema ('PGfixarray n ty) where-  pgtype = fixarray (Proxy @n) (pgtype @schema @ty)+  => PGTyped schema (nullity ('PGvarchar n)) where pgtype = varchar @n+instance PGTyped schema (nullity 'PGbytea) where pgtype = bytea+instance PGTyped schema (nullity 'PGtimestamp) where pgtype = timestamp+instance PGTyped schema (nullity 'PGtimestamptz) where pgtype = timestampWithTimeZone+instance PGTyped schema (nullity 'PGdate) where pgtype = date+instance PGTyped schema (nullity 'PGtime) where pgtype = time+instance PGTyped schema (nullity 'PGtimetz) where pgtype = timeWithTimeZone+instance PGTyped schema (nullity 'PGinterval) where pgtype = interval+instance PGTyped schema (nullity 'PGuuid) where pgtype = uuid+instance PGTyped schema (nullity 'PGjson) where pgtype = json+instance PGTyped schema (nullity 'PGjsonb) where pgtype = jsonb+instance PGTyped schema ty+  => PGTyped schema (nullity ('PGvararray ty)) where+    pgtype = vararray (pgtype @schema @ty)+instance (KnownNat n, PGTyped schema ty)+  => PGTyped schema (nullity ('PGfixarray n ty)) where+    pgtype = fixarray @n (pgtype @schema @ty)

@@ -42,13 +42,10 @@     -- * Delete   , deleteFrom   , deleteFrom_-    -- * With-  , with   ) where  import Control.DeepSeq import Data.ByteString hiding (foldr)-import Data.Monoid  import qualified Generics.SOP as SOP import qualified GHC.Generics as GHC@@ -180,16 +177,38 @@ in printSQL manipulation :} DELETE FROM "tab" WHERE ("col1" = "col2") RETURNING *++with manipulation:++>>> type ProductsTable = '[] :=> '["product" ::: 'NoDef :=> 'NotNull 'PGtext, "date" ::: 'Def :=> 'NotNull 'PGdate]++>>> :{+let+  manipulation :: Manipulation+    '[ "products" ::: 'Table ProductsTable+     , "products_deleted" ::: 'Table ProductsTable+     ] '[ 'NotNull 'PGdate] '[]+  manipulation = with+    (deleteFrom #products (#date .< param @1) ReturningStar `as` #deleted_rows)+    (insertQuery_ #products_deleted (selectStar (from (view (#deleted_rows `as` #t)))))+in printSQL manipulation+:}+WITH "deleted_rows" AS (DELETE FROM "products" WHERE ("date" < ($1 :: date)) RETURNING *) INSERT INTO "products_deleted" SELECT * FROM "deleted_rows" AS "t" -}+ newtype Manipulation   (schema :: SchemaType)   (params :: [NullityType])-  (columns :: RelationType)+  (columns :: RowType)     = UnsafeManipulation { renderManipulation :: ByteString }     deriving (GHC.Generic,Show,Eq,Ord,NFData)- instance RenderSQL (Manipulation schema params columns) where   renderSQL = renderManipulation+instance With Manipulation where+  with Done manip = manip+  with (cte :>> ctes) manip = UnsafeManipulation $+    "WITH" <+> renderCommonTableExpressions renderManipulation cte ctes+    <+> renderManipulation manip  -- | Convert a `Query` into a `Manipulation`. queryStatement@@ -212,13 +231,14 @@   :: ( SOP.SListI columns      , SOP.SListI results      , Has tab schema ('Table table)+     , row ~ TableToRow table      , columns ~ TableToColumns table )   => Alias tab -- ^ table to insert into   -> NP (Aliased (ColumnValue schema '[] params)) columns -- ^ row to insert   -> [NP (Aliased (ColumnValue schema '[] params)) columns] -- ^ more rows to insert-  -> ConflictClause schema columns params+  -> ConflictClause schema table params   -- ^ what to do in case of constraint conflict-  -> ReturningClause schema columns params results -- ^ results to return+  -> ReturningClause schema params row results -- ^ results to return   -> Manipulation schema params results insertRows tab rw rws conflict returning = UnsafeManipulation $   "INSERT" <+> "INTO" <+> renderAlias tab@@ -242,12 +262,13 @@   :: ( SOP.SListI columns      , SOP.SListI results      , Has tab schema ('Table table)+     , row ~ TableToRow table      , columns ~ TableToColumns table )   => Alias tab -- ^ table to insert into   -> NP (Aliased (ColumnValue schema '[] params)) columns -- ^ row to insert-  -> ConflictClause schema columns params+  -> ConflictClause schema table params   -- ^ what to do in case of constraint conflict-  -> ReturningClause schema columns params results -- ^ results to return+  -> ReturningClause schema params row results -- ^ results to return   -> Manipulation schema params results insertRow tab rw = insertRows tab rw [] @@ -278,12 +299,13 @@   :: ( SOP.SListI columns      , SOP.SListI results      , Has tab schema ('Table table)+     , row ~ TableToRow table      , columns ~ TableToColumns table )   => Alias tab -- ^ table to insert into-  -> Query schema params (ColumnsToRelation columns)-  -> ConflictClause schema columns params+  -> Query schema params (TableToRow table)+  -> ConflictClause schema table params   -- ^ what to do in case of constraint conflict-  -> ReturningClause schema columns params results -- ^ results to return+  -> ReturningClause schema params row results -- ^ results to return   -> Manipulation schema params results insertQuery tab query conflict returning = UnsafeManipulation $   "INSERT" <+> "INTO" <+> renderAlias tab@@ -297,7 +319,7 @@      , Has tab schema ('Table table)      , columns ~ TableToColumns table )   => Alias tab -- ^ table to insert into-  -> Query schema params (ColumnsToRelation columns)+  -> Query schema params (TableToRow table)   -> Manipulation schema params '[] insertQuery_ tab query =   insertQuery tab query OnConflictDoRaise (Returning Nil)@@ -309,7 +331,7 @@ -- existing value in the row for an update. data ColumnValue   (schema :: SchemaType)-  (columns :: RelationType)+  (columns :: RowType)   (params :: [NullityType])   (ty :: ColumnType)   where@@ -331,17 +353,15 @@ -- values are desired. data ReturningClause   (schema :: SchemaType)-  (columns :: ColumnsType)   (params :: [NullityType])-  (results :: RelationType)+  (row0 :: RowType)+  (row1 :: RowType)   where     ReturningStar-      :: results ~ ColumnsToRelation columns-      => ReturningClause schema columns params results+      :: ReturningClause schema params row row     Returning-      :: rel ~ ColumnsToRelation columns-      => NP (Aliased (Expression schema '[table ::: rel] 'Ungrouped params)) results-      -> ReturningClause schema columns params results+      :: NP (Aliased (Expression schema '[table ::: row0] 'Ungrouped params)) row1+      -> ReturningClause schema params row0 row1  -- | Render a `ReturningClause`. renderReturningClause@@ -359,18 +379,22 @@ -- `OnConflictDoNothing` simply avoids inserting a row. -- `OnConflictDoUpdate` updates the existing row that conflicts with the row -- proposed for insertion.-data ConflictClause (schema :: SchemaType) (columns :: ColumnsType) params where-  OnConflictDoRaise :: ConflictClause schema columns params-  OnConflictDoNothing :: ConflictClause schema columns params-  OnConflictDoUpdate-    :: NP (Aliased (ColumnValue schema (ColumnsToRelation columns) params)) columns-    -> [Condition schema '[table ::: ColumnsToRelation columns] 'Ungrouped params]-    -> ConflictClause schema columns params+data ConflictClause+  (schema :: SchemaType)+  (table :: TableType)+  (params :: [NullityType]) where+    OnConflictDoRaise :: ConflictClause schema table params+    OnConflictDoNothing :: ConflictClause schema table params+    OnConflictDoUpdate+      :: (row ~ TableToRow table, columns ~ TableToColumns table)+      => NP (Aliased (ColumnValue schema row params)) columns+      -> [Condition schema '[t ::: row] 'Ungrouped params]+      -> ConflictClause schema table params  -- | Render a `ConflictClause`. renderConflictClause-  :: SOP.SListI columns-  => ConflictClause schema columns params+  :: SOP.SListI (TableToColumns table)+  => ConflictClause schema table params   -> ByteString renderConflictClause = \case   OnConflictDoRaise -> ""@@ -402,13 +426,14 @@   :: ( SOP.SListI columns      , SOP.SListI results      , Has tab schema ('Table table)+     , row ~ TableToRow table      , columns ~ TableToColumns table )   => Alias tab -- ^ table to update-  -> NP (Aliased (ColumnValue schema (ColumnsToRelation columns) params)) columns+  -> NP (Aliased (ColumnValue schema row params)) columns   -- ^ modified values to replace old values-  -> Condition schema '[tab ::: ColumnsToRelation columns] 'Ungrouped params+  -> (forall t. Condition schema '[t ::: row] 'Ungrouped params)   -- ^ condition under which to perform update on a row-  -> ReturningClause schema columns params results -- ^ results to return+  -> ReturningClause schema params row results -- ^ results to return   -> Manipulation schema params results update tab columns wh returning = UnsafeManipulation $   "UPDATE"@@ -432,11 +457,12 @@ update_   :: ( SOP.SListI columns      , Has tab schema ('Table table)+     , row ~ TableToRow table      , columns ~ TableToColumns table )   => Alias tab -- ^ table to update-  -> NP (Aliased (ColumnValue schema (ColumnsToRelation columns) params)) columns+  -> NP (Aliased (ColumnValue schema row params)) columns   -- ^ modified values to replace old values-  -> Condition schema '[tab ::: ColumnsToRelation columns] 'Ungrouped params+  -> (forall t. Condition schema '[t ::: row] 'Ungrouped params)   -- ^ condition under which to perform update on a row   -> Manipulation schema params '[] update_ tab columns wh = update tab columns wh (Returning Nil)@@ -449,11 +475,12 @@ deleteFrom   :: ( SOP.SListI results      , Has tab schema ('Table table)+     , row ~ TableToRow table      , columns ~ TableToColumns table )   => Alias tab -- ^ table to delete from-  -> Condition schema '[tab ::: ColumnsToRelation columns] 'Ungrouped params+  -> Condition schema '[tab ::: row] 'Ungrouped params   -- ^ condition under which to delete a row-  -> ReturningClause schema columns params results -- ^ results to return+  -> ReturningClause schema params row results -- ^ results to return   -> Manipulation schema params results deleteFrom tab wh returning = UnsafeManipulation $   "DELETE FROM" <+> renderAlias tab@@ -463,45 +490,10 @@ -- | Delete rows returning `Nil`. deleteFrom_   :: ( Has tab schema ('Table table)+     , row ~ TableToRow table      , columns ~ TableToColumns table )   => Alias tab -- ^ table to delete from-  -> Condition schema '[tab ::: ColumnsToRelation columns] 'Ungrouped params+  -> (forall t. Condition schema '[t ::: row] 'Ungrouped params)   -- ^ condition under which to delete a row   -> Manipulation schema params '[] deleteFrom_ tab wh = deleteFrom tab wh (Returning Nil)--{------------------------------------------WITH statements------------------------------------------}---- | `with` provides a way to write auxiliary statements for use in a larger statement.--- These statements, which are often referred to as Common Table Expressions or CTEs,--- can be thought of as defining temporary tables that exist just for one statement.------ >>> type ProductsTable = '[] :=> '["product" ::: 'NoDef :=> 'NotNull 'PGtext, "date" ::: 'Def :=> 'NotNull 'PGdate]------ >>> :{--- let---   manipulation :: Manipulation '["products" ::: 'Table ProductsTable, "products_deleted" ::: 'Table ProductsTable] '[ 'NotNull 'PGdate] '[]---   manipulation = with---     (deleteFrom #products (#date .< param @1) ReturningStar `as` #deleted_rows)---     (insertQuery_ #products_deleted (selectStar (from (view (#deleted_rows `as` #t)))))--- in printSQL manipulation--- :}--- WITH "deleted_rows" AS (DELETE FROM "products" WHERE ("date" < ($1 :: date)) RETURNING *) INSERT INTO "products_deleted" SELECT * FROM "deleted_rows" AS "t"-with-  :: SOP.SListI commons-  => NP (Aliased (Manipulation schema params)) (common ': commons)-  -- ^ common table expressions-  -> Manipulation (With (common ': commons) schema) params results-  -> Manipulation schema params results-with commons manipulation = UnsafeManipulation $-  "WITH" <+> renderCommaSeparated renderCommon commons-  <+> renderManipulation manipulation-  where-    renderCommon-      :: Aliased (Manipulation schema params) common-      -> ByteString-    renderCommon (common `As` alias) =-      renderAlias alias <+> "AS" <+>-        parenthesized (renderManipulation common)

@@ -105,9 +105,6 @@     Migration (..)   , migrateUp   , migrateDown-    -- * Aligned lists-  , AlignedList (..)-  , single     -- * Migration table   , MigrationsTable   , createMigrations@@ -116,15 +113,12 @@   , selectMigration   ) where -import Control.Category import Control.Monad import Control.Monad.Base import Control.Monad.Trans.Control-import Data.Monoid import Generics.SOP (K(..)) import Data.Function ((&)) import Data.Text (Text)-import Prelude hiding (id, (.))  import Squeal.PostgreSQL @@ -136,21 +130,6 @@   , up :: PQ schema0 schema1 io () -- ^ The `up` instruction of a `Migration`.   , down :: PQ schema1 schema0 io () -- ^ The `down` instruction of a `Migration`.   }---- | An `AlignedList` is a type-aligned list or free category.-data AlignedList p x0 x1 where-  Done :: AlignedList p x x-  (:>>) :: p x0 x1 -> AlignedList p x1 x2 -> AlignedList p x0 x2-infixr 7 :>>-instance Category (AlignedList p) where-  id = Done-  (.) list = \case-    Done -> list-    step :>> steps -> step :>> (steps >>> list)---- | A `single` step.-single :: p x0 x1 -> AlignedList p x0 x1-single step = step :>> Done  -- | Run `Migration`s by creating the `MigrationsTable` -- if it does not exist and then in a transaction, for each each `Migration`

@@ -50,7 +50,7 @@   , MonadPQ (..)   , PQRun   , pqliftWith-    -- * Result+    -- * Results   , LibPQ.Result   , LibPQ.Row   , ntuples@@ -62,6 +62,11 @@   , LibPQ.ExecStatus (..)   , resultStatus   , resultErrorMessage+  , resultErrorCode+    -- * Exceptions+  , SquealException (..)+  , catchSqueal+  , handleSqueal   ) where  import Control.Exception.Lifted@@ -73,9 +78,10 @@ import Data.Foldable import Data.Function ((&)) import Data.Kind-import Data.Monoid+import Data.Text (pack, Text) import Data.Traversable import Generics.SOP+import PostgreSQL.Binary.Encoding (encodingBytes)  import qualified Database.PostgreSQL.LibPQ as LibPQ @@ -90,7 +96,6 @@ import Control.Monad.Trans.Reader import Control.Monad.Trans.Maybe import Control.Monad.Trans.Cont-import Control.Monad.Trans.List  import qualified Control.Monad.Trans.State.Lazy as Lazy import qualified Control.Monad.Trans.State.Strict as Strict@@ -269,7 +274,7 @@   define (UnsafeDefinition q) = PQ $ \ (K conn) -> do     resultMaybe <- liftBase $ LibPQ.exec conn q     case resultMaybe of-      Nothing -> error+      Nothing -> throw $ ResultException         "define: LibPQ.exec returned no results"       Just result -> return $ K (K result) @@ -393,14 +398,17 @@     (UnsafeManipulation q :: Manipulation schema ps ys) (params :: x) =       PQ $ \ (K conn) -> do         let-          toParam' bytes = (LibPQ.invalidOid,bytes,LibPQ.Binary)+          toParam' encoding =+            (LibPQ.invalidOid, encodingBytes encoding, LibPQ.Binary)           params' = fmap (fmap toParam') (hcollapse (toParams @x @ps params))           q' = q <> ";"         resultMaybe <- liftBase $ LibPQ.execParams conn q' params' LibPQ.Binary         case resultMaybe of-          Nothing -> error+          Nothing -> throw $ ResultException             "manipulateParams: LibPQ.execParams returned no results"-          Just result -> return $ K (K result)+          Just result -> do+            tryResult result+            return $ K (K result)    traversePrepared     (UnsafeManipulation q :: Manipulation schema xs ys) (list :: list x) =@@ -408,29 +416,25 @@         let temp = "temporary_statement"         prepResultMaybe <- LibPQ.prepare conn temp q Nothing         case prepResultMaybe of-          Nothing -> error+          Nothing -> throw $ ResultException             "traversePrepared: LibPQ.prepare returned no results"-          Just prepResult -> do-            status <- LibPQ.resultStatus prepResult-            unless (status == LibPQ.CommandOk) . error $-              "traversePrepared: LibPQ.prepare status " <> show status+          Just prepResult -> tryResult prepResult         results <- for list $ \ params -> do           let-            toParam' bytes = (bytes,LibPQ.Binary)+            toParam' encoding = (encodingBytes encoding,LibPQ.Binary)             params' = fmap (fmap toParam') (hcollapse (toParams @x @xs params))           resultMaybe <- LibPQ.execPrepared conn temp params' LibPQ.Binary           case resultMaybe of-            Nothing -> error+            Nothing -> throw $ ResultException               "traversePrepared: LibPQ.execParams returned no results"-            Just result -> return $ K result+            Just result -> do+              tryResult result+              return $ K result         deallocResultMaybe <- LibPQ.exec conn ("DEALLOCATE " <> temp <> ";")         case deallocResultMaybe of-          Nothing -> error+          Nothing -> throw $ ResultException             "traversePrepared: LibPQ.exec DEALLOCATE returned no results"-          Just deallocResult -> do-            status <- LibPQ.resultStatus deallocResult-            unless (status == LibPQ.CommandOk) . error $-              "traversePrepared: DEALLOCATE status " <> show status+          Just deallocResult -> tryResult deallocResult         return (K results)    traversePrepared_@@ -439,29 +443,23 @@         let temp = "temporary_statement"         prepResultMaybe <- LibPQ.prepare conn temp q Nothing         case prepResultMaybe of-          Nothing -> error+          Nothing -> throw $ ResultException             "traversePrepared_: LibPQ.prepare returned no results"-          Just prepResult -> do-            status <- LibPQ.resultStatus prepResult-            unless (status == LibPQ.CommandOk) . error $-              "traversePrepared: LibPQ.prepare status " <> show status+          Just prepResult -> tryResult prepResult         for_ list $ \ params -> do           let-            toParam' bytes = (bytes,LibPQ.Binary)+            toParam' encoding = (encodingBytes encoding, LibPQ.Binary)             params' = fmap (fmap toParam') (hcollapse (toParams @x @xs params))           resultMaybe <- LibPQ.execPrepared conn temp params' LibPQ.Binary           case resultMaybe of-            Nothing -> error+            Nothing -> throw $ ResultException               "traversePrepared_: LibPQ.execParams returned no results"-            Just _result -> return ()+            Just result -> tryResult result         deallocResultMaybe <- LibPQ.exec conn ("DEALLOCATE " <> temp <> ";")         case deallocResultMaybe of-          Nothing -> error+          Nothing -> throw $ ResultException             "traversePrepared: LibPQ.exec DEALLOCATE returned no results"-          Just deallocResult -> do-            status <- LibPQ.resultStatus deallocResult-            unless (status == LibPQ.CommandOk) . error $-              "traversePrepared: DEALLOCATE status " <> show status+          Just deallocResult -> tryResult deallocResult         return (K ())    liftPQ pq = PQ $ \ (K conn) -> do@@ -479,7 +477,6 @@ instance (Monoid w, MonadPQ schema m) => MonadPQ schema (Strict.RWST r w s m) instance (Monoid w, MonadPQ schema m) => MonadPQ schema (Lazy.RWST r w s m) instance MonadPQ schema m => MonadPQ schema (ContT r m)-instance MonadPQ schema m => MonadPQ schema (ListT m)  instance (Monad m, schema0 ~ schema1)   => Applicative (PQ schema0 schema1 m) where@@ -534,14 +531,16 @@   -> io y getRow r (K result :: K LibPQ.Result columns) = liftBase $ do   numRows <- LibPQ.ntuples result-  when (numRows < r) $ error $-    "getRow: expected at least " <> show r <> "rows but only saw "-    <> show numRows+  when (numRows < r) $ throw $ ResultException $+    "getRow: expected at least " <> pack (show r) <> "rows but only saw "+    <> pack (show numRows)   let len = fromIntegral (lengthSList (Proxy @columns))   row' <- traverse (LibPQ.getvalue result r) [0 .. len - 1]   case fromList row' of-    Nothing -> error "getRow: found unexpected length"-    Just row -> return $ fromRow @columns row+    Nothing -> throw $ ResultException "getRow: found unexpected length"+    Just row -> case fromRow @columns row of+      Left parseError -> throw $ ParseException $ "getRow: " <> parseError+      Right y -> return y  -- | Intended to be used for unfolding in streaming libraries, `nextRow` -- takes a total number of rows (which can be found with `ntuples`)@@ -558,8 +557,10 @@     let len = fromIntegral (lengthSList (Proxy @columns))     row' <- traverse (LibPQ.getvalue result r) [0 .. len - 1]     case fromList row' of-      Nothing -> error "nextRow: found unexpected length"-      Just row -> return $ Just (r+1, fromRow @columns row)+      Nothing -> throw $ ResultException "nextRow: found unexpected length"+      Just row -> case fromRow @columns row of+        Left parseError -> throw $ ParseException $ "nextRow: " <> parseError+        Right y -> return $ Just (r+1, y)  -- | Get all rows from a `LibPQ.Result`. getRows@@ -572,8 +573,10 @@   for [0 .. numRows - 1] $ \ r -> do     row' <- traverse (LibPQ.getvalue result r) [0 .. len - 1]     case fromList row' of-      Nothing -> error "getRows: found unexpected length"-      Just row -> return $ fromRow @columns row+      Nothing -> throw $ ResultException "getRows: found unexpected length"+      Just row -> case fromRow @columns row of+        Left parseError -> throw $ ParseException $ "getRows: " <> parseError+        Right y -> return y  -- | Get the first row if possible from a `LibPQ.Result`. firstRow@@ -586,8 +589,10 @@     let len = fromIntegral (lengthSList (Proxy @columns))     row' <- traverse (LibPQ.getvalue result 0) [0 .. len - 1]     case fromList row' of-      Nothing -> error "firstRow: found unexpected length"-      Just row -> return . Just $ fromRow @columns row+      Nothing -> throw $ ResultException "firstRow: found unexpected length"+      Just row -> case fromRow @columns row of+        Left parseError -> throw $ ParseException $ "firstRow: " <> parseError+        Right y -> return $ Just y  -- | Lifts actions on results from @LibPQ@. liftResult@@ -609,3 +614,55 @@ resultErrorMessage   :: MonadBase IO io => K LibPQ.Result results -> io (Maybe ByteString) resultErrorMessage = liftResult LibPQ.resultErrorMessage++-- | Returns the error code most recently generated by an operation+-- on the connection.+--+-- https://www.postgresql.org/docs/current/static/errcodes-appendix.html+resultErrorCode+  :: MonadBase IO io+  => K LibPQ.Result results+  -> io (Maybe ByteString)+resultErrorCode = liftResult (flip LibPQ.resultErrorField LibPQ.DiagSqlstate)++-- | `Exception`s that can be thrown by Squeal.+data SquealException+  = PQException+  { sqlExecStatus :: LibPQ.ExecStatus+  , sqlStateCode :: Maybe ByteString+    -- ^ https://www.postgresql.org/docs/current/static/errcodes-appendix.html+  , sqlErrorMessage :: Maybe ByteString+  }+  | ResultException Text+  | ParseException Text+  deriving (Eq, Show)+instance Exception SquealException++tryResult+  :: MonadBase IO io+  => LibPQ.Result+  -> io ()+tryResult result = liftBase $ do+  status <- LibPQ.resultStatus result+  case status of+    LibPQ.CommandOk -> return ()+    LibPQ.TuplesOk -> return ()+    _ -> do+      stateCode <- LibPQ.resultErrorField result LibPQ.DiagSqlstate+      msg <- LibPQ.resultErrorMessage result+      throw $ PQException status stateCode msg++-- | Catch `SquealException`s.+catchSqueal+  :: MonadBaseControl IO io+  => io a+  -> (SquealException -> io a) -- ^ handler+  -> io a+catchSqueal = catch++-- | Handle `SquealException`s.+handleSqueal+  :: MonadBaseControl IO io+  => (SquealException -> io a) -- ^ handler+  -> io a -> io a+handleSqueal = handle

@@ -29,21 +29,43 @@ module Squeal.PostgreSQL.Query   ( -- * Queries     Query (UnsafeQuery, renderQuery)-  , union-  , unionAll-  , intersect-  , intersectAll-  , except-  , exceptAll-    -- * Select+    -- ** Select   , select   , selectDistinct   , selectStar   , selectDistinctStar   , selectDotStar   , selectDistinctDotStar+    -- ** Values   , values   , values_+    -- ** Set Operations+  , union+  , unionAll+  , intersect+  , intersectAll+  , except+  , exceptAll+    -- ** With+  , With (with)+  , CommonTableExpression (..)+  , renderCommonTableExpression+  , renderCommonTableExpressions+    -- ** Json+  , jsonEach+  , jsonbEach+  , jsonEachAsText+  , jsonbEachAsText+  , jsonObjectKeys+  , jsonbObjectKeys+  , jsonPopulateRecord+  , jsonbPopulateRecord+  , jsonPopulateRecordSet+  , jsonbPopulateRecordSet+  , jsonToRecord+  , jsonbToRecord+  , jsonToRecordSet+  , jsonbToRecordSet     -- * Table Expressions   , TableExpression (..)   , renderTableExpression@@ -54,22 +76,7 @@   , orderBy   , limit   , offset-    -- ** JSON table expressions-  , PGjson_each-  , PGjsonb_each-  , jsonEach-  , jsonbEach-  , jsonEachAsText-  , jsonbEachAsText-  , jsonPopulateRecordAs-  , jsonbPopulateRecordAs-  , jsonPopulateRecordSetAs-  , jsonbPopulateRecordSetAs-  , jsonToRecordAs-  , jsonbToRecordAs-  , jsonToRecordSetAs-  , jsonbToRecordSetAs-    -- * From+    -- * From Clauses   , FromClause (..)   , table   , subquery@@ -89,11 +96,37 @@     -- * Sorting   , SortExpression (..)   , renderSortExpression+    -- * Subquery Expressions+  , in_+  , rowIn+  , eqAll+  , rowEqAll+  , eqAny+  , rowEqAny+  , neqAll+  , rowNeqAll+  , neqAny+  , rowNeqAny+  , allLt+  , rowLtAll+  , ltAny+  , rowLtAny+  , lteAll+  , rowLteAll+  , lteAny+  , rowLteAny+  , gtAll+  , rowGtAll+  , gtAny+  , rowGtAny+  , gteAll+  , rowGteAll+  , gteAny+  , rowGteAny   ) where  import Control.DeepSeq import Data.ByteString (ByteString)-import Data.Monoid hiding (All) import Data.String import Data.Word import Generics.SOP hiding (from)@@ -107,9 +140,7 @@  {- | The process of retrieving or the command to retrieve data from a database-is called a `Query`. The `select`, `selectStar`, `selectDotStar`,-`selectDistinct`, `selectDistinctStar` and `selectDistinctDotStar` commands-are used to specify queries.+is called a `Query`. Let's see some examples of queries.  simple query: @@ -280,6 +311,16 @@ :} SELECT "t1".* FROM "tab" AS "t1" CROSS JOIN "tab" AS "t2" +value queries:++>>> :{+let+  query :: Query '[] '[] '["foo" ::: 'NotNull 'PGint2, "bar" ::: 'NotNull 'PGbool]+  query = values (1 `as` #foo :* true `as` #bar) [2 `as` #foo :* false `as` #bar]+in printSQL query+:}+SELECT * FROM (VALUES (1, TRUE), (2, FALSE)) AS t ("foo", "bar")+ set operations:  >>> :{@@ -295,11 +336,30 @@ in printSQL query :} (SELECT * FROM "tab" AS "tab") UNION ALL (SELECT * FROM "tab" AS "tab")++with queries:++>>> :{+let+  query :: Query+    '[ "t1" ::: 'View+       '[ "c1" ::: 'NotNull 'PGtext+        , "c2" ::: 'NotNull 'PGtext] ]+    '[]+    '[ "c1" ::: 'NotNull 'PGtext+     , "c2" ::: 'NotNull 'PGtext ]+  query = with (+    selectStar (from (view #t1)) `as` #t2 :>>+    selectStar (from (view #t2)) `as` #t3+    ) (selectStar (from (view #t3)))+in printSQL query+:}+WITH "t2" AS (SELECT * FROM "t1" AS "t1"), "t3" AS (SELECT * FROM "t2" AS "t2") SELECT * FROM "t3" AS "t3" -} newtype Query   (schema :: SchemaType)   (params :: [NullityType])-  (columns :: RelationType)+  (columns :: RowType)     = UnsafeQuery { renderQuery :: ByteString }     deriving (GHC.Generic,Show,Eq,Ord,NFData) instance RenderSQL (Query schema params columns) where renderSQL = renderQuery@@ -381,9 +441,9 @@ -- the intermediate table are actually output. select   :: SListI columns-  => NP (Aliased (Expression schema relations grouping params)) (column ': columns)+  => NP (Aliased (Expression schema from grouping params)) (column ': columns)   -- ^ select list-  -> TableExpression schema params relations grouping+  -> TableExpression schema params from grouping   -- ^ intermediate virtual table   -> Query schema params (column ': columns) select list rels = UnsafeQuery $@@ -395,9 +455,9 @@ -- be subject to the elimination of duplicate rows using `selectDistinct`. selectDistinct   :: SListI columns-  => NP (Aliased (Expression schema relations 'Ungrouped params)) (column ': columns)+  => NP (Aliased (Expression schema from 'Ungrouped params)) (column ': columns)   -- ^ select list-  -> TableExpression schema params relations 'Ungrouped+  -> TableExpression schema params from 'Ungrouped   -- ^ intermediate virtual table   -> Query schema params (column ': columns) selectDistinct list rels = UnsafeQuery $@@ -408,8 +468,8 @@ -- | The simplest kind of query is `selectStar` which emits all columns -- that the table expression produces. selectStar-  :: HasUnique relation relations columns-  => TableExpression schema params relations 'Ungrouped+  :: HasUnique table from columns+  => TableExpression schema params from 'Ungrouped   -- ^ intermediate virtual table   -> Query schema params columns selectStar rels = UnsafeQuery $ "SELECT" <+> "*" <+> renderTableExpression rels@@ -417,8 +477,8 @@ -- | A `selectDistinctStar` emits all columns that the table expression -- produces and eliminates duplicate rows. selectDistinctStar-  :: HasUnique relation relations columns-  => TableExpression schema params relations 'Ungrouped+  :: HasUnique table from columns+  => TableExpression schema params from 'Ungrouped   -- ^ intermediate virtual table   -> Query schema params columns selectDistinctStar rels = UnsafeQuery $@@ -427,27 +487,27 @@ -- | When working with multiple tables, it can also be useful to ask -- for all the columns of a particular table, using `selectDotStar`. selectDotStar-  :: Has relation relations columns-  => Alias relation+  :: Has table from columns+  => Alias table   -- ^ particular virtual subtable-  -> TableExpression schema params relations 'Ungrouped+  -> TableExpression schema params from 'Ungrouped   -- ^ intermediate virtual table   -> Query schema params columns-selectDotStar rel relations = UnsafeQuery $-  "SELECT" <+> renderAlias rel <> ".*" <+> renderTableExpression relations+selectDotStar rel tab = UnsafeQuery $+  "SELECT" <+> renderAlias rel <> ".*" <+> renderTableExpression tab  -- | A `selectDistinctDotStar` asks for all the columns of a particular table, -- and eliminates duplicate rows. selectDistinctDotStar-  :: Has relation relations columns-  => Alias relation+  :: Has table from columns+  => Alias table   -- ^ particular virtual table-  -> TableExpression schema params relations 'Ungrouped+  -> TableExpression schema params from 'Ungrouped   -- ^ intermediate virtual table   -> Query schema params columns-selectDistinctDotStar rel relations = UnsafeQuery $+selectDistinctDotStar rel tab = UnsafeQuery $   "SELECT DISTINCT" <+> renderAlias rel <> ".*"-  <+> renderTableExpression relations+  <+> renderTableExpression tab  -- | `values` computes a row value or set of row values -- specified by value expressions. It is most commonly used@@ -501,13 +561,13 @@ data TableExpression   (schema :: SchemaType)   (params :: [NullityType])-  (relations :: RelationsType)+  (from :: FromType)   (grouping :: Grouping)     = TableExpression-    { fromClause :: FromClause schema params relations+    { fromClause :: FromClause schema params from     -- ^ A table reference that can be a table name, or a derived table such     -- as a subquery, a @JOIN@ construct, or complex combinations of these.-    , whereClause :: [Condition schema relations 'Ungrouped params]+    , whereClause :: [Condition schema from 'Ungrouped params]     -- ^ optional search coditions, combined with `.&&`. After the processing     -- of the `fromClause` is done, each row of the derived virtual table     -- is checked against the search condition. If the result of the@@ -516,20 +576,20 @@     -- at least one column of the table generated in the `fromClause`;     -- this is not required, but otherwise the WHERE clause will     -- be fairly useless.-    , groupByClause :: GroupByClause relations grouping+    , groupByClause :: GroupByClause from grouping     -- ^ The `groupByClause` is used to group together those rows in a table     -- that have the same values in all the columns listed. The order in which     -- the columns are listed does not matter. The effect is to combine each     -- set of rows having common values into one group row that represents all     -- rows in the group. This is done to eliminate redundancy in the output     -- and/or compute aggregates that apply to these groups.-    , havingClause :: HavingClause schema relations grouping params+    , havingClause :: HavingClause schema from grouping params     -- ^ If a table has been grouped using `groupBy`, but only certain groups     -- are of interest, the `havingClause` can be used, much like a     -- `whereClause`, to eliminate groups from the result. Expressions in the     -- `havingClause` can refer both to grouped expressions and to ungrouped     -- expressions (which necessarily involve an aggregate function).-    , orderByClause :: [SortExpression schema relations grouping params]+    , orderByClause :: [SortExpression schema from grouping params]     -- ^ The `orderByClause` is for optional sorting. When more than one     -- `SortExpression` is specified, the later (right) values are used to sort     -- rows that are equal according to the earlier (left) values.@@ -547,7 +607,7 @@  -- | Render a `TableExpression` renderTableExpression-  :: TableExpression schema params relations grouping+  :: TableExpression schema params from grouping   -> ByteString renderTableExpression   (TableExpression frm' whs' grps' hvs' srts' lims' offs') = mconcat@@ -581,16 +641,16 @@ -- `group`, `having`, `orderBy`, `limit` and `offset`, using the `&` operator -- to match the left-to-right sequencing of their placement in SQL. from-  :: FromClause schema params relations -- ^ table reference-  -> TableExpression schema params relations 'Ungrouped+  :: FromClause schema params from -- ^ table reference+  -> TableExpression schema params from 'Ungrouped from rels = TableExpression rels [] NoGroups NoHaving [] [] []  -- | A `where_` is an endomorphism of `TableExpression`s which adds a -- search condition to the `whereClause`. where_-  :: Condition schema relations 'Ungrouped params -- ^ filtering condition-  -> TableExpression schema params relations grouping-  -> TableExpression schema params relations grouping+  :: Condition schema from 'Ungrouped params -- ^ filtering condition+  -> TableExpression schema params from grouping+  -> TableExpression schema params from grouping where_ wh rels = rels {whereClause = wh : whereClause rels}  -- | A `groupBy` is a transformation of `TableExpression`s which switches@@ -598,9 +658,9 @@ -- a "grand total" aggregation query. groupBy   :: SListI bys-  => NP (By relations) bys -- ^ grouped columns-  -> TableExpression schema params relations 'Ungrouped-  -> TableExpression schema params relations ('Grouped bys)+  => NP (By from) bys -- ^ grouped columns+  -> TableExpression schema params from 'Ungrouped+  -> TableExpression schema params from ('Grouped bys) groupBy bys rels = TableExpression   { fromClause = fromClause rels   , whereClause = whereClause rels@@ -614,218 +674,176 @@ -- | A `having` is an endomorphism of `TableExpression`s which adds a -- search condition to the `havingClause`. having-  :: Condition schema relations ('Grouped bys) params -- ^ having condition-  -> TableExpression schema params relations ('Grouped bys)-  -> TableExpression schema params relations ('Grouped bys)+  :: Condition schema from ('Grouped bys) params -- ^ having condition+  -> TableExpression schema params from ('Grouped bys)+  -> TableExpression schema params from ('Grouped bys) having hv rels = rels   { havingClause = case havingClause rels of Having hvs -> Having (hv:hvs) }  -- | An `orderBy` is an endomorphism of `TableExpression`s which appends an -- ordering to the right of the `orderByClause`. orderBy-  :: [SortExpression schema relations grouping params] -- ^ sort expressions-  -> TableExpression schema params relations grouping-  -> TableExpression schema params relations grouping+  :: [SortExpression schema from grouping params] -- ^ sort expressions+  -> TableExpression schema params from grouping+  -> TableExpression schema params from grouping orderBy srts rels = rels {orderByClause = orderByClause rels ++ srts}  -- | A `limit` is an endomorphism of `TableExpression`s which adds to the -- `limitClause`. limit   :: Word64 -- ^ limit parameter-  -> TableExpression schema params relations grouping-  -> TableExpression schema params relations grouping+  -> TableExpression schema params from grouping+  -> TableExpression schema params from grouping limit lim rels = rels {limitClause = lim : limitClause rels}  -- | An `offset` is an endomorphism of `TableExpression`s which adds to the -- `offsetClause`. offset   :: Word64 -- ^ offset parameter-  -> TableExpression schema params relations grouping-  -> TableExpression schema params relations grouping+  -> TableExpression schema params from grouping+  -> TableExpression schema params from grouping offset off rels = rels {offsetClause = off : offsetClause rels}  {----------------------------------------- JSON stuff -----------------------------------------} -type PGjson_each_variant val tab =-  '[ tab ::: '[ "key" ::: 'NotNull 'PGtext, "value" ::: 'NotNull val ] ]---- | The type of a `json_each` `FromClause`.-type PGjson_each tab = PGjson_each_variant 'PGjson tab--- | The type of a `jsonb_each` `FromClause`.-type PGjsonb_each tab = PGjson_each_variant 'PGjsonb tab--- | The type of a `json_each_text` `FromClause`.-type PGjson_each_text tab = PGjson_each_variant 'PGtext tab--- | The type of a `jsonb_each_text` `FromClause`.-type PGjsonb_each_text tab = PGjson_each_variant 'PGtext tab--unsafeAliasedFromClauseExpression-  :: Aliased (Expression schema' relations' grouping' params') ty'-  -> FromClause schema params relations-unsafeAliasedFromClauseExpression aliasedExpr = UnsafeFromClause-  (renderAliasedAs renderExpression aliasedExpr)+unsafeSetOfFunction+  :: ByteString+  -> Expression schema '[] 'Ungrouped params ty+  -> Query schema params row+unsafeSetOfFunction fun expr = UnsafeQuery $+  "SELECT * FROM " <> fun <> "(" <> renderExpression expr <> ")"  -- | Expands the outermost JSON object into a set of key/value pairs. jsonEach-  :: Aliased (Expression schema '[] 'Ungrouped params) '(tab, nullity 'PGjson)-  -> FromClause schema params (PGjson_each tab)-jsonEach (As jexpr jname) = unsafeAliasedFromClauseExpression-  (As (unsafeFunction "json_each" jexpr) jname)+  :: Expression schema '[] 'Ungrouped params (nullity 'PGjson) -- ^ json object+  -> Query schema params+      '["key" ::: 'NotNull 'PGtext, "value" ::: 'NotNull 'PGjson]+jsonEach = unsafeSetOfFunction "json_each"  -- | Expands the outermost binary JSON object into a set of key/value pairs. jsonbEach-  :: Aliased (Expression schema '[] 'Ungrouped params) '(tab, nullity 'PGjsonb)-  -> FromClause schema params (PGjsonb_each tab)-jsonbEach (As jexpr jname) = unsafeAliasedFromClauseExpression-  (As (unsafeFunction "jsonb_each" jexpr) jname)+  :: Expression schema '[] 'Ungrouped params (nullity 'PGjsonb) -- ^ jsonb object+  -> Query schema params+      '["key" ::: 'NotNull 'PGtext, "value" ::: 'NotNull 'PGjsonb]+jsonbEach = unsafeSetOfFunction "jsonb_each"  -- | Expands the outermost JSON object into a set of key/value pairs. jsonEachAsText-  :: Aliased (Expression schema '[] 'Ungrouped params) '(tab, nullity 'PGjson)-  -> FromClause schema params (PGjson_each_text tab)-jsonEachAsText (As jexpr jname) = unsafeAliasedFromClauseExpression-  (As (unsafeFunction "json_each" jexpr) jname)+  :: Expression schema '[] 'Ungrouped params (nullity 'PGjson) -- ^ json object+  -> Query schema params+      '["key" ::: 'NotNull 'PGtext, "value" ::: 'NotNull 'PGtext]+jsonEachAsText = unsafeSetOfFunction "json_each_text"  -- | Expands the outermost binary JSON object into a set of key/value pairs. jsonbEachAsText-  :: Aliased (Expression schema '[] 'Ungrouped params) '(tab, nullity 'PGjsonb)-  -> FromClause schema params (PGjsonb_each_text tab)-jsonbEachAsText (As jexpr jname) = unsafeAliasedFromClauseExpression-  (As (unsafeFunction "jsonb_each" jexpr) jname)+  :: Expression schema '[] 'Ungrouped params (nullity 'PGjsonb) -- ^ jsonb object+  -> Query schema params+    '["key" ::: 'NotNull 'PGtext, "value" ::: 'NotNull 'PGtext]+jsonbEachAsText = unsafeSetOfFunction "jsonb_each_text" -nullRow-  :: Has tab schema ('Table table)-  => Alias tab-  -> Expression schema relations grouping params-     (nullity ('PGcomposite (RelationToRowType (TableToRelation table))))-nullRow tab = UnsafeExpression ("null::"<+>renderAlias tab)+-- | Returns set of keys in the outermost JSON object.+jsonObjectKeys+  :: Expression schema '[] 'Ungrouped params (nullity 'PGjson) -- ^ json object+  -> Query schema params '["json_object_keys" ::: 'NotNull 'PGtext]+jsonObjectKeys = unsafeSetOfFunction "json_object_keys" +-- | Returns set of keys in the outermost JSON object.+jsonbObjectKeys+  :: Expression schema '[] 'Ungrouped params (nullity 'PGjsonb) -- ^ jsonb object+  -> Query schema params '["jsonb_object_keys" ::: 'NotNull 'PGtext]+jsonbObjectKeys = unsafeSetOfFunction "jsonb_object_keys"++unsafePopulateFunction+  :: ByteString+  -> TypeExpression schema (nullity ('PGcomposite row))+  -> Expression schema '[] 'Ungrouped params ty+  -> Query schema params row+unsafePopulateFunction fun ty expr = UnsafeQuery $+  "SELECT * FROM " <> fun <> "("+    <> "null::" <> renderTypeExpression ty <> ", "+    <> renderExpression expr <> ")"+ -- | Expands the JSON expression to a row whose columns match the record -- type defined by the given table.-jsonPopulateRecordAs-  :: (KnownSymbol alias, Has tab schema ('Table table))-  => Alias tab-  -> Expression schema '[] 'Ungrouped params (nullity 'PGjson)-  -> Alias alias-  -> FromClause schema params '[alias ::: TableToRelation table]-jsonPopulateRecordAs tableName expr alias = unsafeAliasedFromClauseExpression-  (unsafeVariadicFunction "json_populate_record"-   (nullRow tableName :* expr :* Nil) `As` alias)+jsonPopulateRecord+  :: TypeExpression schema (nullity ('PGcomposite row)) -- ^ row type+  -> Expression schema '[] 'Ungrouped params (nullity 'PGjson) -- ^ json object+  -> Query schema params row+jsonPopulateRecord = unsafePopulateFunction "json_populate_record"  -- | Expands the binary JSON expression to a row whose columns match the record -- type defined by the given table.-jsonbPopulateRecordAs-  :: (KnownSymbol alias, Has tab schema ('Table table))-  => Alias tab-  -> Expression schema '[] 'Ungrouped params (nullity 'PGjsonb)-  -> Alias alias-  -> FromClause schema params '[alias ::: TableToRelation table]-jsonbPopulateRecordAs tableName expr alias = unsafeAliasedFromClauseExpression-  (unsafeVariadicFunction "jsonb_populate_record"-   (nullRow tableName :* expr :* Nil) `As` alias)+jsonbPopulateRecord+  :: TypeExpression schema (nullity ('PGcomposite row)) -- ^ row type+  -> Expression schema '[] 'Ungrouped params (nullity 'PGjsonb) -- ^ jsonb object+  -> Query schema params row+jsonbPopulateRecord = unsafePopulateFunction "jsonb_populate_record"  -- | Expands the outermost array of objects in the given JSON expression to a -- set of rows whose columns match the record type defined by the given table.-jsonPopulateRecordSetAs-  :: (KnownSymbol alias, Has tab schema ('Table table))-  => Alias tab-  -> Expression schema '[] 'Ungrouped params (nullity 'PGjson)-  -> Alias alias-  -> FromClause schema params '[alias ::: TableToRelation table]-jsonPopulateRecordSetAs tableName expr alias = unsafeAliasedFromClauseExpression-  (unsafeVariadicFunction "json_populate_record_set"-   (nullRow tableName :* expr :* Nil) `As` alias)+jsonPopulateRecordSet+  :: TypeExpression schema (nullity ('PGcomposite row)) -- ^ row type+  -> Expression schema '[] 'Ungrouped params (nullity 'PGjson) -- ^ json array+  -> Query schema params row+jsonPopulateRecordSet = unsafePopulateFunction "json_populate_record_set"  -- | Expands the outermost array of objects in the given binary JSON expression -- to a set of rows whose columns match the record type defined by the given -- table.-jsonbPopulateRecordSetAs-  :: (KnownSymbol alias, Has tab schema ('Table table))-  => Alias tab-  -> Expression schema '[] 'Ungrouped params (nullity 'PGjsonb)-  -> Alias alias-  -> FromClause schema params '[alias ::: TableToRelation table]-jsonbPopulateRecordSetAs tableName expr alias = unsafeAliasedFromClauseExpression-  (unsafeVariadicFunction "jsonb_populate_record_set"-   (nullRow tableName :* expr :* Nil) `As` alias)--renderTableTypeExpression-  :: All Top types-  => Aliased (NP (Aliased (TypeExpression schema))) (tab ::: types)-  -> ByteString-renderTableTypeExpression (hc `As` tab)-  = (renderAlias tab <>)-  . parenthesized-  . commaSeparated-  . flip appEndo []-  . hcfoldMap-    (Proxy :: Proxy Top)-    (\(ty `As` name) -> Endo-      ((renderAlias name <+> renderTypeExpression ty):))-  $ hc+jsonbPopulateRecordSet+  :: TypeExpression schema (nullity ('PGcomposite row)) -- ^ row type+  -> Expression schema '[] 'Ungrouped params (nullity 'PGjsonb) -- ^ jsonb array+  -> Query schema params row+jsonbPopulateRecordSet = unsafePopulateFunction "jsonb_populate_record_set" -unsafeTableAliasedFromClauseExpression-  :: All Top types-  => Expression schema' relations' grouping' params' ty'-  -> Aliased (NP (Aliased (TypeExpression schema))) (tab ::: types)-  -> FromClause schema params '[alias ::: types]-unsafeTableAliasedFromClauseExpression expr types = UnsafeFromClause-  (renderExpression expr-   <+> "AS"-   <+> renderTableTypeExpression types)+unsafeRecordFunction+  :: (SListI record, json `In` PGJsonType)+  => ByteString+  -> Expression schema '[] 'Ungrouped params (nullity json)+  -> NP (Aliased (TypeExpression schema)) record+  -> Query schema params record+unsafeRecordFunction fun expr types = UnsafeQuery $+  "SELECT * FROM " <> fun <> "("+    <> renderExpression expr <> ")"+    <+> "AS" <+> "x" <> parenthesized (renderCommaSeparated renderTy types)+    where+      renderTy :: Aliased (TypeExpression schema) ty -> ByteString+      renderTy (ty `As` alias) =+        renderAlias alias <+> renderTypeExpression ty --- | Builds an arbitrary record from a JSON object. As with all functions--- returning record, the caller must explicitly define the structure of the--- record with an AS clause.-jsonToRecordAs-  :: All Top types-  => Expression schema '[] 'Ungrouped params (nullity 'PGjson)-  -> Aliased (NP (Aliased (TypeExpression schema))) (tab ::: types)-  -> FromClause schema params '[tab ::: types]-jsonToRecordAs expr types =-  unsafeTableAliasedFromClauseExpression-  (unsafeFunction "json_to_record" expr)-  types+-- | Builds an arbitrary record from a JSON object.+jsonToRecord+  :: SListI record+  => Expression schema '[] 'Ungrouped params (nullity 'PGjson) -- ^ json object+  -> NP (Aliased (TypeExpression schema)) record -- ^ record types+  -> Query schema params record+jsonToRecord = unsafeRecordFunction "json_to_record" --- | Builds an arbitrary record from a binary JSON object. As with all functions--- returning record, the caller must explicitly define the structure of the--- record with an AS clause.-jsonbToRecordAs-  :: All Top types-  => Expression schema '[] 'Ungrouped params (nullity 'PGjsonb)-  -> Aliased (NP (Aliased (TypeExpression schema))) (tab ::: types)-  -> FromClause schema params '[tab ::: types]-jsonbToRecordAs expr types =-  unsafeTableAliasedFromClauseExpression-  (unsafeFunction "jsonb_to_record" expr)-  types+-- | Builds an arbitrary record from a binary JSON object.+jsonbToRecord+  :: SListI record+  => Expression schema '[] 'Ungrouped params (nullity 'PGjsonb) -- ^ jsonb object+  -> NP (Aliased (TypeExpression schema)) record -- ^ record types+  -> Query schema params record+jsonbToRecord = unsafeRecordFunction "jsonb_to_record" --- | Builds an arbitrary set of records from a JSON array of objects (see note--- below). As with all functions returning record, the caller must explicitly--- define the structure of the record with an AS clause.-jsonToRecordSetAs-  :: All Top types-  => Expression schema '[] 'Ungrouped params (nullity 'PGjson)-  -> Aliased (NP (Aliased (TypeExpression schema))) (tab ::: types)-  -> FromClause schema params '[tab ::: types]-jsonToRecordSetAs expr types =-  unsafeTableAliasedFromClauseExpression-  (unsafeFunction "json_to_recordset" expr)-  types+-- | Builds an arbitrary set of records from a JSON array of objects.+jsonToRecordSet+  :: SListI record+  => Expression schema '[] 'Ungrouped params (nullity 'PGjson) -- ^ json array+  -> NP (Aliased (TypeExpression schema)) record -- ^ record types+  -> Query schema params record+jsonToRecordSet = unsafeRecordFunction "json_to_record_set" --- | Builds an arbitrary set of records from a binary JSON array of objects (see--- note below). As with all functions returning record, the caller must--- explicitly define the structure of the record with an AS clause.-jsonbToRecordSetAs-  :: All Top types-  => Expression schema '[] 'Ungrouped params (nullity 'PGjsonb)-  -> Aliased (NP (Aliased (TypeExpression schema))) (tab ::: types)-  -> FromClause schema params '[tab ::: types]-jsonbToRecordSetAs expr types =-  unsafeTableAliasedFromClauseExpression-  (unsafeFunction "jsonb_to_recordset" expr)-  types+-- | Builds an arbitrary set of records from a binary JSON array of objects.+jsonbToRecordSet+  :: SListI record+  => Expression schema '[] 'Ungrouped params (nullity 'PGjsonb) -- ^ jsonb array+  -> NP (Aliased (TypeExpression schema)) record -- ^ record types+  -> Query schema params record+jsonbToRecordSet = unsafeRecordFunction "jsonb_to_record_set"  {----------------------------------------- FROM clauses@@ -835,7 +853,7 @@ A `FromClause` can be a table name, or a derived table such as a subquery, a @JOIN@ construct, or complex combinations of these. -}-newtype FromClause schema params relations+newtype FromClause schema params from   = UnsafeFromClause { renderFromClause :: ByteString }   deriving (GHC.Generic,Show,Eq,Ord,NFData) @@ -843,7 +861,7 @@ table   :: Has tab schema ('Table table)   => Aliased Alias (alias ::: tab)-  -> FromClause schema params '[alias ::: TableToRelation table]+  -> FromClause schema params '[alias ::: TableToRow table] table (tab `As` alias) = UnsafeFromClause $   renderAlias tab <+> "AS" <+> renderAlias alias @@ -855,9 +873,9 @@  -- | `view` derives a table from a `View`. view-  :: Has view schema ('View rel)+  :: Has view schema ('View row)   => Aliased Alias (alias ::: view)-  -> FromClause schema params '[alias ::: rel]+  -> FromClause schema params '[alias ::: row] view (vw `As` alias) = UnsafeFromClause $   renderAlias vw <+> "AS" <+> renderAlias alias @@ -903,7 +921,7 @@   -- ^ @on@ condition   -> FromClause schema params left   -- ^ left-  -> FromClause schema params (Join left (NullifyRelations right))+  -> FromClause schema params (Join left (NullifyFrom right)) leftOuterJoin right on left = UnsafeFromClause $   renderFromClause left <+> "LEFT OUTER JOIN" <+> renderFromClause right   <+> "ON" <+> renderExpression on@@ -921,7 +939,7 @@   -- ^ @on@ condition   -> FromClause schema params left   -- ^ left-  -> FromClause schema params (Join (NullifyRelations left) right)+  -> FromClause schema params (Join (NullifyFrom left) right) rightOuterJoin right on left = UnsafeFromClause $   renderFromClause left <+> "RIGHT OUTER JOIN" <+> renderFromClause right   <+> "ON" <+> renderExpression on@@ -941,7 +959,7 @@   -> FromClause schema params left   -- ^ left   -> FromClause schema params-      (Join (NullifyRelations left) (NullifyRelations right))+      (Join (NullifyFrom left) (NullifyFrom right)) fullOuterJoin right on left = UnsafeFromClause $   renderFromClause left <+> "FULL OUTER JOIN" <+> renderFromClause right   <+> "ON" <+> renderExpression on@@ -956,20 +974,20 @@ -- column @col@; otherwise @By2 (\#tab \! \#col)@ will reference a table -- qualified column @tab.col@. data By-    (relations :: RelationsType)+    (from :: FromType)     (by :: (Symbol,Symbol)) where     By1-      :: (HasUnique relation relations columns, Has column columns ty)+      :: (HasUnique table from columns, Has column columns ty)       => Alias column-      -> By relations '(relation, column)+      -> By from '(table, column)     By2-      :: (Has relation relations columns, Has column columns ty)-      => Alias relation+      :: (Has table from columns, Has column columns ty)+      => Alias table       -> Alias column-      -> By relations '(relation, column)-deriving instance Show (By relations by)-deriving instance Eq (By relations by)-deriving instance Ord (By relations by)+      -> By from '(table, column)+deriving instance Show (By from by)+deriving instance Eq (By from by)+deriving instance Ord (By from by)  instance (HasUnique rel rels cols, Has col cols ty, by ~ '(rel, col))   => IsLabel col (By rels by) where fromLabel = By1 fromLabel@@ -982,7 +1000,7 @@     rel ! col = By2 rel col :* Nil  -- | Renders a `By`.-renderBy :: By relations by -> ByteString+renderBy :: By from by -> ByteString renderBy = \case   By1 column -> renderAlias column   By2 rel column -> renderAlias rel <> "." <> renderAlias column@@ -993,15 +1011,15 @@ -- done on @NoGroups@ while all output `Expression`s must be aggregated -- in @Group Nil@. In general, all output `Expression`s in the -- complement of @bys@ must be aggregated in @Group bys@.-data GroupByClause relations grouping where-  NoGroups :: GroupByClause relations 'Ungrouped+data GroupByClause from grouping where+  NoGroups :: GroupByClause from 'Ungrouped   Group     :: SListI bys-    => NP (By relations) bys-    -> GroupByClause relations ('Grouped bys)+    => NP (By from) bys+    -> GroupByClause from ('Grouped bys)  -- | Renders a `GroupByClause`.-renderGroupByClause :: GroupByClause relations grouping -> ByteString+renderGroupByClause :: GroupByClause from grouping -> ByteString renderGroupByClause = \case   NoGroups -> ""   Group Nil -> ""@@ -1011,17 +1029,17 @@ -- An `Ungrouped` `TableExpression` may only use `NoHaving` while a `Grouped` -- `TableExpression` must use `Having` whose conditions are combined with -- `.&&`.-data HavingClause schema relations grouping params where-  NoHaving :: HavingClause schema relations 'Ungrouped params+data HavingClause schema from grouping params where+  NoHaving :: HavingClause schema from 'Ungrouped params   Having-    :: [Condition schema relations ('Grouped bys) params]-    -> HavingClause schema relations ('Grouped bys) params-deriving instance Show (HavingClause schema relations grouping params)-deriving instance Eq (HavingClause schema relations grouping params)-deriving instance Ord (HavingClause schema relations grouping params)+    :: [Condition schema from ('Grouped bys) params]+    -> HavingClause schema from ('Grouped bys) params+deriving instance Show (HavingClause schema from grouping params)+deriving instance Eq (HavingClause schema from grouping params)+deriving instance Ord (HavingClause schema from grouping params)  -- | Render a `HavingClause`.-renderHavingClause :: HavingClause schema relations grouping params -> ByteString+renderHavingClause :: HavingClause schema from grouping params -> ByteString renderHavingClause = \case   NoHaving -> ""   Having [] -> ""@@ -1040,29 +1058,29 @@ -- `AscNullsLast`, `DescNullsFirst` and `DescNullsLast` options are used to -- determine whether nulls appear before or after non-null values in the sort -- ordering of a `Null` result column.-data SortExpression schema relations grouping params where+data SortExpression schema from grouping params where     Asc-      :: Expression schema relations grouping params ('NotNull ty)-      -> SortExpression schema relations grouping params+      :: Expression schema from grouping params ('NotNull ty)+      -> SortExpression schema from grouping params     Desc-      :: Expression schema relations grouping params ('NotNull ty)-      -> SortExpression schema relations grouping params+      :: Expression schema from grouping params ('NotNull ty)+      -> SortExpression schema from grouping params     AscNullsFirst-      :: Expression schema relations grouping params  ('Null ty)-      -> SortExpression schema relations grouping params+      :: Expression schema from grouping params  ('Null ty)+      -> SortExpression schema from grouping params     AscNullsLast-      :: Expression schema relations grouping params  ('Null ty)-      -> SortExpression schema relations grouping params+      :: Expression schema from grouping params  ('Null ty)+      -> SortExpression schema from grouping params     DescNullsFirst-      :: Expression schema relations grouping params  ('Null ty)-      -> SortExpression schema relations grouping params+      :: Expression schema from grouping params  ('Null ty)+      -> SortExpression schema from grouping params     DescNullsLast-      :: Expression schema relations grouping params  ('Null ty)-      -> SortExpression schema relations grouping params-deriving instance Show (SortExpression schema relations grouping params)+      :: Expression schema from grouping params  ('Null ty)+      -> SortExpression schema from grouping params+deriving instance Show (SortExpression schema from grouping params)  -- | Render a `SortExpression`.-renderSortExpression :: SortExpression schema relations grouping params -> ByteString+renderSortExpression :: SortExpression schema from grouping params -> ByteString renderSortExpression = \case   Asc expression -> renderExpression expression <+> "ASC"   Desc expression -> renderExpression expression <+> "DESC"@@ -1072,3 +1090,326 @@     <+> "DESC NULLS FIRST"   AscNullsLast expression -> renderExpression expression <+> "ASC NULLS LAST"   DescNullsLast expression -> renderExpression expression <+> "DESC NULLS LAST"++unsafeSubqueryExpression+  :: ByteString+  -> Expression schema from grp params ty+  -> Query schema params '[alias ::: ty]+  -> Expression schema from grp params (nullity 'PGbool)+unsafeSubqueryExpression op x q = UnsafeExpression $+  renderExpression x <+> op <+> parenthesized (renderQuery q)++unsafeRowSubqueryExpression+  :: SListI row+  => ByteString+  -> NP (Aliased (Expression schema from grp params)) row+  -> Query schema params row+  -> Expression schema from grp params (nullity 'PGbool)+unsafeRowSubqueryExpression op xs q = UnsafeExpression $+  renderExpression (row xs) <+> op <+> parenthesized (renderQuery q)++-- | The right-hand side is a sub`Query`, which must return exactly one column.+-- The left-hand expression is evaluated and compared to each row of the+-- sub`Query` result. The result of `in_` is `true` if any equal subquery row is found.+-- The result is `false` if no equal row is found+-- (including the case where the subquery returns no rows).+--+-- >>> printSQL $ true `in_` values_ (true `as` #foo)+-- TRUE IN (SELECT * FROM (VALUES (TRUE)) AS t ("foo"))+in_+  :: Expression schema from grp params ty -- ^ expression+  -> Query schema params '[alias ::: ty] -- ^ subquery+  -> Expression schema from grp params (nullity 'PGbool)+in_ = unsafeSubqueryExpression "IN"++{- | The left-hand side of this form of `rowIn` is a row constructor.+The right-hand side is a sub`Query`,+which must return exactly as many columns as+there are expressions in the left-hand row.+The left-hand expressions are evaluated and compared row-wise to each row+of the subquery result. The result of `rowIn`+is `true` if any equal subquery row is found.+The result is `false` if no equal row is found+(including the case where the subquery returns no rows).++>>> let myRow = 1 `as` #foo :* false `as` #bar :: NP (Aliased (Expression '[] '[] 'Ungrouped '[])) '["foo" ::: 'NotNull 'PGint2, "bar" ::: 'NotNull 'PGbool]+>>> printSQL $ myRow `rowIn` values_ myRow+ROW(1, FALSE) IN (SELECT * FROM (VALUES (1, FALSE)) AS t ("foo", "bar"))+-}+rowIn+  :: SListI row+  => NP (Aliased (Expression schema from grp params)) row -- ^ row constructor+  -> Query schema params row -- ^ subquery+  -> Expression schema from grp params (nullity 'PGbool)+rowIn = unsafeRowSubqueryExpression "IN"++-- | >>> printSQL $ true `eqAll` values_ (true `as` #foo)+-- TRUE = ALL (SELECT * FROM (VALUES (TRUE)) AS t ("foo"))+eqAll+  :: Expression schema from grp params ty -- ^ expression+  -> Query schema params '[alias ::: ty] -- ^ subquery+  -> Expression schema from grp params (nullity 'PGbool)+eqAll = unsafeSubqueryExpression "= ALL"++-- | >>> let myRow = 1 `as` #foo :* false `as` #bar :: NP (Aliased (Expression '[] '[] 'Ungrouped '[])) '["foo" ::: 'NotNull 'PGint2, "bar" ::: 'NotNull 'PGbool]+-- >>> printSQL $ myRow `rowEqAll` values_ myRow+-- ROW(1, FALSE) = ALL (SELECT * FROM (VALUES (1, FALSE)) AS t ("foo", "bar"))+rowEqAll+  :: SListI row+  => NP (Aliased (Expression schema from grp params)) row -- ^ row constructor+  -> Query schema params row -- ^ subquery+  -> Expression schema from grp params (nullity 'PGbool)+rowEqAll = unsafeRowSubqueryExpression "= ALL"++-- | >>> printSQL $ true `eqAny` values_ (true `as` #foo)+-- TRUE = ANY (SELECT * FROM (VALUES (TRUE)) AS t ("foo"))+eqAny+  :: Expression schema from grp params ty -- ^ expression+  -> Query schema params '[alias ::: ty] -- ^ subquery+  -> Expression schema from grp params (nullity 'PGbool)+eqAny = unsafeSubqueryExpression "= ANY"++-- | >>> let myRow = 1 `as` #foo :* false `as` #bar :: NP (Aliased (Expression '[] '[] 'Ungrouped '[])) '["foo" ::: 'NotNull 'PGint2, "bar" ::: 'NotNull 'PGbool]+-- >>> printSQL $ myRow `rowEqAny` values_ myRow+-- ROW(1, FALSE) = ANY (SELECT * FROM (VALUES (1, FALSE)) AS t ("foo", "bar"))+rowEqAny+  :: SListI row+  => NP (Aliased (Expression schema from grp params)) row -- ^ row constructor+  -> Query schema params row -- ^ subquery+  -> Expression schema from grp params (nullity 'PGbool)+rowEqAny = unsafeRowSubqueryExpression "= ANY"++-- | >>> printSQL $ true `neqAll` values_ (true `as` #foo)+-- TRUE <> ALL (SELECT * FROM (VALUES (TRUE)) AS t ("foo"))+neqAll+  :: Expression schema from grp params ty -- ^ expression+  -> Query schema params '[alias ::: ty] -- ^ subquery+  -> Expression schema from grp params (nullity 'PGbool)+neqAll = unsafeSubqueryExpression "<> ALL"++-- | >>> let myRow = 1 `as` #foo :* false `as` #bar :: NP (Aliased (Expression '[] '[] 'Ungrouped '[])) '["foo" ::: 'NotNull 'PGint2, "bar" ::: 'NotNull 'PGbool]+-- >>> printSQL $ myRow `rowNeqAll` values_ myRow+-- ROW(1, FALSE) <> ALL (SELECT * FROM (VALUES (1, FALSE)) AS t ("foo", "bar"))+rowNeqAll+  :: SListI row+  => NP (Aliased (Expression schema from grp params)) row -- ^ row constructor+  -> Query schema params row -- ^ subquery+  -> Expression schema from grp params (nullity 'PGbool)+rowNeqAll = unsafeRowSubqueryExpression "<> ALL"++-- | >>> printSQL $ true `neqAny` values_ (true `as` #foo)+-- TRUE <> ANY (SELECT * FROM (VALUES (TRUE)) AS t ("foo"))+neqAny+  :: Expression schema from grp params ty -- ^ expression+  -> Query schema params '[alias ::: ty] -- ^ subquery+  -> Expression schema from grp params (nullity 'PGbool)+neqAny = unsafeSubqueryExpression "<> ANY"++-- | >>> let myRow = 1 `as` #foo :* false `as` #bar :: NP (Aliased (Expression '[] '[] 'Ungrouped '[])) '["foo" ::: 'NotNull 'PGint2, "bar" ::: 'NotNull 'PGbool]+-- >>> printSQL $ myRow `rowNeqAny` values_ myRow+-- ROW(1, FALSE) <> ANY (SELECT * FROM (VALUES (1, FALSE)) AS t ("foo", "bar"))+rowNeqAny+  :: SListI row+  => NP (Aliased (Expression schema from grp params)) row -- ^ row constructor+  -> Query schema params row -- ^ subquery+  -> Expression schema from grp params (nullity 'PGbool)+rowNeqAny = unsafeRowSubqueryExpression "<> ANY"++-- | >>> printSQL $ true `allLt` values_ (true `as` #foo)+-- TRUE ALL < (SELECT * FROM (VALUES (TRUE)) AS t ("foo"))+allLt+  :: Expression schema from grp params ty -- ^ expression+  -> Query schema params '[alias ::: ty] -- ^ subquery+  -> Expression schema from grp params (nullity 'PGbool)+allLt = unsafeSubqueryExpression "ALL <"++-- | >>> let myRow = 1 `as` #foo :* false `as` #bar :: NP (Aliased (Expression '[] '[] 'Ungrouped '[])) '["foo" ::: 'NotNull 'PGint2, "bar" ::: 'NotNull 'PGbool]+-- >>> printSQL $ myRow `rowLtAll` values_ myRow+-- ROW(1, FALSE) ALL < (SELECT * FROM (VALUES (1, FALSE)) AS t ("foo", "bar"))+rowLtAll+  :: SListI row+  => NP (Aliased (Expression schema from grp params)) row -- ^ row constructor+  -> Query schema params row -- ^ subquery+  -> Expression schema from grp params (nullity 'PGbool)+rowLtAll = unsafeRowSubqueryExpression "ALL <"++-- | >>> printSQL $ true `ltAny` values_ (true `as` #foo)+-- TRUE ANY < (SELECT * FROM (VALUES (TRUE)) AS t ("foo"))+ltAny+  :: Expression schema from grp params ty -- ^ expression+  -> Query schema params '[alias ::: ty] -- ^ subquery+  -> Expression schema from grp params (nullity 'PGbool)+ltAny = unsafeSubqueryExpression "ANY <"++-- | >>> let myRow = 1 `as` #foo :* false `as` #bar :: NP (Aliased (Expression '[] '[] 'Ungrouped '[])) '["foo" ::: 'NotNull 'PGint2, "bar" ::: 'NotNull 'PGbool]+-- >>> printSQL $ myRow `rowLtAll` values_ myRow+-- ROW(1, FALSE) ALL < (SELECT * FROM (VALUES (1, FALSE)) AS t ("foo", "bar"))+rowLtAny+  :: SListI row+  => NP (Aliased (Expression schema from grp params)) row -- ^ row constructor+  -> Query schema params row -- ^ subquery+  -> Expression schema from grp params (nullity 'PGbool)+rowLtAny = unsafeRowSubqueryExpression "ANY <"++-- | >>> printSQL $ true `lteAll` values_ (true `as` #foo)+-- TRUE <= ALL (SELECT * FROM (VALUES (TRUE)) AS t ("foo"))+lteAll+  :: Expression schema from grp params ty -- ^ expression+  -> Query schema params '[alias ::: ty] -- ^ subquery+  -> Expression schema from grp params (nullity 'PGbool)+lteAll = unsafeSubqueryExpression "<= ALL"++-- | >>> let myRow = 1 `as` #foo :* false `as` #bar :: NP (Aliased (Expression '[] '[] 'Ungrouped '[])) '["foo" ::: 'NotNull 'PGint2, "bar" ::: 'NotNull 'PGbool]+-- >>> printSQL $ myRow `rowLteAll` values_ myRow+-- ROW(1, FALSE) <= ALL (SELECT * FROM (VALUES (1, FALSE)) AS t ("foo", "bar"))+rowLteAll+  :: SListI row+  => NP (Aliased (Expression schema from grp params)) row -- ^ row constructor+  -> Query schema params row -- ^ subquery+  -> Expression schema from grp params (nullity 'PGbool)+rowLteAll = unsafeRowSubqueryExpression "<= ALL"++-- | >>> printSQL $ true `lteAny` values_ (true `as` #foo)+-- TRUE <= ANY (SELECT * FROM (VALUES (TRUE)) AS t ("foo"))+lteAny+  :: Expression schema from grp params ty -- ^ expression+  -> Query schema params '[alias ::: ty] -- ^ subquery+  -> Expression schema from grp params (nullity 'PGbool)+lteAny = unsafeSubqueryExpression "<= ANY"++-- | >>> let myRow = 1 `as` #foo :* false `as` #bar :: NP (Aliased (Expression '[] '[] 'Ungrouped '[])) '["foo" ::: 'NotNull 'PGint2, "bar" ::: 'NotNull 'PGbool]+-- >>> printSQL $ myRow `rowLteAny` values_ myRow+-- ROW(1, FALSE) <= ANY (SELECT * FROM (VALUES (1, FALSE)) AS t ("foo", "bar"))+rowLteAny+  :: SListI row+  => NP (Aliased (Expression schema from grp params)) row -- ^ row constructor+  -> Query schema params row -- ^ subquery+  -> Expression schema from grp params (nullity 'PGbool)+rowLteAny = unsafeRowSubqueryExpression "<= ANY"++-- | >>> printSQL $ true `gtAll` values_ (true `as` #foo)+-- TRUE > ALL (SELECT * FROM (VALUES (TRUE)) AS t ("foo"))+gtAll+  :: Expression schema from grp params ty -- ^ expression+  -> Query schema params '[alias ::: ty] -- ^ subquery+  -> Expression schema from grp params (nullity 'PGbool)+gtAll = unsafeSubqueryExpression "> ALL"++-- | >>> let myRow = 1 `as` #foo :* false `as` #bar :: NP (Aliased (Expression '[] '[] 'Ungrouped '[])) '["foo" ::: 'NotNull 'PGint2, "bar" ::: 'NotNull 'PGbool]+-- >>> printSQL $ myRow `rowGtAll` values_ myRow+-- ROW(1, FALSE) > ALL (SELECT * FROM (VALUES (1, FALSE)) AS t ("foo", "bar"))+rowGtAll+  :: SListI row+  => NP (Aliased (Expression schema from grp params)) row -- ^ row constructor+  -> Query schema params row -- ^ subquery+  -> Expression schema from grp params (nullity 'PGbool)+rowGtAll = unsafeRowSubqueryExpression "> ALL"++-- | >>> printSQL $ true `gtAny` values_ (true `as` #foo)+-- TRUE > ANY (SELECT * FROM (VALUES (TRUE)) AS t ("foo"))+gtAny+  :: Expression schema from grp params ty -- ^ expression+  -> Query schema params '[alias ::: ty] -- ^ subquery+  -> Expression schema from grp params (nullity 'PGbool)+gtAny = unsafeSubqueryExpression "> ANY"++-- | >>> let myRow = 1 `as` #foo :* false `as` #bar :: NP (Aliased (Expression '[] '[] 'Ungrouped '[])) '["foo" ::: 'NotNull 'PGint2, "bar" ::: 'NotNull 'PGbool]+-- >>> printSQL $ myRow `rowGtAny` values_ myRow+-- ROW(1, FALSE) > ANY (SELECT * FROM (VALUES (1, FALSE)) AS t ("foo", "bar"))+rowGtAny+  :: SListI row+  => NP (Aliased (Expression schema from grp params)) row -- ^ row constructor+  -> Query schema params row -- ^ subquery+  -> Expression schema from grp params (nullity 'PGbool)+rowGtAny = unsafeRowSubqueryExpression "> ANY"++-- | >>> printSQL $ true `gteAll` values_ (true `as` #foo)+-- TRUE >= ALL (SELECT * FROM (VALUES (TRUE)) AS t ("foo"))+gteAll+  :: Expression schema from grp params ty -- ^ expression+  -> Query schema params '[alias ::: ty] -- ^ subquery+  -> Expression schema from grp params (nullity 'PGbool)+gteAll = unsafeSubqueryExpression ">= ALL"++-- | >>> let myRow = 1 `as` #foo :* false `as` #bar :: NP (Aliased (Expression '[] '[] 'Ungrouped '[])) '["foo" ::: 'NotNull 'PGint2, "bar" ::: 'NotNull 'PGbool]+-- >>> printSQL $ myRow `rowGteAll` values_ myRow+-- ROW(1, FALSE) >= ALL (SELECT * FROM (VALUES (1, FALSE)) AS t ("foo", "bar"))+rowGteAll+  :: SListI row+  => NP (Aliased (Expression schema from grp params)) row -- ^ row constructor+  -> Query schema params row -- ^ subquery+  -> Expression schema from grp params (nullity 'PGbool)+rowGteAll = unsafeRowSubqueryExpression ">= ALL"++-- | >>> printSQL $ true `gteAny` values_ (true `as` #foo)+-- TRUE >= ANY (SELECT * FROM (VALUES (TRUE)) AS t ("foo"))+gteAny+  :: Expression schema from grp params ty -- ^ expression+  -> Query schema params '[alias ::: ty] -- ^ subquery+  -> Expression schema from grp params (nullity 'PGbool)+gteAny = unsafeSubqueryExpression ">= ANY"++-- | >>> let myRow = 1 `as` #foo :* false `as` #bar :: NP (Aliased (Expression '[] '[] 'Ungrouped '[])) '["foo" ::: 'NotNull 'PGint2, "bar" ::: 'NotNull 'PGbool]+-- >>> printSQL $ myRow `rowGteAny` values_ myRow+-- ROW(1, FALSE) >= ANY (SELECT * FROM (VALUES (1, FALSE)) AS t ("foo", "bar"))+rowGteAny+  :: SListI row+  => NP (Aliased (Expression schema from grp params)) row -- ^ row constructor+  -> Query schema params row -- ^ subquery+  -> Expression schema from grp params (nullity 'PGbool)+rowGteAny = unsafeRowSubqueryExpression ">= ANY"++-- | A `CommonTableExpression` is an auxiliary statement in a `with` clause.+data CommonTableExpression statement+  (params :: [NullityType])+  (schema0 :: SchemaType)+  (schema1 :: SchemaType) where+  CommonTableExpression+    :: Aliased (statement schema params) (alias ::: cte)+    -> CommonTableExpression+      statement params schema (alias ::: 'View cte ': schema)+instance (KnownSymbol alias, schema1 ~ (alias ::: 'View cte ': schema))+  => Aliasable alias+    (statement schema params cte)+    (CommonTableExpression statement params schema schema1) where+      statement `as` alias = CommonTableExpression (statement `as` alias)+instance (KnownSymbol alias, schema1 ~ (alias ::: 'View cte ': schema))+  => Aliasable alias (statement schema params cte)+    (AlignedList (CommonTableExpression statement params) schema schema1) where+      statement `as` alias = single (statement `as` alias)++-- | render a `CommonTableExpression`.+renderCommonTableExpression+  :: (forall sch ps row. statement ps sch row -> ByteString) -- ^ render statement+  -> CommonTableExpression statement params schema0 schema1 -> ByteString+renderCommonTableExpression renderStatement+  (CommonTableExpression (statement `As` alias)) =+    renderAlias alias <+> "AS" <+> parenthesized (renderStatement statement)++-- | render a non-empty `AlignedList` of `CommonTableExpression`s.+renderCommonTableExpressions+  :: (forall sch ps row. statement ps sch row -> ByteString) -- ^ render statement+  -> CommonTableExpression statement params schema0 schema1+  -> AlignedList (CommonTableExpression statement params) schema1 schema2+  -> ByteString+renderCommonTableExpressions renderStatement cte ctes =+  renderCommonTableExpression renderStatement cte <> case ctes of+    Done           -> ""+    cte' :>> ctes' -> "," <+>+      renderCommonTableExpressions renderStatement cte' ctes'++-- | `with` provides a way to write auxiliary statements for use in a larger query.+-- These statements, referred to as `CommonTableExpression`s, can be thought of as+-- defining temporary tables that exist just for one query.+class With statement where+  with+    :: AlignedList (CommonTableExpression statement params) schema0 schema1+    -- ^ common table expressions+    -> statement schema1 params row+    -- ^ larger query+    -> statement schema0 params row+instance With Query where+  with Done query = query+  with (cte :>> ctes) query = UnsafeQuery $+    "WITH" <+> renderCommonTableExpressions renderQuery cte ctes+      <+> renderQuery query

@@ -9,12 +9,14 @@ -}  {-# LANGUAGE-    FlexibleContexts+    AllowAmbiguousTypes+  , FlexibleContexts   , MagicHash   , OverloadedStrings   , PolyKinds   , RankNTypes   , ScopedTypeVariables+  , TypeApplications #-}  module Squeal.PostgreSQL.Render@@ -28,6 +30,7 @@   , renderCommaSeparated   , renderCommaSeparatedMaybe   , renderNat+  , renderSymbol   , RenderSQL (..)   , printSQL   ) where@@ -51,6 +54,7 @@  -- | Concatenate two `ByteString`s with a space between. (<+>) :: ByteString -> ByteString -> ByteString+infixr 7 <+> str1 <+> str2 = str1 <> " " <> str2  -- | Comma separate a list of `ByteString`s.@@ -92,8 +96,12 @@   . hmap (K . render)  -- | Render a promoted `Nat`.-renderNat :: KnownNat n => proxy n -> ByteString-renderNat (_ :: proxy n) = fromString (show (natVal' (proxy# :: Proxy# n)))+renderNat :: forall n. KnownNat n => ByteString+renderNat = fromString (show (natVal' (proxy# :: Proxy# n)))++-- | Render a promoted `Symbol`.+renderSymbol :: forall s. KnownSymbol s => ByteString+renderSymbol = fromString (symbolVal' (proxy# :: Proxy# s))  -- | A class for rendering SQL class RenderSQL sql where

@@ -20,6 +20,7 @@   , FlexibleInstances   , FunctionalDependencies   , GADTs+  , LambdaCase   , OverloadedStrings   , RankNTypes   , ScopedTypeVariables@@ -33,18 +34,24 @@ #-}  module Squeal.PostgreSQL.Schema-  ( -- * Types+  ( -- * Postgres Types     PGType (..)-  , HasOid (..)   , NullityType (..)+  , RowType+  , FromType+    -- * Haskell to Postgres Types+  , PG+  , NullPG+  , TuplePG+  , RowPG+  , Json (..)+  , Jsonb (..)+  , Composite (..)+  , Enumerated (..)+    -- * Schema Types   , ColumnType-    -- * Tables   , ColumnsType-  , RelationType-  , NilRelation-  , RelationsType   , TableType-    -- * Schema   , SchemumType (..)   , SchemaType     -- * Constraints@@ -52,7 +59,6 @@   , ColumnConstraint (..)   , TableConstraint (..)   , TableConstraints-  , NilTableConstraints   , Uniquely     -- * Aliases   , (:::)@@ -62,8 +68,6 @@   , Aliased (As)   , Aliasable (as)   , renderAliasedAs-  , AliasesOf-  , ZipAliased (..)   , Has   , HasUnique   , HasAll@@ -75,62 +79,48 @@   , PGlabel (..)   , renderLabel   , renderLabels+  , LabelsPG     -- * Grouping   , Grouping (..)   , GroupedBy-    -- * Type Families-  , Join-  , With+    -- * Aligned lists+  , AlignedList (..)+  , single+    -- * Data Definitions   , Create   , Drop   , Alter   , Rename+  , DropIfConstraintsInvolve+    -- * Lists+  , Join   , Elem   , In+  , Length+    -- * Type Classifications+  , HasOid (..)   , PGNum   , PGIntegral   , PGFloating   , PGTypeOf-  , PGarrayOf-  , PGarray-  , PGtextArray-  , SameTypes+  , PGArrayOf+  , PGArray+  , PGTextArray+  , PGJsonType+  , PGJsonKey   , SamePGType   , AllNotNull   , NotAllNull+    -- * Nullifications   , NullifyType-  , NullifyRelation-  , NullifyRelations-  , ColumnsToRelation+  , NullifyRow+  , NullifyFrom+    -- * Table Conversions   , TableToColumns-  , TableToRelation-  , RelationToRowType-  , RelationToNullityTypes-  , ConstraintInvolves-  , DropIfConstraintsInvolve-    -- ** JSON support-  , PGjson_-  , PGjsonKey-    -- * Embedding-  , PG-  , EnumFrom-  , LabelsFrom-  , CompositeFrom-  , FieldNamesFrom-  , FieldTypesFrom-  , ConstructorsOf-  , ConstructorNameOf-  , ConstructorNamesOf-  , FieldsOf-  , FieldNameOf-  , FieldNamesOf-  , FieldTypeOf-  , FieldTypesOf-  , RecordCodeOf-  , MapMaybes (..)-  , Nulls+  , TableToRow   ) where +import Control.Category import Control.DeepSeq import Data.Aeson (Value) import Data.ByteString (ByteString)@@ -144,10 +134,13 @@ import Data.Word (Word16, Word32, Word64) import Data.Type.Bool import Data.UUID.Types (UUID)+import Data.Vector (Vector) import Generics.SOP+import Generics.SOP.Record import GHC.OverloadedLabels import GHC.TypeLits import Network.IP.Addr+import Prelude hiding (id, (.))  import qualified Data.ByteString.Lazy as Lazy import qualified Data.Text.Lazy as Lazy@@ -183,10 +176,10 @@   | PGinet -- ^ IPv4 or IPv6 host address   | PGjson -- ^	textual JSON data   | PGjsonb -- ^ binary JSON data, decomposed-  | PGvararray PGType -- ^ variable length array-  | PGfixarray Nat PGType -- ^ fixed length array-  | PGenum [Symbol]-  | PGcomposite [(Symbol, PGType)]+  | PGvararray NullityType -- ^ variable length array+  | PGfixarray Nat NullityType -- ^ fixed length array+  | PGenum [Symbol] -- ^ enumerated (enum) types are data types that comprise a static, ordered set of values.+  | PGcomposite RowType -- ^ a composite type represents the structure of a row or record; it is essentially just a list of field names and their data types.   | UnsafePGType Symbol -- ^ an escape hatch for unsupported PostgreSQL types  -- | The object identifier of a `PGType`.@@ -283,9 +276,6 @@  -- | A `TableConstraints` is a row of `TableConstraint`s. type TableConstraints = [(Symbol,TableConstraint)]--- | A monokinded empty `TableConstraints`.-type family NilTableConstraints :: TableConstraints where-  NilTableConstraints = '[]  -- | A `ForeignKey` must reference columns that either are -- a `PrimaryKey` or form a `Unique` constraint.@@ -309,36 +299,39 @@ -- :} type TableType = (TableConstraints,ColumnsType) --- | `RelationType` is a row of `NullityType`------ >>> :{--- type family PersonRelation :: RelationType where---   PersonRelation =---     '[ "name"        ::: 'NotNull 'PGtext---      , "age"         ::: 'NotNull 'PGint4---      , "dateOfBirth" :::    'Null 'PGdate---      ]--- :}-type RelationType = [(Symbol,NullityType)]--- | A monokinded empty `RelationType`.-type family NilRelation :: RelationType where NilRelation = '[]+{- | A `RowType` is a row of `NullityType`. They correspond to Haskell+record types by means of `RowPG` and are used in many places. --- | `RelationsType` is a row of `RelationType`s, thought of as a product.-type RelationsType = [(Symbol,RelationType)]+>>> :{+type family PersonRow :: RowType where+  PersonRow =+    '[ "name"        ::: 'NotNull 'PGtext+     , "age"         ::: 'NotNull 'PGint4+     , "dateOfBirth" :::    'Null 'PGdate+     ]+:}+-}+type RowType = [(Symbol,NullityType)] --- | `ColumnsToRelation` removes column constraints.-type family ColumnsToRelation (columns :: ColumnsType) :: RelationType where-  ColumnsToRelation '[] = '[]-  ColumnsToRelation (column ::: constraint :=> ty ': columns) =-    column ::: ty ': ColumnsToRelation columns+{- | `FromType` is a row of `RowType`s. It can be thought of as+a product, or horizontal gluing and is used in `Squeal.PostgreSQL.Query.FromClause`s+and `Squeal.PostgreSQL.Query.TableExpression`s.+-}+type FromType = [(Symbol,RowType)] +-- | `ColumnsToRow` removes column constraints.+type family ColumnsToRow (columns :: ColumnsType) :: RowType where+  ColumnsToRow '[] = '[]+  ColumnsToRow (column ::: constraint :=> ty ': columns) =+    column ::: ty ': ColumnsToRow columns+ -- | `TableToColumns` removes table constraints. type family TableToColumns (table :: TableType) :: ColumnsType where   TableToColumns (constraints :=> columns) = columns --- | Convert a table to a relation.-type family TableToRelation (table :: TableType) :: RelationType where-  TableToRelation tab = ColumnsToRelation (TableToColumns tab)+-- | Convert a table to a row type.+type family TableToRow (table :: TableType) :: RowType where+  TableToRow tab = ColumnsToRow (TableToColumns tab)  -- | `Grouping` is an auxiliary namespace, created by -- @GROUP BY@ clauses (`Squeal.PostgreSQL.Query.group`), and used@@ -351,15 +344,15 @@ a member of the auxiliary namespace created by @GROUP BY@ clauses and thus, may be called in an output `Squeal.PostgreSQL.Expression.Expression` without aggregating. -}-class (KnownSymbol relation, KnownSymbol column)-  => GroupedBy relation column bys where-instance {-# OVERLAPPING #-} (KnownSymbol relation, KnownSymbol column)-  => GroupedBy relation column ('(table,column) ': bys)+class (KnownSymbol table, KnownSymbol column)+  => GroupedBy table column bys where+instance {-# OVERLAPPING #-} (KnownSymbol table, KnownSymbol column)+  => GroupedBy table column ('(table,column) ': bys) instance {-# OVERLAPPABLE #-}-  ( KnownSymbol relation+  ( KnownSymbol table   , KnownSymbol column-  , GroupedBy relation column bys-  ) => GroupedBy relation column (tabcol ': bys)+  , GroupedBy table column bys+  ) => GroupedBy table column (tabcol ': bys)  -- | `Alias`es are proxies for a type level string or `Symbol` -- and have an `IsLabel` instance so that with @-XOverloadedLabels@@@ -420,7 +413,7 @@   | aliased -> expression   , aliased -> alias   where as :: expression -> Alias alias -> aliased-instance (alias ~ alias1, KnownSymbol alias) => Aliasable alias+instance (KnownSymbol alias, alias ~ alias1) => Aliasable alias   (expression ty)   (Aliased expression (alias1 ::: ty))     where@@ -441,41 +434,6 @@ renderAliasedAs render (expression `As` alias) =   render expression <> " AS " <> renderAlias alias --- | `AliasesOf` retains the AliasesOf in a row.-type family AliasesOf aliaseds where-  AliasesOf '[] = '[]-  AliasesOf (alias ::: ty ': tys) = alias ': AliasesOf tys---- | The `ZipAliased` class provides a type family for zipping--- `Symbol` lists together with arbitrary lists of the same size,--- with an associated type family `ZipAs`, together with--- a method `zipAs` for zipping heterogeneous lists of `Alias`es--- together with a heterogeneous list of expressions into--- a heterogeneous list of `Aliased` expressions.-class-  ( SListI (ZipAs ns xs)-  , All KnownSymbol ns-  ) => ZipAliased ns xs where--  type family ZipAs-    (ns :: [Symbol]) (xs :: [k]) = (zs :: [(Symbol,k)]) | zs -> ns xs--  zipAs-    :: NP Alias ns-    -> NP expr xs-    -> NP (Aliased expr) (ZipAs ns xs)--instance ZipAliased '[] '[] where-  type ZipAs '[] '[] = '[]-  zipAs Nil Nil = Nil--instance-  ( KnownSymbol n-  , ZipAliased ns xs-  ) => ZipAliased (n ': ns) (x ': xs) where-  type ZipAs (n ': ns) (x ': xs) = '(n,x) ': ZipAs ns xs-  zipAs (n :* ns) (x :* xs) = x `As` n :* zipAs ns xs- -- | @HasUnique alias fields field@ is a constraint that proves that -- @fields@ is a singleton of @alias ::: field@. type HasUnique alias fields field = fields ~ '[alias ::: field]@@ -522,21 +480,15 @@ -- | @In x xs@ is a constraint that proves that @x@ is in @xs@. type family In x xs :: Constraint where In x xs = Elem x xs ~ 'True --- | `PGNum` is a constraint on `PGType` whose--- `Squeal.PostgreSQL.Expression.Expression`s have a `Num` constraint.-type PGNum ty =-  In ty '[ 'PGint2, 'PGint4, 'PGint8, 'PGnumeric, 'PGfloat4, 'PGfloat8]+-- | Numeric Postgres types.+type PGNum =+  '[ 'PGint2, 'PGint4, 'PGint8, 'PGnumeric, 'PGfloat4, 'PGfloat8] --- | `PGFloating` is a constraint on `PGType` whose--- `Squeal.PostgreSQL.Expression.Expression`s--- have `Fractional` and `Floating` constraints.-type PGFloating ty = In ty '[ 'PGfloat4, 'PGfloat8, 'PGnumeric]+-- | Floating Postgres types.+type PGFloating = '[ 'PGfloat4, 'PGfloat8, 'PGnumeric] --- | `PGIntegral` is a constraint on `PGType` whose--- `Squeal.PostgreSQL.Expression.Expression`s--- have `Squeal.PostgreSQL.Expression.div_` and--- `Squeal.PostgreSQL.Expression.mod_` functions.-type PGIntegral ty = In ty '[ 'PGint2, 'PGint4, 'PGint8]+-- | Integral Postgres types.+type PGIntegral = '[ 'PGint2, 'PGint4, 'PGint8]  -- | Error message helper for displaying unavailable\/unknown\/placeholder type -- variables whose kind is known.@@ -547,40 +499,32 @@ type ErrPGvararrayOf t = ErrArrayOf ('ShowType 'PGvararray) t  -- | Ensure a type is a valid array type.-type family PGarray name arr :: Constraint where-  PGarray name ('PGvararray x) = ()-  PGarray name ('PGfixarray n x) = ()-  PGarray name val = TypeError-    ('Text name :<>: 'Text ": Unsatisfied PGarray constraint. Expected either: "+type family PGArray name arr :: Constraint where+  PGArray name ('PGvararray x) = ()+  PGArray name ('PGfixarray n x) = ()+  PGArray name val = TypeError+    ('Text name :<>: 'Text ": Unsatisfied PGArray constraint. Expected either: "      :$$: 'Text " • " :<>: ErrPGvararrayOf (Placeholder PGType)      :$$: 'Text " • " :<>: ErrPGfixarrayOf (Placeholder PGType)      :$$: 'Text "But got: " :<>: 'ShowType val)  -- | Ensure a type is a valid array type with a specific element type.-type family PGarrayOf name arr ty :: Constraint where-  PGarrayOf name ('PGvararray x) ty = x ~ ty-  PGarrayOf name ('PGfixarray n x) ty = x ~ ty-  PGarrayOf name val ty = TypeError-    ( 'Text name :<>: 'Text "Unsatisfied PGarrayOf constraint. Expected either: "+type family PGArrayOf name arr ty :: Constraint where+  PGArrayOf name ('PGvararray x) ty = x ~ ty+  PGArrayOf name ('PGfixarray n x) ty = x ~ ty+  PGArrayOf name val ty = TypeError+    ( 'Text name :<>: 'Text "Unsatisfied PGArrayOf constraint. Expected either: "       :$$: 'Text " • " :<>: ErrPGvararrayOf ( 'ShowType ty )       :$$: 'Text " • " :<>: ErrPGfixarrayOf ( 'ShowType ty )       :$$: 'Text "But got: " :<>: 'ShowType val)  -- | Ensure a type is a valid array type whose elements are text.-type PGtextArray name arr = PGarrayOf name arr 'PGtext+type PGTextArray name arr = PGArrayOf name arr ('NotNull 'PGtext)  -- | `PGTypeOf` forgets about @NULL@ and any column constraints. type family PGTypeOf (ty :: NullityType) :: PGType where   PGTypeOf (nullity pg) = pg --- | `SameTypes` is a constraint that proves two `ColumnsType`s have the same--- length and the same `ColumnType`s.-type family SameTypes (columns0 :: ColumnsType) (columns1 :: ColumnsType)-  :: Constraint where-  SameTypes '[] '[] = ()-  SameTypes (column0 ::: def0 :=> ty0 ': columns0) (column1 ::: def1 :=> ty1 ': columns1)-    = (ty0 ~ ty1, SameTypes columns0 columns1)- -- | Equality constraint on the underlying `PGType` of two columns. class SamePGType   (ty0 :: (Symbol,ColumnType)) (ty1 :: (Symbol,ColumnType)) where@@ -599,34 +543,24 @@   NotAllNull (column ::: def :=> 'NotNull ty ': columns) = ()   NotAllNull (column ::: def :=> 'Null ty ': columns) = NotAllNull columns --- | `NullifyType` is an idempotent that nullifies a `ColumnType`.+-- | `NullifyType` is an idempotent that nullifies a `NullityType`. type family NullifyType (ty :: NullityType) :: NullityType where   NullifyType ('Null ty) = 'Null ty   NullifyType ('NotNull ty) = 'Null ty --- | `NullifyRelation` is an idempotent that nullifies a `ColumnsType`.-type family NullifyRelation (columns :: RelationType) :: RelationType where-  NullifyRelation '[] = '[]-  NullifyRelation (column ::: ty ': columns) =-    column ::: NullifyType ty ': NullifyRelation columns+-- | `NullifyRow` is an idempotent that nullifies a `RowType`.+type family NullifyRow (columns :: RowType) :: RowType where+  NullifyRow '[] = '[]+  NullifyRow (column ::: ty ': columns) =+    column ::: NullifyType ty ': NullifyRow columns --- | `NullifyRelations` is an idempotent that nullifies a `RelationsType`+-- | `NullifyFrom` is an idempotent that nullifies a `FromType` -- used to nullify the left or right hand side of an outer join -- in a `Squeal.PostgreSQL.Query.FromClause`.-type family NullifyRelations (tables :: RelationsType) :: RelationsType where-  NullifyRelations '[] = '[]-  NullifyRelations (table ::: columns ': tables) =-    table ::: NullifyRelation columns ': NullifyRelations tables---- | `RelationToRowType` drops the nullity constraints of its argument relations.-type family RelationToRowType (tables :: RelationType) :: [(Symbol, PGType)] where-  RelationToRowType (nullity x : xs) = x : RelationToRowType xs-  RelationToRowType '[] = '[]---- | `RelationToNullityTypes` drops the column constraints.-type family RelationToNullityTypes (rel :: RelationType) :: [NullityType] where-  RelationToNullityTypes ('(k, x) : xs) = x : RelationToNullityTypes xs-  RelationToNullityTypes '[]            = '[]+type family NullifyFrom (tables :: FromType) :: FromType where+  NullifyFrom '[] = '[]+  NullifyFrom (table ::: columns ': tables) =+    table ::: NullifyRow columns ': NullifyFrom tables  -- | `Join` is simply promoted `++` and is used in @JOIN@s in -- `Squeal.PostgreSQL.Query.FromClause`s.@@ -659,19 +593,6 @@   Alter alias x1 (alias ::: x0 ': xs) = alias ::: x1 ': xs   Alter alias x1 (x0 ': xs) = x0 ': Alter alias x1 xs --- type family AddConstraint constraint ty where---   AddConstraint constraint (constraints :=> ty)---     = AsSet (constraint ': constraints) :=> ty---- type family DeleteFromList (e :: elem) (list :: [elem]) where---   DeleteFromList elem '[] = '[]---   DeleteFromList elem (x ': xs) =---     If (Cmp elem x == 'EQ) xs (x ': DeleteFromList elem xs)---- type family DropConstraint constraint ty where---   DropConstraint constraint (constraints :=> ty)---     = (AsSet (DeleteFromList constraint constraints)) :=> ty- -- | @Rename alias0 alias1 xs@ replaces the alias @alias0@ by @alias1@ in @xs@ -- and is used in `Squeal.PostgreSQL.Definition.alterTableRename` and -- `Squeal.PostgreSQL.Definition.renameColumn`.@@ -679,26 +600,6 @@   Rename alias0 alias1 ((alias0 ::: x0) ': xs) = (alias1 ::: x0) ': xs   Rename alias0 alias1 (x ': xs) = x ': Rename alias0 alias1 xs --- | `MapMaybes` is used in the binary instances of composite types.-class MapMaybes xs where-  type family Maybes (xs :: [Type]) = (mxs :: [Type]) | mxs -> xs-  maybes :: NP Maybe xs -> NP I (Maybes xs)-  unMaybes :: NP I (Maybes xs) -> NP Maybe xs-instance MapMaybes '[] where-  type Maybes '[] = '[]-  maybes Nil = Nil-  unMaybes Nil = Nil-instance MapMaybes xs => MapMaybes (x ': xs) where-  type Maybes (x ': xs) = Maybe x ': Maybes xs-  maybes (x :* xs) = I x :* maybes xs-  unMaybes (I mx :* xs) = mx :* unMaybes xs---- | `Nulls` is used to construct a `Squeal.Postgresql.Expression.row`--- of a composite type.-type family Nulls tys where-  Nulls '[] = '[]-  Nulls (field ::: ty ': tys) = field ::: 'Null ty ': Nulls tys- -- | Check if a `TableConstraint` involves a column type family ConstraintInvolves column constraint where   ConstraintInvolves column ('Check columns) = column `Elem` columns@@ -715,25 +616,46 @@         (DropIfConstraintsInvolve column constraints)         (alias ::: constraint ': DropIfConstraintsInvolve column constraints) +{- | Calculate the `Length` of a type level list++>>> :kind! Length '[Char,String,Bool,Double]+Length '[Char,String,Bool,Double] :: Nat+= 4+-}+type family Length (xs :: [k]) :: Nat where+  Length (x : xs) = 1 + Length xs+  Length '[] = 0+ -- | A `SchemumType` is a user-defined type, either a `Table`, -- `View` or `Typedef`. data SchemumType   = Table TableType-  | View RelationType+  | View RowType   | Typedef PGType --- | The schema of a database consists of a list of aliased,--- user-defined `SchemumType`s.-type SchemaType = [(Symbol,SchemumType)]+{- | The schema of a database consists of a list of aliased,+user-defined `SchemumType`s. --- | Used in `Squeal.Postgresql.Manipulation.with`.-type family With-  (relations :: RelationsType)-  (schema :: SchemaType)-  :: SchemaType where-    With '[] schema = schema-    With (alias ::: rel ': rels) schema =-      alias ::: 'View rel ': With rels schema+>>> :{+type family Schema :: SchemaType where+  Schema =+    '[ "users" ::: 'Table (+        '[ "pk_users" ::: 'PrimaryKey '["id"] ] :=>+        '[ "id"   :::   'Def :=> 'NotNull 'PGint4+        , "name" ::: 'NoDef :=> 'NotNull 'PGtext+        ])+    , "emails" ::: 'Table (+        '[ "pk_emails"  ::: 'PrimaryKey '["id"]+        , "fk_user_id" ::: 'ForeignKey '["user_id"] "users" '["id"]+        ] :=>+        '[ "id"      :::   'Def :=> 'NotNull 'PGint4+        , "user_id" ::: 'NoDef :=> 'NotNull 'PGint4+        , "email"   ::: 'NoDef :=>    'Null 'PGtext+        ])+    ]+:}+-}+type SchemaType = [(Symbol,SchemumType)]  -- | `IsPGlabel` looks very much like the `IsLabel` class. Whereas -- the overloaded label, `fromLabel` is used for column references,@@ -749,105 +671,166 @@ -- | Renders a label renderLabel :: KnownSymbol label => proxy label -> ByteString renderLabel (_ :: proxy label) =-  "\'" <> fromString (symbolVal (Proxy @label)) <> "\'"+  "\'" <> renderSymbol @label <> "\'" -- | Renders a list of labels renderLabels   :: All KnownSymbol labels => NP PGlabel labels -> [ByteString] renderLabels = hcollapse   . hcmap (Proxy @KnownSymbol) (K . renderLabel) --- | The `PG` type family embeds a subset of Haskell types--- as Postgres basic types.------ >>> :kind! PG LocalTime--- PG LocalTime :: PGType--- = 'PGtimestamp-type family PG (hask :: Type) :: PGType where-  PG Bool = 'PGbool-  PG Int16 = 'PGint2-  PG Int32 = 'PGint4-  PG Int64 = 'PGint8-  PG Word16 = 'PGint2-  PG Word32 = 'PGint4-  PG Word64 = 'PGint8-  PG Scientific = 'PGnumeric-  PG Float = 'PGfloat4-  PG Double = 'PGfloat8-  PG Char = 'PGchar 1-  PG Text = 'PGtext-  PG Lazy.Text = 'PGtext-  PG ByteString = 'PGbytea-  PG Lazy.ByteString = 'PGbytea-  PG LocalTime = 'PGtimestamp-  PG UTCTime = 'PGtimestamptz-  PG Day = 'PGdate-  PG TimeOfDay = 'PGtime-  PG (TimeOfDay, TimeZone) = 'PGtimetz-  PG DiffTime = 'PGinterval-  PG UUID = 'PGuuid-  PG (NetAddr IP) = 'PGinet-  PG Value = 'PGjson-  PG ty = TypeError-    ('Text "There is no Postgres basic type for " ':<>: 'ShowType ty)+{- | The `PG` type family embeds a subset of Haskell types+as Postgres types. As an open type family, `PG` is extensible. --- | The `EnumFrom` type family embeds Haskell enum types, ADTs with--- nullary constructors, as Postgres enum types------ >>> data Schwarma = Beef | Lamb | Chicken deriving GHC.Generic--- >>> instance Generic Schwarma--- >>> instance HasDatatypeInfo Schwarma--- >>> :kind! EnumFrom Schwarma--- EnumFrom Schwarma :: PGType--- = 'PGenum '["Beef", "Lamb", "Chicken"]-type family EnumFrom (hask :: Type) :: PGType where-  EnumFrom hask = 'PGenum (LabelsFrom hask)+>>> :kind! PG LocalTime+PG LocalTime :: PGType+= 'PGtimestamp --- | The `LabelsFrom` type family calculates the constructors of a--- Haskell enum type.------ >>> data Schwarma = Beef | Lamb | Chicken deriving GHC.Generic--- >>> instance Generic Schwarma--- >>> instance HasDatatypeInfo Schwarma--- >>> :kind! LabelsFrom Schwarma--- LabelsFrom Schwarma :: [Type.ConstructorName]--- = '["Beef", "Lamb", "Chicken"]-type family LabelsFrom (hask :: Type) :: [Type.ConstructorName] where-  LabelsFrom hask =+>>> newtype MyDouble = My Double+>>> type instance PG MyDouble = 'PGfloat8+-}+type family PG (hask :: Type) :: PGType+type instance PG Bool = 'PGbool+type instance PG Int16 = 'PGint2+type instance PG Int32 = 'PGint4+type instance PG Int64 = 'PGint8+type instance PG Word16 = 'PGint2+type instance PG Word32 = 'PGint4+type instance PG Word64 = 'PGint8+type instance PG Scientific = 'PGnumeric+type instance PG Float = 'PGfloat4+type instance PG Double = 'PGfloat8+type instance PG Char = 'PGchar 1+type instance PG Text = 'PGtext+type instance PG Lazy.Text = 'PGtext+type instance PG String = 'PGtext+type instance PG ByteString = 'PGbytea+type instance PG Lazy.ByteString = 'PGbytea+type instance PG LocalTime = 'PGtimestamp+type instance PG UTCTime = 'PGtimestamptz+type instance PG Day = 'PGdate+type instance PG TimeOfDay = 'PGtime+type instance PG (TimeOfDay, TimeZone) = 'PGtimetz+type instance PG DiffTime = 'PGinterval+type instance PG UUID = 'PGuuid+type instance PG (NetAddr IP) = 'PGinet+type instance PG Value = 'PGjson+type instance PG (Json hask) = 'PGjson+type instance PG (Jsonb hask) = 'PGjsonb+type instance PG (Vector hask) = 'PGvararray (NullPG hask)+type instance PG (hask, hask) = 'PGfixarray 2 (NullPG hask)+type instance PG (hask, hask, hask) = 'PGfixarray 3 (NullPG hask)+type instance PG (hask, hask, hask, hask) = 'PGfixarray 4 (NullPG hask)+type instance PG (hask, hask, hask, hask, hask) = 'PGfixarray 5 (NullPG hask)+type instance PG (hask, hask, hask, hask, hask, hask)+  = 'PGfixarray 6 (NullPG hask)+type instance PG (hask, hask, hask, hask, hask, hask, hask)+  = 'PGfixarray 7 (NullPG hask)+type instance PG (hask, hask, hask, hask, hask, hask, hask, hask)+  = 'PGfixarray 8 (NullPG hask)+type instance PG (hask, hask, hask, hask, hask, hask, hask, hask, hask)+  = 'PGfixarray 9 (NullPG hask)+type instance PG (hask, hask, hask, hask, hask, hask, hask, hask, hask, hask)+  = 'PGfixarray 10 (NullPG hask)+type instance PG (Composite hask) = 'PGcomposite (RowPG hask)+type instance PG (Enumerated hask) = 'PGenum (LabelsPG hask)++{- | The `Json` newtype is an indication that the Haskell+type it's applied to should be stored as `PGjson`.+-}+newtype Json hask = Json {getJson :: hask}+  deriving (Eq, Ord, Show, Read, GHC.Generic)++{- | The `Jsonb` newtype is an indication that the Haskell+type it's applied to should be stored as `PGjsonb`.+-}+newtype Jsonb hask = Jsonb {getJsonb :: hask}+  deriving (Eq, Ord, Show, Read, GHC.Generic)++{- | The `Composite` newtype is an indication that the Haskell+type it's applied to should be stored as a `PGcomposite`.+-}+newtype Composite record = Composite {getComposite :: record}+  deriving (Eq, Ord, Show, Read, GHC.Generic)++{- | The `Enumerated` newtype is an indication that the Haskell+type it's applied to should be stored as `PGenum`.+-}+newtype Enumerated enum = Enumerated {getEnumerated :: enum}+  deriving (Eq, Ord, Show, Read, GHC.Generic)++{-| The `LabelsPG` type family calculates the constructors of a+Haskell enum type.++>>> data Schwarma = Beef | Lamb | Chicken deriving GHC.Generic+>>> instance Generic Schwarma+>>> instance HasDatatypeInfo Schwarma+>>> :kind! LabelsPG Schwarma+LabelsPG Schwarma :: [Type.ConstructorName]+= '["Beef", "Lamb", "Chicken"]+-}+type family LabelsPG (hask :: Type) :: [Type.ConstructorName] where+  LabelsPG hask =     ConstructorNamesOf (ConstructorsOf (DatatypeInfoOf hask)) --- | The `CompositeFrom` type family embeds Haskell record types as--- Postgres composite types, as long as the record fields--- are `Maybe`s of Haskell types that can be embedded as basic types--- with the `PG` type family.------ >>> data Row = Row { a :: Maybe Int16, b :: Maybe LocalTime } deriving GHC.Generic--- >>> instance Generic Row--- >>> instance HasDatatypeInfo Row--- >>> :kind! CompositeFrom Row--- CompositeFrom Row :: PGType--- = 'PGcomposite '['("a", 'PGint2), '("b", 'PGtimestamp)]-type family CompositeFrom (hask :: Type) :: PGType where-  CompositeFrom hask =-    'PGcomposite (ZipAs (FieldNamesFrom hask) (FieldTypesFrom hask))+{- | `RowPG` turns a Haskell record type into a `RowType`. --- | >>> data Row = Row { a :: Maybe Int16, b :: Maybe LocalTime } deriving GHC.Generic--- >>> instance Generic Row--- >>> instance HasDatatypeInfo Row--- >>> :kind! FieldNamesFrom Row--- FieldNamesFrom Row :: [Type.FieldName]--- = '["a", "b"]-type family FieldNamesFrom (hask :: Type) :: [Type.FieldName] where-  FieldNamesFrom hask = FieldNamesOf (FieldsOf (DatatypeInfoOf hask))+>>> data Person = Person { name :: Text, age :: Int32 } deriving GHC.Generic+>>> instance Generic Person+>>> instance HasDatatypeInfo Person+>>> :kind! RowPG Person+RowPG Person :: [(Symbol, NullityType)]+= '["name" ::: 'NotNull 'PGtext, "age" ::: 'NotNull 'PGint4]+-}+type family RowPG (hask :: Type) :: RowType where+  RowPG hask = RowOf (RecordCodeOf hask) --- | >>> data Row = Row { a :: Maybe Int16, b :: Maybe LocalTime } deriving GHC.Generic--- >>> instance Generic Row--- >>> instance HasDatatypeInfo Row--- >>> :kind! FieldTypesFrom Row--- FieldTypesFrom Row :: [PGType]--- = '['PGint2, 'PGtimestamp]-type family FieldTypesFrom (hask :: Type) :: [PGType] where-  FieldTypesFrom hask = FieldTypesOf (RecordCodeOf hask (Code hask))+type family RowOf (fields :: [(Symbol, Type)]) :: RowType where+  RowOf '[] = '[]+  RowOf (field ': fields) = FieldPG field ': RowOf fields +type family FieldPG (field :: (Symbol, Type)) :: (Symbol, NullityType) where+  FieldPG (field ::: hask) = field ::: NullPG hask++{- | `NullPG` turns a Haskell type into a `NullityType`.++>>> :kind! NullPG Double+NullPG Double :: NullityType+= 'NotNull 'PGfloat8+>>> :kind! NullPG (Maybe Double)+NullPG (Maybe Double) :: NullityType+= 'Null 'PGfloat8+-}+type family NullPG (hask :: Type) :: NullityType where+  NullPG (Maybe hask) = 'Null (PG hask)+  NullPG hask = 'NotNull (PG hask)++{- | `TuplePG` turns a Haskell tuple type (including record types) into+the corresponding list of `NullityType`s.++>>> :kind! TuplePG (Double, Maybe Char)+TuplePG (Double, Maybe Char) :: [NullityType]+= '['NotNull 'PGfloat8, 'Null ('PGchar 1)]+-}+type family TuplePG (hask :: Type) :: [NullityType] where+  TuplePG hask = TupleOf (TupleCodeOf hask (Code hask))++type family TupleOf (tuple :: [Type]) :: [NullityType] where+  TupleOf '[] = '[]+  TupleOf (hask ': tuple) = NullPG hask ': TupleOf tuple++type family TupleCodeOf (hask :: Type) (code :: [[Type]]) :: [Type] where+  TupleCodeOf hask '[tuple] = tuple+  TupleCodeOf hask '[] =+    TypeError+      (    'Text "The type `" :<>: 'ShowType hask :<>: 'Text "' is not a tuple type."+      :$$: 'Text "It is a void type with no constructors."+      )+  TupleCodeOf hask (_ ': _ ': _) =+    TypeError+      (    'Text "The type `" :<>: 'ShowType hask :<>: 'Text "' is not a tuple type."+      :$$: 'Text "It is a sum type with more than one constructor."+      )+ -- | Calculates constructors of a datatype. type family ConstructorsOf (datatype :: Type.DatatypeInfo)   :: [Type.ConstructorInfo] where@@ -875,47 +858,23 @@     ConstructorNamesOf (constructor ': constructors) =       ConstructorNameOf constructor ': ConstructorNamesOf constructors --- | Calculate the fields of a datatype.-type family FieldsOf (datatype :: Type.DatatypeInfo)-  :: [Type.FieldInfo] where-    FieldsOf ('Type.ADT _module _datatype '[ 'Type.Record _name fields]) =-      fields-    FieldsOf ('Type.Newtype _module _datatype ('Type.Record _name fields)) =-      fields---- | Calculate the name of a field.-type family FieldNameOf (field :: Type.FieldInfo) :: Type.FieldName where-  FieldNameOf ('Type.FieldInfo name) = name---- | Calculate the names of fields.-type family FieldNamesOf (fields :: [Type.FieldInfo])-  :: [Type.FieldName] where-    FieldNamesOf '[] = '[]-    FieldNamesOf (field ': fields) = FieldNameOf field ': FieldNamesOf fields---- | >>> :kind! FieldTypeOf (Maybe Int16)--- FieldTypeOf (Maybe Int16) :: PGType--- = 'PGint2-type family FieldTypeOf (maybe :: Type) where-  FieldTypeOf (Maybe hask) = PG hask-  FieldTypeOf ty = TypeError-    ('Text "FieldTypeOf error: non-Maybe type " ':<>: 'ShowType ty)---- | Calculate the types of fields.-type family FieldTypesOf (fields :: [Type]) where-  FieldTypesOf '[] = '[]-  FieldTypesOf (field ': fields) = FieldTypeOf field ': FieldTypesOf fields---- | Inspect the code of an algebraic datatype and ensure it's a product,--- otherwise generate a type error-type family RecordCodeOf (hask :: Type) (code ::[[Type]]) :: [Type] where-  RecordCodeOf _hask '[tys] = tys-  RecordCodeOf hask _tys = TypeError-    ('Text "RecordCodeOf error: non-Record type " ':<>: 'ShowType hask)- -- | Is a type a valid JSON key?-type PGjsonKey key = key `In` '[ 'PGint2, 'PGint4, 'PGtext ]+type PGJsonKey = '[ 'PGint2, 'PGint4, 'PGtext ]  -- | Is a type a valid JSON type?-type PGjson_ json = json `In` '[ 'PGjson, 'PGjsonb ]+type PGJsonType = '[ 'PGjson, 'PGjsonb ] +-- | An `AlignedList` is a type-aligned list or free category.+data AlignedList p x0 x1 where+  Done :: AlignedList p x x+  (:>>) :: p x0 x1 -> AlignedList p x1 x2 -> AlignedList p x0 x2+infixr 7 :>>+instance Category (AlignedList p) where+  id = Done+  (.) list = \case+    Done -> list+    step :>> steps -> step :>> (steps >>> list)++-- | A `single` step.+single :: p x0 x1 -> AlignedList p x0 x1+single step = step :>> Done

@@ -9,9 +9,11 @@ -}  {-# LANGUAGE-    FlexibleContexts+    DataKinds+  , FlexibleContexts   , LambdaCase   , OverloadedStrings+  , TypeInType #-}  module Squeal.PostgreSQL.Transaction@@ -39,7 +41,6 @@ import Control.Monad.Base import Control.Monad.Trans.Control import Data.ByteString-import Data.Monoid import Generics.SOP  import qualified Database.PostgreSQL.LibPQ as LibPQ@@ -69,16 +70,16 @@ transactionally_ = transactionally defaultMode  -- | @BEGIN@ a transaction.-begin :: MonadPQ schema tx => TransactionMode -> tx (K Result NilRelation)+begin :: MonadPQ schema tx => TransactionMode -> tx (K Result ('[] :: RowType)) begin mode = manipulate . UnsafeManipulation $   "BEGIN" <+> renderTransactionMode mode <> ";"  -- | @COMMIT@ a schema invariant transaction.-commit :: MonadPQ schema tx => tx (K Result NilRelation)+commit :: MonadPQ schema tx => tx (K Result ('[] :: RowType)) commit = manipulate $ UnsafeManipulation "COMMIT;"  -- | @ROLLBACK@ a schema invariant transaction.-rollback :: MonadPQ schema tx => tx (K Result NilRelation)+rollback :: MonadPQ schema tx => tx (K Result ('[] :: RowType)) rollback = manipulate $ UnsafeManipulation "ROLLBACK;"  -- | Run a schema changing computation `transactionallySchema`.

@@ -0,0 +1,121 @@+{-# LANGUAGE DataKinds             #-}+{-# LANGUAGE DeriveGeneric         #-}+{-# LANGUAGE DuplicateRecordFields #-}+{-# LANGUAGE FlexibleContexts      #-}+{-# LANGUAGE OverloadedLabels      #-}+{-# LANGUAGE OverloadedLists       #-}+{-# LANGUAGE OverloadedStrings     #-}+{-# LANGUAGE TypeApplications      #-}+{-# LANGUAGE TypeFamilies          #-}+{-# LANGUAGE TypeOperators         #-}+module ExceptionHandling+  ( specs+  , User (..)+  )+where++import           Control.Monad               (void)+import           Control.Monad.Base          (MonadBase)+import qualified Data.ByteString.Char8       as Char8+import           Data.Int                    (Int16)+import           Data.Text                   (Text)+import           Data.Vector                 (Vector)+import qualified Generics.SOP                as SOP+import qualified GHC.Generics                as GHC+import           Squeal.PostgreSQL+import           Squeal.PostgreSQL.Migration+import           Test.Hspec++type Schema =+  '[ "users" ::: 'Table (+       '[ "pk_users" ::: 'PrimaryKey '["id"]+        , "unique_names" ::: 'Unique '["name"]+        ] :=>+       '[ "id" ::: 'Def :=> 'NotNull 'PGint4+        , "name" ::: 'NoDef :=> 'NotNull 'PGtext+        , "vec" ::: 'NoDef :=> 'NotNull ('PGvararray ('Null 'PGint2))+        ])+   , "emails" ::: 'Table (+       '[  "pk_emails" ::: 'PrimaryKey '["id"]+        , "fk_user_id" ::: 'ForeignKey '["user_id"] "users" '["id"]+        ] :=>+       '[ "id" ::: 'Def :=> 'NotNull 'PGint4+        , "user_id" ::: 'NoDef :=> 'NotNull 'PGint4+        , "email" ::: 'NoDef :=> 'Null 'PGtext+        ])+   ]++data User =+  User { userName  :: Text+       , userEmail :: Maybe Text+       , userVec   :: Vector (Maybe Int16) }+  deriving (Show, GHC.Generic)+instance SOP.Generic User+instance SOP.HasDatatypeInfo User++insertUser :: Manipulation Schema '[ 'NotNull 'PGtext, 'NotNull ('PGvararray ('Null 'PGint2))]+  '[ "fromOnly" ::: 'NotNull 'PGint4 ]+insertUser = insertRows #users+  (Default `as` #id :* Set (param @1) `as` #name :* Set (param @2) `as` #vec) []+  OnConflictDoRaise (Returning (#id `as` #fromOnly))++setup :: Definition '[] Schema+setup =+  createTable #users+    ( serial `as` #id :*+      (text & notNullable) `as` #name :*+      (vararray int2 & notNullable) `as` #vec )+    ( primaryKey #id `as` #pk_users+    :* unique #name `as` #unique_names )+  >>>+  createTable #emails+    ( serial `as` #id :*+      (int & notNullable) `as` #user_id :*+      (text & nullable) `as` #email )+    ( primaryKey #id `as` #pk_emails :*+      foreignKey #user_id #users #id+        OnDeleteCascade OnUpdateCascade `as` #fk_user_id )++teardown :: Definition Schema '[]+teardown = dropTable #emails >>> dropTable #users++migration :: Migration IO '[] Schema+migration = Migration { name = "test"+                      , up = void $ define setup+                      , down = void $ define teardown }++setupDB :: IO ()+setupDB = void . withConnection connectionString $+  migrateUp $ single migration++dropDB :: IO ()+dropDB = void . withConnection connectionString $+  migrateDown $ single migration++connectionString :: Char8.ByteString+connectionString = "host=localhost port=5432 dbname=exampledb"++testUser :: User+testUser = User "TestUser" Nothing []++newUser :: (MonadBase IO m, MonadPQ Schema m) => User -> m ()+newUser u = void $ manipulateParams insertUser (userName u, userVec u)++insertUserTwice :: (MonadBase IO m, MonadPQ Schema m) => m ()+insertUserTwice = newUser testUser >> newUser testUser++specs :: SpecWith ()+specs = before_ setupDB $ after_ dropDB $+  describe "Exceptions" $ do++    let+      dupKeyErr = PQException FatalError (Just "23505")+        (Just "ERROR:  duplicate key value violates unique constraint \"unique_names\"\nDETAIL:  Key (name)=(TestUser) already exists.\n")++    it "should be thrown for unique constraint violation in a manipulation" $+      withConnection connectionString insertUserTwice+       `shouldThrow` (== dupKeyErr)++    it "should be rethrown for unique constraint violation in a manipulation by a transaction" $+      withConnection connectionString (transactionally_ insertUserTwice)+       `shouldThrow` (== dupKeyErr)

@@ -0,0 +1,7 @@+module Specs where++import           Test.Hspec+import qualified ExceptionHandling++main :: IO ()+main = hspec ExceptionHandling.specs