-- Hoogle documentation, generated by Haddock
-- See Hoogle, http://www.haskell.org/hoogle/


-- | Squeal PostgreSQL Library
--   
--   Squeal is a type-safe embedding of PostgreSQL in Haskell
@package squeal-postgresql
@version 0.5.1.0


-- | Rendering helper functions.
module Squeal.PostgreSQL.Render

-- | A class for rendering SQL
class RenderSQL sql
renderSQL :: RenderSQL sql => sql -> ByteString

-- | Print SQL.
printSQL :: (RenderSQL sql, MonadIO io) => sql -> io ()

-- | <a>escape</a> a character to prevent injection
escape :: Char -> String

-- | Parenthesize a <a>ByteString</a>.
parenthesized :: ByteString -> ByteString

-- | Square bracket a <a>ByteString</a>
bracketed :: ByteString -> ByteString

-- | Concatenate two <a>ByteString</a>s with a space between.
(<+>) :: ByteString -> ByteString -> ByteString
infixr 7 <+>

-- | Comma separate a list of <a>ByteString</a>s.
commaSeparated :: [ByteString] -> ByteString

-- | Add double quotes around a <a>ByteString</a>.
doubleQuoted :: ByteString -> ByteString

-- | Add single quotes around a <a>Text</a> and escape single quotes within
--   it.
singleQuotedText :: Text -> ByteString

-- | Add single quotes around a <a>ByteString</a> and escape single quotes
--   within it.
singleQuotedUtf8 :: ByteString -> ByteString

-- | Comma separate the renderings of a heterogeneous list.
renderCommaSeparated :: SListI xs => (forall x. expression x -> ByteString) -> NP expression xs -> ByteString

-- | Comma separate the renderings of a heterogeneous list.
renderCommaSeparatedConstraint :: forall c xs expression. (All c xs, SListI xs) => (forall x. c x => expression x -> ByteString) -> NP expression xs -> ByteString

-- | Comma separate the <a>Maybe</a> renderings of a heterogeneous list,
--   dropping <a>Nothing</a>s.
renderCommaSeparatedMaybe :: SListI xs => (forall x. expression x -> Maybe ByteString) -> NP expression xs -> ByteString

-- | Render a promoted <a>Nat</a>.
renderNat :: forall n. KnownNat n => ByteString

-- | Render a promoted <a>Symbol</a>.
renderSymbol :: forall s. KnownSymbol s => ByteString


-- | Haskell singly-linked lists are very powerful. This module provides
--   functionality for type-level lists, heterogeneous lists and type
--   aligned lists.
module Squeal.PostgreSQL.List

-- | An n-ary product.
--   
--   The product is parameterized by a type constructor <tt>f</tt> and
--   indexed by a type-level list <tt>xs</tt>. The length of the list
--   determines the number of elements in the product, and if the
--   <tt>i</tt>-th element of the list is of type <tt>x</tt>, then the
--   <tt>i</tt>-th element of the product is of type <tt>f x</tt>.
--   
--   The constructor names are chosen to resemble the names of the list
--   constructors.
--   
--   Two common instantiations of <tt>f</tt> are the identity functor
--   <a>I</a> and the constant functor <a>K</a>. For <a>I</a>, the product
--   becomes a heterogeneous list, where the type-level list describes the
--   types of its components. For <tt><a>K</a> a</tt>, the product becomes
--   a homogeneous list, where the contents of the type-level list are
--   ignored, but its length still specifies the number of elements.
--   
--   In the context of the SOP approach to generic programming, an n-ary
--   product describes the structure of the arguments of a single data
--   constructor.
--   
--   <i>Examples:</i>
--   
--   <pre>
--   I 'x'    :* I True  :* Nil  ::  NP I       '[ Char, Bool ]
--   K 0      :* K 1     :* Nil  ::  NP (K Int) '[ Char, Bool ]
--   Just 'x' :* Nothing :* Nil  ::  NP Maybe   '[ Char, Bool ]
--   </pre>
data NP (a :: k -> Type) (b :: [k]) :: forall k. () => k -> Type -> [k] -> Type
[Nil] :: forall k (a :: k -> Type) (b :: [k]). () => NP a ([] :: [k])
[:*] :: forall k (a :: k -> Type) (b :: [k]) (x :: k) (xs :: [k]). () => a x -> NP a xs -> NP a (x : xs)
infixr 5 :*

-- | A useful operator for ending an <a>NP</a> list of length at least 2
--   without <a>Nil</a>.
(*:) :: f x -> f y -> NP f '[x, y]
infixl 9 *:

-- | <a>Join</a> is simply promoted <a>++</a> and is used in <tt>JOIN</tt>s
--   in <a>FromClause</a>s.
type family Join xs ys

-- | <a>disjoin</a> is a utility function for splitting an <a>NP</a> list
--   into pieces.
disjoin :: forall xs ys expr. SListI xs => NP expr (Join xs ys) -> (NP expr xs, NP expr ys)

-- | The <a>Additional</a> class is for appending type-level list
--   parameterized constructors such as <a>NP</a>, <a>Selection</a>, and
--   <a>FromClause</a>.
class Additional expr
also :: Additional expr => expr ys -> expr xs -> expr (Join xs ys)

-- | An <a>AlignedList</a> is a type-aligned list or free category.
data AlignedList p x0 x1
[Done] :: AlignedList p x x
[:>>] :: p x0 x1 -> AlignedList p x1 x2 -> AlignedList p x0 x2
infixr 7 :>>

-- | A <a>single</a> step.
single :: p x0 x1 -> AlignedList p x0 x1

-- | <a>extractList</a> turns an <a>AlignedList</a> into a standard list.
extractList :: (forall a0 a1. p a0 a1 -> b) -> AlignedList p x0 x1 -> [b]

-- | <a>mapAligned</a> applies a function to each element of an
--   <a>AlignedList</a>.
mapAligned :: (forall z0 z1. p z0 z1 -> q z0 z1) -> AlignedList p x0 x1 -> AlignedList q x0 x1

-- | <tt>Elem</tt> is a promoted <a>elem</a>.
type family Elem x xs

-- | <tt>In x xs</tt> is a constraint that proves that <tt>x</tt> is in
--   <tt>xs</tt>.
type family In x xs :: Constraint

-- | Calculate the <a>Length</a> of a type level list
--   
--   <pre>
--   &gt;&gt;&gt; :kind! Length '[Char,String,Bool,Double]
--   Length '[Char,String,Bool,Double] :: Nat
--   = 4
--   </pre>
type family Length (xs :: [k]) :: Nat
instance forall k (p :: k -> k -> *). Control.Category.Category (Squeal.PostgreSQL.List.AlignedList p)
instance forall k (p :: k -> k -> *) (x0 :: k) (x1 :: k). (forall (t0 :: k) (t1 :: k). Squeal.PostgreSQL.Render.RenderSQL (p t0 t1)) => Squeal.PostgreSQL.Render.RenderSQL (Squeal.PostgreSQL.List.AlignedList p x0 x1)
instance forall a (expr :: a -> *). Squeal.PostgreSQL.List.Additional (Data.SOP.NP.NP expr)


-- | This module embeds Postgres's alias system in Haskell in a typesafe
--   fashion. Thanks to GHC's <tt>OverloadedLabels</tt> extension, Squeal
--   can reference aliases by prepending with a <tt>#</tt>.
module Squeal.PostgreSQL.Alias

-- | The alias operator <a>:::</a> is like a promoted version of <a>As</a>,
--   a type level pair between an alias and some type.
type (:::) (alias :: Symbol) ty = '(alias, ty)
infixr 6 :::

-- | <a>Alias</a>es are proxies for a type level string or <a>Symbol</a>
--   and have an <a>IsLabel</a> instance so that with
--   <tt>-XOverloadedLabels</tt>
--   
--   <pre>
--   &gt;&gt;&gt; :set -XOverloadedLabels
--   
--   &gt;&gt;&gt; #foobar :: Alias "foobar"
--   Alias
--   </pre>
data Alias (alias :: Symbol)
Alias :: Alias
class IsLabel (x :: Symbol) a
fromLabel :: IsLabel x a => a

-- | The <a>As</a> operator is used to name an expression. <a>As</a> is
--   like a demoted version of <a>:::</a>.
--   
--   <pre>
--   &gt;&gt;&gt; Just "hello" `As` #hi :: Aliased Maybe ("hi" ::: String)
--   As (Just "hello") Alias
--   </pre>
data Aliased expression aliased
[As] :: KnownSymbol alias => expression ty -> Alias alias -> Aliased expression (alias ::: ty)

-- | The <a>Aliasable</a> class provides a way to scrap your <a>Nil</a>s in
--   an <a>NP</a> list of <a>Aliased</a> expressions.
class KnownSymbol alias => Aliasable alias expression aliased | aliased -> expression, aliased -> alias
as :: Aliasable alias expression aliased => expression -> Alias alias -> aliased

-- | <pre>
--   &gt;&gt;&gt; let renderMaybe = fromString . maybe "Nothing" (const "Just")
--   
--   &gt;&gt;&gt; renderAliased renderMaybe (Just (3::Int) `As` #an_int)
--   "Just AS \"an_int\""
--   </pre>
renderAliased :: (forall ty. expression ty -> ByteString) -> Aliased expression aliased -> ByteString

-- | <tt>Has alias fields field</tt> is a constraint that proves that
--   <tt>fields</tt> has a field of <tt>alias ::: field</tt>, inferring
--   <tt>field</tt> from <tt>alias</tt> and <tt>fields</tt>.
class KnownSymbol alias => Has (alias :: Symbol) (fields :: [(Symbol, kind)]) (field :: kind) | alias fields -> field

-- | <tt>HasUnique alias fields field</tt> is a constraint that proves that
--   <tt>fields</tt> is a singleton of <tt>alias ::: field</tt>.
type HasUnique alias fields field = fields ~ '[alias ::: field]

-- | <a>HasAll</a> extends <a>Has</a> to take lists of <tt>aliases</tt> and
--   <tt>fields</tt> and infer a list of <tt>subfields</tt>.
class (All KnownSymbol aliases) => HasAll (aliases :: [Symbol]) (fields :: [(Symbol, kind)]) (subfields :: [(Symbol, kind)]) | aliases fields -> subfields

-- | <tt>HasIn fields (alias ::: field)</tt> is a constraint that proves
--   that <tt>fields</tt> has a field of <tt>alias ::: field</tt>. It is
--   used in <tt>UPDATE</tt>s to choose which subfields to update.
class HasIn fields field

-- | <a>QualifiedAlias</a>es enables multi-schema support by allowing a
--   reference to a <a>Table</a>, <a>Typedef</a> or <a>View</a> to be
--   qualified by their schemas. By default, a qualifier of <tt>public</tt>
--   is provided.
--   
--   <pre>
--   &gt;&gt;&gt; :{
--   let
--     alias1 :: QualifiedAlias "sch" "tab"
--     alias1 = #sch ! #tab
--     alias2 :: QualifiedAlias "public" "vw"
--     alias2 = #vw
--   in printSQL alias1 &gt;&gt; printSQL alias2
--   :}
--   "sch"."tab"
--   "vw"
--   </pre>
data QualifiedAlias (qualifier :: Symbol) (alias :: Symbol)
QualifiedAlias :: QualifiedAlias

-- | Analagous to <a>IsLabel</a>, the constraint <a>IsQualified</a> defines
--   <a>!</a> for a column alias qualified by a table alias.
class IsQualified table column expression
(!) :: IsQualified table column expression => Alias table -> Alias column -> expression
infixl 9 !

-- | <a>Grouping</a> is an auxiliary namespace, created by <tt>GROUP
--   BY</tt> clauses (<a>group</a>), and used for typesafe aggregation
data Grouping

-- | no aggregation permitted
Ungrouped :: Grouping

-- | aggregation required for any column which is not grouped
Grouped :: [(Symbol, Symbol)] -> Grouping

-- | A <a>GroupedBy</a> constraint indicates that a table qualified column
--   is a member of the auxiliary namespace created by <tt>GROUP BY</tt>
--   clauses and thus, may be called in an output <a>Expression</a> without
--   aggregating.
class (KnownSymbol table, KnownSymbol column) => GroupedBy table column bys
instance Control.DeepSeq.NFData (Squeal.PostgreSQL.Alias.QualifiedAlias qualifier alias)
instance GHC.Show.Show (Squeal.PostgreSQL.Alias.QualifiedAlias qualifier alias)
instance GHC.Classes.Ord (Squeal.PostgreSQL.Alias.QualifiedAlias qualifier alias)
instance GHC.Generics.Generic (Squeal.PostgreSQL.Alias.QualifiedAlias qualifier alias)
instance GHC.Classes.Eq (Squeal.PostgreSQL.Alias.QualifiedAlias qualifier alias)
instance Control.DeepSeq.NFData (Squeal.PostgreSQL.Alias.Alias alias)
instance GHC.Show.Show (Squeal.PostgreSQL.Alias.Alias alias)
instance GHC.Classes.Ord (Squeal.PostgreSQL.Alias.Alias alias)
instance GHC.Generics.Generic (Squeal.PostgreSQL.Alias.Alias alias)
instance GHC.Classes.Eq (Squeal.PostgreSQL.Alias.Alias alias)
instance forall k (expression :: k -> *) (ty :: k) (alias :: GHC.Types.Symbol). GHC.Show.Show (expression ty) => GHC.Show.Show (Squeal.PostgreSQL.Alias.Aliased expression (alias Squeal.PostgreSQL.Alias.::: ty))
instance forall k (expression :: k -> *) (ty :: k) (alias :: GHC.Types.Symbol). GHC.Classes.Eq (expression ty) => GHC.Classes.Eq (Squeal.PostgreSQL.Alias.Aliased expression (alias Squeal.PostgreSQL.Alias.::: ty))
instance forall k (expression :: k -> *) (ty :: k) (alias :: GHC.Types.Symbol). GHC.Classes.Ord (expression ty) => GHC.Classes.Ord (Squeal.PostgreSQL.Alias.Aliased expression (alias Squeal.PostgreSQL.Alias.::: ty))
instance (q Data.Type.Equality.~ q', a Data.Type.Equality.~ a') => Squeal.PostgreSQL.Alias.IsQualified q a (Squeal.PostgreSQL.Alias.QualifiedAlias q' a')
instance (q' Data.Type.Equality.~ "public", a Data.Type.Equality.~ a') => GHC.OverloadedLabels.IsLabel a (Squeal.PostgreSQL.Alias.QualifiedAlias q' a')
instance (q0 Data.Type.Equality.~ q1, a0 Data.Type.Equality.~ a1, a1 Data.Type.Equality.~ a2, GHC.TypeLits.KnownSymbol a2) => Squeal.PostgreSQL.Alias.IsQualified q0 a0 (Squeal.PostgreSQL.Alias.Aliased (Squeal.PostgreSQL.Alias.QualifiedAlias q1) (a1 Squeal.PostgreSQL.Alias.::: a2))
instance (q Data.Type.Equality.~ "public", a0 Data.Type.Equality.~ a1, a1 Data.Type.Equality.~ a2, GHC.TypeLits.KnownSymbol a2) => GHC.OverloadedLabels.IsLabel a0 (Squeal.PostgreSQL.Alias.Aliased (Squeal.PostgreSQL.Alias.QualifiedAlias q) (a1 Squeal.PostgreSQL.Alias.::: a2))
instance (GHC.TypeLits.KnownSymbol q, GHC.TypeLits.KnownSymbol a) => Squeal.PostgreSQL.Render.RenderSQL (Squeal.PostgreSQL.Alias.QualifiedAlias q a)
instance Squeal.PostgreSQL.Alias.IsQualified table column (Squeal.PostgreSQL.Alias.Alias table, Squeal.PostgreSQL.Alias.Alias column)
instance forall kind (fields :: [(GHC.Types.Symbol, kind)]). Squeal.PostgreSQL.Alias.HasAll '[] fields '[]
instance forall k (alias :: GHC.Types.Symbol) (fields :: [(GHC.Types.Symbol, k)]) (field :: k) (aliases :: [GHC.Types.Symbol]) (subfields :: [(GHC.Types.Symbol, k)]). (Squeal.PostgreSQL.Alias.Has alias fields field, Squeal.PostgreSQL.Alias.HasAll aliases fields subfields) => Squeal.PostgreSQL.Alias.HasAll (alias : aliases) fields ((alias Squeal.PostgreSQL.Alias.::: field) : subfields)
instance forall k (alias :: GHC.Types.Symbol) (fields :: [(GHC.Types.Symbol, k)]) (field :: k). Squeal.PostgreSQL.Alias.Has alias fields field => Squeal.PostgreSQL.Alias.HasIn fields (alias Squeal.PostgreSQL.Alias.::: field)
instance forall kind (alias :: GHC.Types.Symbol) (field :: kind) (fields :: [(GHC.Types.Symbol, kind)]). GHC.TypeLits.KnownSymbol alias => Squeal.PostgreSQL.Alias.Has alias ((alias Squeal.PostgreSQL.Alias.::: field) : fields) field
instance forall kind (alias :: GHC.Types.Symbol) (fields :: [(GHC.Types.Symbol, kind)]) (field :: kind) (field' :: (GHC.Types.Symbol, kind)). (GHC.TypeLits.KnownSymbol alias, Squeal.PostgreSQL.Alias.Has alias fields field) => Squeal.PostgreSQL.Alias.Has alias (field' : fields) field
instance forall k (alias :: GHC.Types.Symbol) (aliased :: (GHC.Types.Symbol, k)) (ty :: k) (expression :: k -> *). (GHC.TypeLits.KnownSymbol alias, aliased Data.Type.Equality.~ (alias Squeal.PostgreSQL.Alias.::: ty)) => Squeal.PostgreSQL.Alias.Aliasable alias (expression ty) (Squeal.PostgreSQL.Alias.Aliased expression aliased)
instance forall k (alias :: GHC.Types.Symbol) (tys :: [(GHC.Types.Symbol, k)]) (ty :: k) (expression :: k -> *). (GHC.TypeLits.KnownSymbol alias, tys Data.Type.Equality.~ '[alias Squeal.PostgreSQL.Alias.::: ty]) => Squeal.PostgreSQL.Alias.Aliasable alias (expression ty) (Data.SOP.NP.NP (Squeal.PostgreSQL.Alias.Aliased expression) tys)
instance (alias0 Data.Type.Equality.~ alias1, alias0 Data.Type.Equality.~ alias2, GHC.TypeLits.KnownSymbol alias2) => GHC.OverloadedLabels.IsLabel alias0 (Squeal.PostgreSQL.Alias.Aliased Squeal.PostgreSQL.Alias.Alias (alias1 Squeal.PostgreSQL.Alias.::: alias2))
instance (alias1 Data.Type.Equality.~ alias2) => GHC.OverloadedLabels.IsLabel alias1 (Squeal.PostgreSQL.Alias.Alias alias2)
instance (aliases Data.Type.Equality.~ '[alias]) => GHC.OverloadedLabels.IsLabel alias (Data.SOP.NP.NP Squeal.PostgreSQL.Alias.Alias aliases)
instance GHC.TypeLits.KnownSymbol alias => Squeal.PostgreSQL.Render.RenderSQL (Squeal.PostgreSQL.Alias.Alias alias)
instance Data.SOP.Constraint.All GHC.TypeLits.KnownSymbol aliases => Squeal.PostgreSQL.Render.RenderSQL (Data.SOP.NP.NP Squeal.PostgreSQL.Alias.Alias aliases)
instance (GHC.TypeLits.KnownSymbol table, GHC.TypeLits.KnownSymbol column) => Squeal.PostgreSQL.Alias.GroupedBy table column ('(table, column) : bys)
instance forall a (table :: GHC.Types.Symbol) (column :: GHC.Types.Symbol) (bys :: [a]) (tabcol :: a). (GHC.TypeLits.KnownSymbol table, GHC.TypeLits.KnownSymbol column, Squeal.PostgreSQL.Alias.GroupedBy table column bys) => Squeal.PostgreSQL.Alias.GroupedBy table column (tabcol : bys)


-- | <a>Schema</a> provides a type-level DSL for kinds of Postgres types,
--   tables, schema, constraints, aliases, enumerated labels, and
--   groupings. It also defines useful type families to operate on these.
--   Finally, it defines an embedding of Haskell types into Postgres types.
module Squeal.PostgreSQL.Schema

-- | <a>PGType</a> is the promoted datakind of PostgreSQL types.
--   
--   <pre>
--   &gt;&gt;&gt; :kind 'PGbool
--   'PGbool :: PGType
--   </pre>
data PGType

-- | logical Boolean (true/false)
PGbool :: PGType

-- | signed two-byte integer
PGint2 :: PGType

-- | signed four-byte integer
PGint4 :: PGType

-- | signed eight-byte integer
PGint8 :: PGType

-- | arbitrary precision numeric type
PGnumeric :: PGType

-- | single precision floating-point number (4 bytes)
PGfloat4 :: PGType

-- | double precision floating-point number (8 bytes)
PGfloat8 :: PGType

-- | currency amount
PGmoney :: PGType

-- | fixed-length character string
PGchar :: Nat -> PGType

-- | variable-length character string
PGvarchar :: Nat -> PGType

-- | variable-length character string
PGtext :: PGType

-- | binary data ("byte array")
PGbytea :: PGType

-- | date and time (no time zone)
PGtimestamp :: PGType

-- | date and time, including time zone
PGtimestamptz :: PGType

-- | calendar date (year, month, day)
PGdate :: PGType

-- | time of day (no time zone)
PGtime :: PGType

-- | time of day, including time zone
PGtimetz :: PGType

-- | time span
PGinterval :: PGType

-- | universally unique identifier
PGuuid :: PGType

-- | IPv4 or IPv6 host address
PGinet :: PGType

-- | textual JSON data
PGjson :: PGType

-- | binary JSON data, decomposed
PGjsonb :: PGType

-- | variable length array
PGvararray :: NullityType -> PGType

-- | fixed length array
PGfixarray :: [Nat] -> NullityType -> PGType

-- | enumerated (enum) types are data types that comprise a static, ordered
--   set of values.
PGenum :: [Symbol] -> PGType

-- | a composite type represents the structure of a row or record; it is
--   essentially just a list of field names and their data types.
PGcomposite :: RowType -> PGType

-- | A tsvector value is a sorted list of distinct lexemes, which are words
--   that have been normalized to merge different variants of the same
--   word.
PGtsvector :: PGType

-- | A tsquery value stores lexemes that are to be searched for
PGtsquery :: PGType

-- | an escape hatch for unsupported PostgreSQL types
UnsafePGType :: Symbol -> PGType

-- | <a>NullityType</a> encodes the potential presence or definite absence
--   of a <tt>NULL</tt> allowing operations which are sensitive to such to
--   be well typed.
--   
--   <pre>
--   &gt;&gt;&gt; :kind 'Null 'PGint4
--   'Null 'PGint4 :: NullityType
--   
--   &gt;&gt;&gt; :kind 'NotNull ('PGvarchar 50)
--   'NotNull ('PGvarchar 50) :: NullityType
--   </pre>
data NullityType

-- | <tt>NULL</tt> may be present
Null :: PGType -> NullityType

-- | <tt>NULL</tt> is absent
NotNull :: PGType -> NullityType

-- | A <a>RowType</a> is a row of <a>NullityType</a>. They correspond to
--   Haskell record types by means of <a>RowPG</a> and are used in many
--   places.
--   
--   <pre>
--   &gt;&gt;&gt; :{
--   type family PersonRow :: RowType where
--     PersonRow =
--       '[ "name"        ::: 'NotNull 'PGtext
--        , "age"         ::: 'NotNull 'PGint4
--        , "dateOfBirth" :::    'Null 'PGdate
--        ]
--   :}
--   </pre>
type RowType = [(Symbol, NullityType)]

-- | <a>FromType</a> is a row of <a>RowType</a>s. It can be thought of as a
--   product, or horizontal gluing and is used in <a>FromClause</a>s and
--   <a>TableExpression</a>s.
type FromType = [(Symbol, RowType)]

-- | <a>ColumnType</a> encodes the allowance of <tt>DEFAULT</tt> and
--   <tt>NULL</tt> and the base <a>PGType</a> for a column.
--   
--   <pre>
--   &gt;&gt;&gt; :set -XTypeFamilies -XTypeInType
--   
--   &gt;&gt;&gt; import GHC.TypeLits
--   
--   &gt;&gt;&gt; type family IdColumn :: ColumnType where IdColumn = 'Def :=&gt; 'NotNull 'PGint4
--   
--   &gt;&gt;&gt; type family EmailColumn :: ColumnType where EmailColumn = 'NoDef :=&gt; 'Null 'PGtext
--   </pre>
type ColumnType = (ColumnConstraint, NullityType)

-- | <a>ColumnsType</a> is a row of <a>ColumnType</a>s.
--   
--   <pre>
--   &gt;&gt;&gt; :{
--   type family UsersColumns :: ColumnsType where
--     UsersColumns =
--       '[ "name" ::: 'NoDef :=&gt; 'NotNull 'PGtext
--        , "id"   :::   'Def :=&gt; 'NotNull 'PGint4
--        ]
--   :}
--   </pre>
type ColumnsType = [(Symbol, ColumnType)]

-- | <a>TableType</a> encodes a row of constraints on a table as well as
--   the types of its columns.
--   
--   <pre>
--   &gt;&gt;&gt; :{
--   type family UsersTable :: TableType where
--     UsersTable =
--       '[ "pk_users" ::: 'PrimaryKey '["id"] ] :=&gt;
--       '[ "id"       :::   'Def :=&gt; 'NotNull 'PGint4
--        , "name"     ::: 'NoDef :=&gt; 'NotNull 'PGtext
--        ]
--   :}
--   </pre>
type TableType = (TableConstraints, ColumnsType)

-- | A <a>SchemumType</a> is a user-defined type, either a <a>Table</a>,
--   <a>View</a> or <a>Typedef</a>.
data SchemumType
Table :: TableType -> SchemumType
View :: RowType -> SchemumType
Typedef :: PGType -> SchemumType

-- | The schema of a database consists of a list of aliased, user-defined
--   <a>SchemumType</a>s.
--   
--   <pre>
--   &gt;&gt;&gt; :{
--   type family Schema :: SchemaType where
--     Schema =
--       '[ "users" ::: 'Table (
--           '[ "pk_users" ::: 'PrimaryKey '["id"] ] :=&gt;
--           '[ "id"   :::   'Def :=&gt; 'NotNull 'PGint4
--           , "name" ::: 'NoDef :=&gt; 'NotNull 'PGtext
--           ])
--       , "emails" ::: 'Table (
--           '[ "pk_emails"  ::: 'PrimaryKey '["id"]
--           , "fk_user_id" ::: 'ForeignKey '["user_id"] "users" '["id"]
--           ] :=&gt;
--           '[ "id"      :::   'Def :=&gt; 'NotNull 'PGint4
--           , "user_id" ::: 'NoDef :=&gt; 'NotNull 'PGint4
--           , "email"   ::: 'NoDef :=&gt;    'Null 'PGtext
--           ])
--       ]
--   :}
--   </pre>
type SchemaType = [(Symbol, SchemumType)]

-- | A database contains one or more named schemas, which in turn contain
--   tables. The same object name can be used in different schemas without
--   conflict; for example, both schema1 and myschema can contain tables
--   named mytable. Unlike databases, schemas are not rigidly separated: a
--   user can access objects in any of the schemas in the database they are
--   connected to, if they have privileges to do so.
--   
--   There are several reasons why one might want to use schemas:
--   
--   <ul>
--   <li>To allow many users to use one database without interfering with
--   each other.</li>
--   <li>To organize database objects into logical groups to make them more
--   manageable.</li>
--   <li>Third-party applications can be put into separate schemas so they
--   do not collide with the names of other objects.</li>
--   </ul>
type SchemasType = [(Symbol, SchemaType)]

-- | A type family to use for a single schema database.
type family Public (schema :: SchemaType) :: SchemasType

-- | The constraint operator, <a>:=&gt;</a> is a type level pair between a
--   "constraint" and some type, for use in pairing a
--   <a>ColumnConstraint</a> with a <a>NullityType</a> to produce a
--   <a>ColumnType</a> or a <a>TableConstraints</a> and a
--   <a>ColumnsType</a> to produce a <a>TableType</a>.
type (:=>) constraint ty = '(constraint, ty)
infixr 7 :=>

-- | <a>ColumnConstraint</a> encodes the availability of <tt>DEFAULT</tt>
--   for inserts and updates. A column can be assigned a default value. A
--   data <a>Manipulation</a> command can also request explicitly that a
--   column be set to its default value, without having to know what that
--   value is.
data ColumnConstraint

-- | <tt>DEFAULT</tt> is available for inserts and updates
Def :: ColumnConstraint

-- | <tt>DEFAULT</tt> is unavailable for inserts and updates
NoDef :: ColumnConstraint

-- | <a>TableConstraint</a> encodes various forms of data constraints of
--   columns in a table. <a>TableConstraint</a>s give you as much control
--   over the data in your tables as you wish. If a user attempts to store
--   data in a column that would violate a constraint, an error is raised.
--   This applies even if the value came from the default value definition.
data TableConstraint
Check :: [Symbol] -> TableConstraint
Unique :: [Symbol] -> TableConstraint
PrimaryKey :: [Symbol] -> TableConstraint
ForeignKey :: [Symbol] -> Symbol -> [Symbol] -> TableConstraint

-- | A <a>TableConstraints</a> is a row of <a>TableConstraint</a>s.
--   
--   <pre>
--   &gt;&gt;&gt; :{
--   type family UsersConstraints :: TableConstraints where
--     UsersConstraints = '[ "pk_users" ::: 'PrimaryKey '["id"] ]
--   :}
--   </pre>
type TableConstraints = [(Symbol, TableConstraint)]

-- | A <a>ForeignKey</a> must reference columns that either are a
--   <a>PrimaryKey</a> or form a <a>Unique</a> constraint.
type family Uniquely (key :: [Symbol]) (constraints :: TableConstraints) :: Constraint

-- | <a>IsPGlabel</a> looks very much like the <a>IsLabel</a> class.
--   Whereas the overloaded label, <a>fromLabel</a> is used for column
--   references, <a>label</a>s are used for enum terms. A <a>label</a> is
--   called with type application like `label @"beef"`.
class IsPGlabel (label :: Symbol) expr
label :: IsPGlabel label expr => expr

-- | A <a>PGlabel</a> unit type with an <a>IsPGlabel</a> instance
data PGlabel (label :: Symbol)
PGlabel :: PGlabel

-- | <tt>Create alias x xs</tt> adds <tt>alias ::: x</tt> to the end of
--   <tt>xs</tt> and is used in <a>createTable</a> statements and in
--   <tt>ALTER TABLE</tt> <a>addColumn</a>.
type family Create alias x xs

-- | <tt>Drop alias xs</tt> removes the type associated with <tt>alias</tt>
--   in <tt>xs</tt> and is used in <a>dropTable</a> statements and in
--   <tt>ALTER TABLE</tt> <a>dropColumn</a> statements.
type family Drop alias xs

-- | <tt>Alter alias x xs</tt> replaces the type associated with an
--   <tt>alias</tt> in <tt>xs</tt> with the type <tt>x</tt> and is used in
--   <a>alterTable</a> and <a>alterColumn</a>.
type family Alter alias x xs

-- | <tt>Rename alias0 alias1 xs</tt> replaces the alias <tt>alias0</tt> by
--   <tt>alias1</tt> in <tt>xs</tt> and is used in <a>alterTableRename</a>
--   and <a>renameColumn</a>.
type family Rename alias0 alias1 xs

-- | Check if a <a>TableConstraint</a> involves a column
type family ConstraintInvolves column constraint

-- | Drop all <a>TableConstraint</a>s that involve a column
type family DropIfConstraintsInvolve column constraints

-- | Utility class for <a>AllUnique</a> to provide nicer error messages.
class IsNotElem x isElem

-- | No elem of <tt>xs</tt> appears more than once, in the context of
--   assignment.
class AllUnique (xs :: [(Symbol, a)])

-- | Numeric Postgres types.
type PGNum = '[ 'PGint2,  'PGint4,  'PGint8,  'PGnumeric,  'PGfloat4,  'PGfloat8]

-- | Integral Postgres types.
type PGIntegral = '[ 'PGint2,  'PGint4,  'PGint8]

-- | Floating Postgres types.
type PGFloating = '[ 'PGfloat4,  'PGfloat8,  'PGnumeric]

-- | <a>PGTypeOf</a> forgets about <tt>NULL</tt> and any column
--   constraints.
type family PGTypeOf (ty :: NullityType) :: PGType

-- | Is a type a valid JSON type?
type PGJsonType = '[ 'PGjson,  'PGjsonb]

-- | Is a type a valid JSON key?
type PGJsonKey = '[ 'PGint2,  'PGint4,  'PGtext]

-- | Equality constraint on the underlying <a>PGType</a> of two columns.
class SamePGType (ty0 :: (Symbol, ColumnType)) (ty1 :: (Symbol, ColumnType))

-- | <a>AllNotNull</a> is a constraint that proves a <a>ColumnsType</a> has
--   no <tt>NULL</tt>s.
type family AllNotNull (columns :: ColumnsType) :: Constraint

-- | <a>NotAllNull</a> is a constraint that proves a <a>ColumnsType</a> has
--   some <tt>NOT NULL</tt>.
type family NotAllNull (columns :: ColumnsType) :: Constraint

-- | <a>NullifyType</a> is an idempotent that nullifies a
--   <a>NullityType</a>.
type family NullifyType (ty :: NullityType) :: NullityType

-- | <a>NullifyRow</a> is an idempotent that nullifies a <a>RowType</a>.
type family NullifyRow (columns :: RowType) :: RowType

-- | <a>NullifyFrom</a> is an idempotent that nullifies a <a>FromType</a>
--   used to nullify the left or right hand side of an outer join in a
--   <a>FromClause</a>.
type family NullifyFrom (tables :: FromType) :: FromType

-- | <a>TableToColumns</a> removes table constraints.
type family TableToColumns (table :: TableType) :: ColumnsType

-- | <a>ColumnsToRow</a> removes column constraints.
type family ColumnsToRow (columns :: ColumnsType) :: RowType

-- | Convert a table to a row type.
type family TableToRow (table :: TableType) :: RowType
instance Squeal.PostgreSQL.Schema.AllUnique '[]
instance forall a (x :: (GHC.Types.Symbol, a)) (xs :: [(GHC.Types.Symbol, a)]). (Squeal.PostgreSQL.Schema.IsNotElem x (Squeal.PostgreSQL.List.Elem x xs), Squeal.PostgreSQL.Schema.AllUnique xs) => Squeal.PostgreSQL.Schema.AllUnique (x : xs)
instance forall k (x :: k). Squeal.PostgreSQL.Schema.IsNotElem x 'GHC.Types.False
instance forall k1 k2 (alias :: k2) (a :: k1). (TypeError ...) => Squeal.PostgreSQL.Schema.IsNotElem '(alias, a) 'GHC.Types.True
instance (label Data.Type.Equality.~ label1) => Squeal.PostgreSQL.Schema.IsPGlabel label (Squeal.PostgreSQL.Schema.PGlabel label1)
instance (labels Data.Type.Equality.~ '[label]) => Squeal.PostgreSQL.Schema.IsPGlabel label (Data.SOP.NP.NP Squeal.PostgreSQL.Schema.PGlabel labels)
instance GHC.TypeLits.KnownSymbol label => Squeal.PostgreSQL.Render.RenderSQL (Squeal.PostgreSQL.Schema.PGlabel label)
instance Data.SOP.Constraint.All GHC.TypeLits.KnownSymbol labels => Squeal.PostgreSQL.Render.RenderSQL (Data.SOP.NP.NP Squeal.PostgreSQL.Schema.PGlabel labels)
instance forall k (ty0 :: k) (ty1 :: k) (alias0 :: GHC.Types.Symbol) (def0 :: Squeal.PostgreSQL.Schema.ColumnConstraint) (nullity0 :: k -> Squeal.PostgreSQL.Schema.NullityType) (alias1 :: GHC.Types.Symbol) (def1 :: Squeal.PostgreSQL.Schema.ColumnConstraint) (nullity1 :: k -> Squeal.PostgreSQL.Schema.NullityType). (ty0 Data.Type.Equality.~ ty1) => Squeal.PostgreSQL.Schema.SamePGType (alias0 Squeal.PostgreSQL.Alias.::: (def0 Squeal.PostgreSQL.Schema.:=> nullity0 ty0)) (alias1 Squeal.PostgreSQL.Alias.::: (def1 Squeal.PostgreSQL.Schema.:=> nullity1 ty1))


-- | <a>PG</a> provides type families for turning Haskell <a>Type</a>s into
--   corresponding Postgres types.
module Squeal.PostgreSQL.PG

-- | The <a>PG</a> type family embeds a subset of Haskell types as Postgres
--   types. As an open type family, <a>PG</a> is extensible.
--   
--   <pre>
--   &gt;&gt;&gt; :kind! PG LocalTime
--   PG LocalTime :: PGType
--   = 'PGtimestamp
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; newtype MyDouble = My Double
--   
--   &gt;&gt;&gt; :set -XTypeFamilies
--   
--   &gt;&gt;&gt; type instance PG MyDouble = 'PGfloat8
--   </pre>
type family PG (hask :: Type) :: PGType

-- | <a>NullPG</a> turns a Haskell type into a <a>NullityType</a>.
--   
--   <pre>
--   &gt;&gt;&gt; :kind! NullPG Double
--   NullPG Double :: NullityType
--   = 'NotNull 'PGfloat8
--   
--   &gt;&gt;&gt; :kind! NullPG (Maybe Double)
--   NullPG (Maybe Double) :: NullityType
--   = 'Null 'PGfloat8
--   </pre>
type family NullPG (hask :: Type) :: NullityType

-- | <a>TuplePG</a> turns a Haskell tuple type (including record types)
--   into the corresponding list of <a>NullityType</a>s.
--   
--   <pre>
--   &gt;&gt;&gt; :kind! TuplePG (Double, Maybe Char)
--   TuplePG (Double, Maybe Char) :: [NullityType]
--   = '[ 'NotNull 'PGfloat8, 'Null ('PGchar 1)]
--   </pre>
type family TuplePG (hask :: Type) :: [NullityType]

-- | <a>RowPG</a> turns a Haskell <a>Type</a> into a <a>RowType</a>.
--   
--   <a>RowPG</a> may be applied to normal Haskell record types provided
--   they have <a>Generic</a> and <a>HasDatatypeInfo</a> instances;
--   
--   <pre>
--   &gt;&gt;&gt; data Person = Person { name :: Strict.Text, age :: Int32 } deriving GHC.Generic
--   
--   &gt;&gt;&gt; instance SOP.Generic Person
--   
--   &gt;&gt;&gt; instance SOP.HasDatatypeInfo Person
--   
--   &gt;&gt;&gt; :kind! RowPG Person
--   RowPG Person :: [(Symbol, NullityType)]
--   = '["name" ::: 'NotNull 'PGtext, "age" ::: 'NotNull 'PGint4]
--   </pre>
type family RowPG (hask :: Type) :: RowType

-- | The <a>Money</a> newtype stores a monetary value in terms of the
--   number of cents, i.e. <tt>$2,000.20</tt> would be expressed as
--   <tt>Money { cents = 200020 }</tt>.
--   
--   <pre>
--   &gt;&gt;&gt; import Control.Monad (void)
--   
--   &gt;&gt;&gt; import Control.Monad.IO.Class (liftIO)
--   
--   &gt;&gt;&gt; import Squeal.PostgreSQL
--   
--   &gt;&gt;&gt; :{
--   let
--     roundTrip :: Query_ (Public '[]) (Only Money) (Only Money)
--     roundTrip = values_ $ parameter @1 money `as` #fromOnly
--   :}
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; let input = Only (Money 20020)
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; :{
--   withConnection "host=localhost port=5432 dbname=exampledb" $ do
--     result &lt;- runQueryParams roundTrip input
--     Just output &lt;- firstRow result
--     liftIO . print $ input == output
--   :}
--   True
--   </pre>
newtype Money
Money :: Int64 -> Money
[cents] :: Money -> Int64

-- | The <a>Json</a> newtype is an indication that the Haskell type it's
--   applied to should be stored as a <a>PGjson</a>.
newtype Json hask
Json :: hask -> Json hask
[getJson] :: Json hask -> hask

-- | The <a>Jsonb</a> newtype is an indication that the Haskell type it's
--   applied to should be stored as a <a>PGjsonb</a>.
newtype Jsonb hask
Jsonb :: hask -> Jsonb hask
[getJsonb] :: Jsonb hask -> hask

-- | The <a>Composite</a> newtype is an indication that the Haskell type
--   it's applied to should be stored as a <a>PGcomposite</a>.
newtype Composite record
Composite :: record -> Composite record
[getComposite] :: Composite record -> record

-- | The <a>Enumerated</a> newtype is an indication that the Haskell type
--   it's applied to should be stored as a <a>PGenum</a>.
newtype Enumerated enum
Enumerated :: enum -> Enumerated enum
[getEnumerated] :: Enumerated enum -> enum

-- | The <a>VarArray</a> newtype is an indication that the Haskell type
--   it's applied to should be stored as a <a>PGvararray</a>.
--   
--   <pre>
--   &gt;&gt;&gt; :kind! PG (VarArray (Vector Double))
--   PG (VarArray (Vector Double)) :: PGType
--   = 'PGvararray ('NotNull 'PGfloat8)
--   </pre>
newtype VarArray arr
VarArray :: arr -> VarArray arr
[getVarArray] :: VarArray arr -> arr

-- | The <a>FixArray</a> newtype is an indication that the Haskell type
--   it's applied to should be stored as a <a>PGfixarray</a>.
--   
--   <pre>
--   &gt;&gt;&gt; :kind! PG (FixArray ((Double, Double), (Double, Double)))
--   PG (FixArray ((Double, Double), (Double, Double))) :: PGType
--   = 'PGfixarray '[2, 2] ('NotNull 'PGfloat8)
--   </pre>
newtype FixArray arr
FixArray :: arr -> FixArray arr
[getFixArray] :: FixArray arr -> arr

-- | The <a>LabelsPG</a> type family calculates the constructors of a
--   Haskell enum type.
--   
--   <pre>
--   &gt;&gt;&gt; data Schwarma = Beef | Lamb | Chicken deriving GHC.Generic
--   
--   &gt;&gt;&gt; instance SOP.Generic Schwarma
--   
--   &gt;&gt;&gt; instance SOP.HasDatatypeInfo Schwarma
--   
--   &gt;&gt;&gt; :kind! LabelsPG Schwarma
--   LabelsPG Schwarma :: [Type.ConstructorName]
--   = '["Beef", "Lamb", "Chicken"]
--   </pre>
type family LabelsPG (hask :: Type) :: [ConstructorName]

-- | <a>DimPG</a> turns Haskell nested homogeneous tuples into a list of
--   lengths.
type family DimPG (hask :: Type) :: [Nat]

-- | <a>FixPG</a> extracts <a>NullPG</a> of the base type of nested
--   homogeneous tuples.
type family FixPG (hask :: Type) :: NullityType

-- | <a>TupleOf</a> turns a list of Haskell <a>Type</a>s into a list of
--   <a>NullityType</a>s.
type family TupleOf (tuple :: [Type]) :: [NullityType]

-- | <a>TupleCodeOf</a> takes the <a>Code</a> of a haskell <a>Type</a> and
--   if it's a simple product returns it, otherwise giving a
--   <a>TypeError</a>.
type family TupleCodeOf (hask :: Type) (code :: [[Type]]) :: [Type]

-- | <a>RowOf</a> applies <a>NullPG</a> to the fields of a list.
type family RowOf (record :: [(Symbol, Type)]) :: RowType

-- | Calculates constructors of a datatype.
type family ConstructorsOf (datatype :: DatatypeInfo) :: [ConstructorInfo]

-- | Calculates the name of a nullary constructor, otherwise generates a
--   type error.
type family ConstructorNameOf (constructor :: ConstructorInfo) :: ConstructorName

-- | Calculate the names of nullary constructors.
type family ConstructorNamesOf (constructors :: [ConstructorInfo]) :: [ConstructorName]
instance GHC.Generics.Generic (Squeal.PostgreSQL.PG.FixArray arr)
instance GHC.Read.Read arr => GHC.Read.Read (Squeal.PostgreSQL.PG.FixArray arr)
instance GHC.Show.Show arr => GHC.Show.Show (Squeal.PostgreSQL.PG.FixArray arr)
instance GHC.Classes.Ord arr => GHC.Classes.Ord (Squeal.PostgreSQL.PG.FixArray arr)
instance GHC.Classes.Eq arr => GHC.Classes.Eq (Squeal.PostgreSQL.PG.FixArray arr)
instance GHC.Generics.Generic (Squeal.PostgreSQL.PG.VarArray arr)
instance GHC.Read.Read arr => GHC.Read.Read (Squeal.PostgreSQL.PG.VarArray arr)
instance GHC.Show.Show arr => GHC.Show.Show (Squeal.PostgreSQL.PG.VarArray arr)
instance GHC.Classes.Ord arr => GHC.Classes.Ord (Squeal.PostgreSQL.PG.VarArray arr)
instance GHC.Classes.Eq arr => GHC.Classes.Eq (Squeal.PostgreSQL.PG.VarArray arr)
instance GHC.Generics.Generic (Squeal.PostgreSQL.PG.Enumerated enum)
instance GHC.Read.Read enum => GHC.Read.Read (Squeal.PostgreSQL.PG.Enumerated enum)
instance GHC.Show.Show enum => GHC.Show.Show (Squeal.PostgreSQL.PG.Enumerated enum)
instance GHC.Classes.Ord enum => GHC.Classes.Ord (Squeal.PostgreSQL.PG.Enumerated enum)
instance GHC.Classes.Eq enum => GHC.Classes.Eq (Squeal.PostgreSQL.PG.Enumerated enum)
instance GHC.Generics.Generic (Squeal.PostgreSQL.PG.Composite record)
instance GHC.Read.Read record => GHC.Read.Read (Squeal.PostgreSQL.PG.Composite record)
instance GHC.Show.Show record => GHC.Show.Show (Squeal.PostgreSQL.PG.Composite record)
instance GHC.Classes.Ord record => GHC.Classes.Ord (Squeal.PostgreSQL.PG.Composite record)
instance GHC.Classes.Eq record => GHC.Classes.Eq (Squeal.PostgreSQL.PG.Composite record)
instance GHC.Generics.Generic (Squeal.PostgreSQL.PG.Jsonb hask)
instance GHC.Read.Read hask => GHC.Read.Read (Squeal.PostgreSQL.PG.Jsonb hask)
instance GHC.Show.Show hask => GHC.Show.Show (Squeal.PostgreSQL.PG.Jsonb hask)
instance GHC.Classes.Ord hask => GHC.Classes.Ord (Squeal.PostgreSQL.PG.Jsonb hask)
instance GHC.Classes.Eq hask => GHC.Classes.Eq (Squeal.PostgreSQL.PG.Jsonb hask)
instance GHC.Generics.Generic (Squeal.PostgreSQL.PG.Json hask)
instance GHC.Read.Read hask => GHC.Read.Read (Squeal.PostgreSQL.PG.Json hask)
instance GHC.Show.Show hask => GHC.Show.Show (Squeal.PostgreSQL.PG.Json hask)
instance GHC.Classes.Ord hask => GHC.Classes.Ord (Squeal.PostgreSQL.PG.Json hask)
instance GHC.Classes.Eq hask => GHC.Classes.Eq (Squeal.PostgreSQL.PG.Json hask)
instance GHC.Generics.Generic Squeal.PostgreSQL.PG.Money
instance GHC.Read.Read Squeal.PostgreSQL.PG.Money
instance GHC.Show.Show Squeal.PostgreSQL.PG.Money
instance GHC.Classes.Ord Squeal.PostgreSQL.PG.Money
instance GHC.Classes.Eq Squeal.PostgreSQL.PG.Money


-- | Squeal expressions are the atoms used to build statements.
module Squeal.PostgreSQL.Expression

-- | <a>Expression</a>s are used in a variety of contexts, such as in the
--   target <a>List</a> of the <a>select</a> command, as new column values
--   in <a>insertRow</a> or <a>update</a>, or in search <a>Condition</a>s
--   in a number of commands.
--   
--   The expression syntax allows the calculation of values from primitive
--   expression using arithmetic, logical, and other operations.
--   
--   The type parameters of <a>Expression</a> are
--   
--   <ul>
--   <li><tt>outer :: </tt> <a>FromType</a>, the <tt>from</tt> clauses of
--   any outer queries in which the <a>Expression</a> is a correlated
--   subquery expression;</li>
--   <li><tt>commons :: </tt> <a>FromType</a>, the
--   <a>CommonTableExpression</a>s that are in scope for the
--   <a>Expression</a>;</li>
--   <li><tt>grp :: </tt> <a>Grouping</a>, the <a>Grouping</a> of the
--   <tt>from</tt> clause which may limit which columns may be referenced
--   by alias;</li>
--   <li><tt>schemas :: </tt> <a>SchemasType</a>, the schemas of your
--   database that are in scope for the <a>Expression</a>;</li>
--   <li><tt>from :: </tt> <a>FromType</a>, the <tt>from</tt> clause which
--   the <a>Expression</a> may use to reference columns by alias;</li>
--   <li><tt>ty :: </tt> <a>NullityType</a>, the type of the
--   <a>Expression</a>.</li>
--   </ul>
newtype Expression (outer :: FromType) (commons :: FromType) (grp :: Grouping) (schemas :: SchemasType) (params :: [NullityType]) (from :: FromType) (ty :: NullityType)
UnsafeExpression :: ByteString -> Expression
[renderExpression] :: Expression -> ByteString

-- | An <a>Expr</a> is a closed <a>Expression</a>. It is a
--   F<tt>RankNType</tt> but don't be scared. Think of it as an expression
--   which sees no namespaces, so you can't use parameters or alias
--   references. It can be used as a simple piece of more complex
--   <a>Expression</a>s.
type Expr x = forall outer commons grp schemas params from. Expression outer commons grp schemas params from x " cannot reference aliases"

-- | A <tt>RankNType</tt> for functions with a single argument. These could
--   be either function calls or unary operators. This is a subtype of the
--   usual Haskell function type <a>-&gt;</a>, indeed a subcategory as it
--   is closed under the usual <a>.</a> and <a>id</a>.
type (:-->) x y = forall outer commons grp schemas params from. Expression outer commons grp schemas params from x " input" -> Expression outer commons grp schemas params from y " output"

-- | <pre>
--   &gt;&gt;&gt; printSQL $ unsafeFunction "f" true
--   f(TRUE)
--   </pre>
unsafeFunction :: ByteString -> x :--> y

-- | <pre>
--   &gt;&gt;&gt; printSQL $ unsafeUnaryOpL "NOT" true
--   (NOT TRUE)
--   </pre>
unsafeUnaryOpL :: ByteString -> x :--> y

-- | <pre>
--   &gt;&gt;&gt; printSQL $ true &amp; unsafeUnaryOpR "IS NOT TRUE"
--   (TRUE IS NOT TRUE)
--   </pre>
unsafeUnaryOpR :: ByteString -> x :--> y

-- | A <tt>RankNType</tt> for binary operators.
type Operator x1 x2 y = forall outer commons grp schemas params from. Expression outer commons grp schemas params from x1 " left input" -> Expression outer commons grp schemas params from x2 " right input" -> Expression outer commons grp schemas params from y " output"

-- | <pre>
--   &gt;&gt;&gt; printSQL $ unsafeBinaryOp "OR" true false
--   (TRUE OR FALSE)
--   </pre>
unsafeBinaryOp :: ByteString -> Operator ty0 ty1 ty2

-- | A <tt>RankNType</tt> for functions with a variable-length list of
--   homogeneous arguments and at least 1 more argument.
type FunctionVar x0 x1 y = forall outer commons grp schemas params from. [Expression outer commons grp schemas params from x0] " inputs" -> Expression outer commons grp schemas params from x1 " must have at least 1 input" -> Expression outer commons grp schemas params from y " output"

-- | <pre>
--   &gt;&gt;&gt; printSQL (unsafeFunctionVar "greatest" [true, null_] false)
--   greatest(TRUE, NULL, FALSE)
--   </pre>
unsafeFunctionVar :: ByteString -> FunctionVar x0 x1 y

-- | A <tt>RankNType</tt> for functions with a fixed-length list of
--   heterogeneous arguments. Use the <a>*:</a> operator to end your
--   argument lists, like so.
--   
--   <pre>
--   &gt;&gt;&gt; printSQL (unsafeFunctionN "fun" (true :* false :* localTime *: true))
--   fun(TRUE, FALSE, LOCALTIME, TRUE)
--   </pre>
type FunctionN xs y = forall outer commons grp schemas params from. NP (Expression outer commons grp schemas params from) xs " inputs" -> Expression outer commons grp schemas params from y " output"

-- | <pre>
--   &gt;&gt;&gt; printSQL $ unsafeFunctionN "f" (currentTime :* localTimestamp :* false *: literal 'a')
--   f(CURRENT_TIME, LOCALTIMESTAMP, FALSE, E'a')
--   </pre>
unsafeFunctionN :: SListI xs => ByteString -> FunctionN xs y

-- | Contained by operators
class PGSubset container
(@>) :: PGSubset container => Operator (null0 container) (null1 container) ( 'Null  'PGbool)
(<@) :: PGSubset container => Operator (null0 container) (null1 container) ( 'Null  'PGbool)

-- | <a>&amp;</a> is a reverse application operator. This provides
--   notational convenience. Its precedence is one higher than that of the
--   forward application operator <a>$</a>, which allows <a>&amp;</a> to be
--   nested in <a>$</a>.
--   
--   <pre>
--   &gt;&gt;&gt; 5 &amp; (+1) &amp; show
--   "6"
--   </pre>
(&) :: () => a -> (a -> b) -> b
infixl 1 &

-- | The constant type functor.
--   
--   Like <a>Constant</a>, but kind-polymorphic in its second argument and
--   with a shorter name.
newtype K a (b :: k) :: forall k. () => Type -> k -> Type
K :: a -> K a

-- | Extract the contents of a <a>K</a> value.
unK :: () => K a b -> a
instance Control.DeepSeq.NFData (Squeal.PostgreSQL.Expression.Expression outer commons grp schemas params from ty)
instance GHC.Classes.Ord (Squeal.PostgreSQL.Expression.Expression outer commons grp schemas params from ty)
instance GHC.Classes.Eq (Squeal.PostgreSQL.Expression.Expression outer commons grp schemas params from ty)
instance GHC.Show.Show (Squeal.PostgreSQL.Expression.Expression outer commons grp schemas params from ty)
instance GHC.Generics.Generic (Squeal.PostgreSQL.Expression.Expression outer commons grp schemas params from ty)
instance Squeal.PostgreSQL.Expression.PGSubset 'Squeal.PostgreSQL.Schema.PGjsonb
instance Squeal.PostgreSQL.Expression.PGSubset 'Squeal.PostgreSQL.Schema.PGtsquery
instance Squeal.PostgreSQL.Expression.PGSubset ('Squeal.PostgreSQL.Schema.PGvararray ty)
instance Squeal.PostgreSQL.Render.RenderSQL (Squeal.PostgreSQL.Expression.Expression outer commons grp schemas params from ty)
instance (Squeal.PostgreSQL.Alias.HasUnique tab (Squeal.PostgreSQL.List.Join outer from) row, Squeal.PostgreSQL.Alias.Has col row ty) => GHC.OverloadedLabels.IsLabel col (Squeal.PostgreSQL.Expression.Expression outer commons 'Squeal.PostgreSQL.Alias.Ungrouped schemas params from ty)
instance (Squeal.PostgreSQL.Alias.HasUnique tab (Squeal.PostgreSQL.List.Join outer from) row, Squeal.PostgreSQL.Alias.Has col row ty, tys Data.Type.Equality.~ '[ty]) => GHC.OverloadedLabels.IsLabel col (Data.SOP.NP.NP (Squeal.PostgreSQL.Expression.Expression outer commons 'Squeal.PostgreSQL.Alias.Ungrouped schemas params from) tys)
instance (Squeal.PostgreSQL.Alias.HasUnique tab (Squeal.PostgreSQL.List.Join outer from) row, Squeal.PostgreSQL.Alias.Has col row ty, column Data.Type.Equality.~ (col Squeal.PostgreSQL.Alias.::: ty)) => GHC.OverloadedLabels.IsLabel col (Squeal.PostgreSQL.Alias.Aliased (Squeal.PostgreSQL.Expression.Expression outer commons 'Squeal.PostgreSQL.Alias.Ungrouped schemas params from) column)
instance (Squeal.PostgreSQL.Alias.HasUnique tab (Squeal.PostgreSQL.List.Join outer from) row, Squeal.PostgreSQL.Alias.Has col row ty, columns Data.Type.Equality.~ '[col Squeal.PostgreSQL.Alias.::: ty]) => GHC.OverloadedLabels.IsLabel col (Data.SOP.NP.NP (Squeal.PostgreSQL.Alias.Aliased (Squeal.PostgreSQL.Expression.Expression outer commons 'Squeal.PostgreSQL.Alias.Ungrouped schemas params from)) columns)
instance (Squeal.PostgreSQL.Alias.Has tab (Squeal.PostgreSQL.List.Join outer from) row, Squeal.PostgreSQL.Alias.Has col row ty) => Squeal.PostgreSQL.Alias.IsQualified tab col (Squeal.PostgreSQL.Expression.Expression outer commons 'Squeal.PostgreSQL.Alias.Ungrouped schemas params from ty)
instance (Squeal.PostgreSQL.Alias.Has tab (Squeal.PostgreSQL.List.Join outer from) row, Squeal.PostgreSQL.Alias.Has col row ty, tys Data.Type.Equality.~ '[ty]) => Squeal.PostgreSQL.Alias.IsQualified tab col (Data.SOP.NP.NP (Squeal.PostgreSQL.Expression.Expression outer commons 'Squeal.PostgreSQL.Alias.Ungrouped schemas params from) tys)
instance (Squeal.PostgreSQL.Alias.Has tab (Squeal.PostgreSQL.List.Join outer from) row, Squeal.PostgreSQL.Alias.Has col row ty, column Data.Type.Equality.~ (col Squeal.PostgreSQL.Alias.::: ty)) => Squeal.PostgreSQL.Alias.IsQualified tab col (Squeal.PostgreSQL.Alias.Aliased (Squeal.PostgreSQL.Expression.Expression outer commons 'Squeal.PostgreSQL.Alias.Ungrouped schemas params from) column)
instance (Squeal.PostgreSQL.Alias.Has tab (Squeal.PostgreSQL.List.Join outer from) row, Squeal.PostgreSQL.Alias.Has col row ty, columns Data.Type.Equality.~ '[col Squeal.PostgreSQL.Alias.::: ty]) => Squeal.PostgreSQL.Alias.IsQualified tab col (Data.SOP.NP.NP (Squeal.PostgreSQL.Alias.Aliased (Squeal.PostgreSQL.Expression.Expression outer commons 'Squeal.PostgreSQL.Alias.Ungrouped schemas params from)) columns)
instance (Squeal.PostgreSQL.Alias.HasUnique tab (Squeal.PostgreSQL.List.Join outer from) row, Squeal.PostgreSQL.Alias.Has col row ty, Squeal.PostgreSQL.Alias.GroupedBy tab col bys) => GHC.OverloadedLabels.IsLabel col (Squeal.PostgreSQL.Expression.Expression outer commons ('Squeal.PostgreSQL.Alias.Grouped bys) schemas params from ty)
instance (Squeal.PostgreSQL.Alias.HasUnique tab (Squeal.PostgreSQL.List.Join outer from) row, Squeal.PostgreSQL.Alias.Has col row ty, Squeal.PostgreSQL.Alias.GroupedBy tab col bys, tys Data.Type.Equality.~ '[ty]) => GHC.OverloadedLabels.IsLabel col (Data.SOP.NP.NP (Squeal.PostgreSQL.Expression.Expression outer commons ('Squeal.PostgreSQL.Alias.Grouped bys) schemas params from) tys)
instance (Squeal.PostgreSQL.Alias.HasUnique tab (Squeal.PostgreSQL.List.Join outer from) row, Squeal.PostgreSQL.Alias.Has col row ty, Squeal.PostgreSQL.Alias.GroupedBy tab col bys, column Data.Type.Equality.~ (col Squeal.PostgreSQL.Alias.::: ty)) => GHC.OverloadedLabels.IsLabel col (Squeal.PostgreSQL.Alias.Aliased (Squeal.PostgreSQL.Expression.Expression outer commons ('Squeal.PostgreSQL.Alias.Grouped bys) schemas params from) column)
instance (Squeal.PostgreSQL.Alias.HasUnique tab (Squeal.PostgreSQL.List.Join outer from) row, Squeal.PostgreSQL.Alias.Has col row ty, Squeal.PostgreSQL.Alias.GroupedBy tab col bys, columns Data.Type.Equality.~ '[col Squeal.PostgreSQL.Alias.::: ty]) => GHC.OverloadedLabels.IsLabel col (Data.SOP.NP.NP (Squeal.PostgreSQL.Alias.Aliased (Squeal.PostgreSQL.Expression.Expression outer commons ('Squeal.PostgreSQL.Alias.Grouped bys) schemas params from)) columns)
instance (Squeal.PostgreSQL.Alias.Has tab (Squeal.PostgreSQL.List.Join outer from) row, Squeal.PostgreSQL.Alias.Has col row ty, Squeal.PostgreSQL.Alias.GroupedBy tab col bys) => Squeal.PostgreSQL.Alias.IsQualified tab col (Squeal.PostgreSQL.Expression.Expression outer commons ('Squeal.PostgreSQL.Alias.Grouped bys) schemas params from ty)
instance (Squeal.PostgreSQL.Alias.Has tab (Squeal.PostgreSQL.List.Join outer from) row, Squeal.PostgreSQL.Alias.Has col row ty, Squeal.PostgreSQL.Alias.GroupedBy tab col bys, tys Data.Type.Equality.~ '[ty]) => Squeal.PostgreSQL.Alias.IsQualified tab col (Data.SOP.NP.NP (Squeal.PostgreSQL.Expression.Expression outer commons ('Squeal.PostgreSQL.Alias.Grouped bys) schemas params from) tys)
instance (Squeal.PostgreSQL.Alias.Has tab (Squeal.PostgreSQL.List.Join outer from) row, Squeal.PostgreSQL.Alias.Has col row ty, Squeal.PostgreSQL.Alias.GroupedBy tab col bys, column Data.Type.Equality.~ (col Squeal.PostgreSQL.Alias.::: ty)) => Squeal.PostgreSQL.Alias.IsQualified tab col (Squeal.PostgreSQL.Alias.Aliased (Squeal.PostgreSQL.Expression.Expression outer commons ('Squeal.PostgreSQL.Alias.Grouped bys) schemas params from) column)
instance (Squeal.PostgreSQL.Alias.Has tab (Squeal.PostgreSQL.List.Join outer from) row, Squeal.PostgreSQL.Alias.Has col row ty, Squeal.PostgreSQL.Alias.GroupedBy tab col bys, columns Data.Type.Equality.~ '[col Squeal.PostgreSQL.Alias.::: ty]) => Squeal.PostgreSQL.Alias.IsQualified tab col (Data.SOP.NP.NP (Squeal.PostgreSQL.Alias.Aliased (Squeal.PostgreSQL.Expression.Expression outer commons ('Squeal.PostgreSQL.Alias.Grouped bys) schemas params from)) columns)
instance (GHC.TypeLits.KnownSymbol label, Squeal.PostgreSQL.List.In label labels) => Squeal.PostgreSQL.Schema.IsPGlabel label (Squeal.PostgreSQL.Expression.Expression outer commons grp schemas params from (null ('Squeal.PostgreSQL.Schema.PGenum labels)))
instance Squeal.PostgreSQL.List.In ty Squeal.PostgreSQL.Schema.PGNum => GHC.Num.Num (Squeal.PostgreSQL.Expression.Expression outer commons grp schemas params from (null ty))
instance (Squeal.PostgreSQL.List.In ty Squeal.PostgreSQL.Schema.PGNum, Squeal.PostgreSQL.List.In ty Squeal.PostgreSQL.Schema.PGFloating) => GHC.Real.Fractional (Squeal.PostgreSQL.Expression.Expression outer commons grp schemas params from (null ty))
instance (Squeal.PostgreSQL.List.In ty Squeal.PostgreSQL.Schema.PGNum, Squeal.PostgreSQL.List.In ty Squeal.PostgreSQL.Schema.PGFloating) => GHC.Float.Floating (Squeal.PostgreSQL.Expression.Expression outer commons grp schemas params from (null ty))
instance Data.String.IsString (Squeal.PostgreSQL.Expression.Expression outer commons grp schemas params from (null 'Squeal.PostgreSQL.Schema.PGtext))
instance Data.String.IsString (Squeal.PostgreSQL.Expression.Expression outer commons grp schemas params from (null 'Squeal.PostgreSQL.Schema.PGtsvector))
instance Data.String.IsString (Squeal.PostgreSQL.Expression.Expression outer commons grp schemas params from (null 'Squeal.PostgreSQL.Schema.PGtsquery))
instance GHC.Base.Semigroup (Squeal.PostgreSQL.Expression.Expression outer commons grp schemas params from (null ('Squeal.PostgreSQL.Schema.PGvararray ty)))
instance GHC.Base.Semigroup (Squeal.PostgreSQL.Expression.Expression outer commons grp schemas params from (null 'Squeal.PostgreSQL.Schema.PGjsonb))
instance GHC.Base.Semigroup (Squeal.PostgreSQL.Expression.Expression outer commons grp schemas params from (null 'Squeal.PostgreSQL.Schema.PGtext))
instance GHC.Base.Semigroup (Squeal.PostgreSQL.Expression.Expression outer commons grp schemas params from (null 'Squeal.PostgreSQL.Schema.PGtsvector))
instance GHC.Base.Monoid (Squeal.PostgreSQL.Expression.Expression outer commons grp schemas params from (null 'Squeal.PostgreSQL.Schema.PGtext))
instance GHC.Base.Monoid (Squeal.PostgreSQL.Expression.Expression outer commons grp schemas params from (null 'Squeal.PostgreSQL.Schema.PGtsvector))


-- | Type expressions.
module Squeal.PostgreSQL.Expression.Type

-- | <a>TypeExpression</a>s are used in <a>cast</a>s and <a>createTable</a>
--   commands.
newtype TypeExpression (schemas :: SchemasType) (ty :: NullityType)
UnsafeTypeExpression :: ByteString -> TypeExpression
[renderTypeExpression] :: TypeExpression -> ByteString

-- | <pre>
--   &gt;&gt;&gt; printSQL $ true &amp; cast int4
--   (TRUE :: int4)
--   </pre>
cast :: TypeExpression schemas ty1 -> Expression outer commons grp schemas params from ty0 -> Expression outer commons grp schemas params from ty1

-- | A safe version of <a>cast</a> which just matches a value with its
--   type.
--   
--   <pre>
--   &gt;&gt;&gt; printSQL (1 &amp; astype int)
--   (1 :: int)
--   </pre>
astype :: TypeExpression schemas ty -> Expression outer commons grp schemas params from ty -> Expression outer commons grp schemas params from ty

-- | <a>inferredtype</a> will add a type annotation to an <a>Expression</a>
--   which can be useful for fixing the storage type of a value.
--   
--   <pre>
--   &gt;&gt;&gt; printSQL (inferredtype true)
--   (TRUE :: bool)
--   </pre>
inferredtype :: PGTyped schemas ty => Expression outer common grp schemas params from ty -> Expression outer common grp schemas params from ty

-- | <a>pgtype</a> is a demoted version of a <a>PGType</a>
class PGTyped schemas (ty :: NullityType)
pgtype :: PGTyped schemas ty => TypeExpression schemas ty

-- | The enum or composite type in a <a>Typedef</a> can be expressed by its
--   alias.
typedef :: (Has sch schemas schema, Has td schema ( 'Typedef ty)) => QualifiedAlias sch td -> TypeExpression schemas (null ty)

-- | The composite type corresponding to a <a>Table</a> definition can be
--   expressed by its alias.
typetable :: (Has sch schemas schema, Has tab schema ( 'Table table)) => QualifiedAlias sch tab -> TypeExpression schemas (null ( 'PGcomposite (TableToRow table)))

-- | The composite type corresponding to a <a>View</a> definition can be
--   expressed by its alias.
typeview :: (Has sch schemas schema, Has vw schema ( 'View view)) => QualifiedAlias sch vw -> TypeExpression schemas (null ( 'PGcomposite view))

-- | logical Boolean (true/false)
bool :: TypeExpression schemas (null  'PGbool)

-- | signed two-byte integer
int2 :: TypeExpression schemas (null  'PGint2)

-- | signed two-byte integer
smallint :: TypeExpression schemas (null  'PGint2)

-- | signed four-byte integer
int4 :: TypeExpression schemas (null  'PGint4)

-- | signed four-byte integer
int :: TypeExpression schemas (null  'PGint4)

-- | signed four-byte integer
integer :: TypeExpression schemas (null  'PGint4)

-- | signed eight-byte integer
int8 :: TypeExpression schemas (null  'PGint8)

-- | signed eight-byte integer
bigint :: TypeExpression schemas (null  'PGint8)

-- | arbitrary precision numeric type
numeric :: TypeExpression schemas (null  'PGnumeric)

-- | single precision floating-point number (4 bytes)
float4 :: TypeExpression schemas (null  'PGfloat4)

-- | single precision floating-point number (4 bytes)
real :: TypeExpression schemas (null  'PGfloat4)

-- | double precision floating-point number (8 bytes)
float8 :: TypeExpression schemas (null  'PGfloat8)

-- | double precision floating-point number (8 bytes)
doublePrecision :: TypeExpression schemas (null  'PGfloat8)

-- | currency amount
money :: TypeExpression schema (null  'PGmoney)

-- | variable-length character string
text :: TypeExpression schemas (null  'PGtext)

-- | fixed-length character string
char :: forall n schemas null. (KnownNat n, 1 <= n) => TypeExpression schemas (null ( 'PGchar n))

-- | fixed-length character string
character :: forall n schemas null. (KnownNat n, 1 <= n) => TypeExpression schemas (null ( 'PGchar n))

-- | variable-length character string
varchar :: forall n schemas null. (KnownNat n, 1 <= n) => TypeExpression schemas (null ( 'PGvarchar n))

-- | variable-length character string
characterVarying :: forall n schemas null. (KnownNat n, 1 <= n) => TypeExpression schemas (null ( 'PGvarchar n))

-- | binary data ("byte array")
bytea :: TypeExpression schemas (null  'PGbytea)

-- | date and time (no time zone)
timestamp :: TypeExpression schemas (null  'PGtimestamp)

-- | date and time, including time zone
timestampWithTimeZone :: TypeExpression schemas (null  'PGtimestamptz)

-- | calendar date (year, month, day)
date :: TypeExpression schemas (null  'PGdate)

-- | time of day (no time zone)
time :: TypeExpression schemas (null  'PGtime)

-- | time of day, including time zone
timeWithTimeZone :: TypeExpression schemas (null  'PGtimetz)

-- | time span
interval :: TypeExpression schemas (null  'PGinterval)

-- | universally unique identifier
uuid :: TypeExpression schemas (null  'PGuuid)

-- | IPv4 or IPv6 host address
inet :: TypeExpression schemas (null  'PGinet)

-- | textual JSON data
json :: TypeExpression schemas (null  'PGjson)

-- | binary JSON data, decomposed
jsonb :: TypeExpression schemas (null  'PGjsonb)

-- | variable length array
vararray :: TypeExpression schemas pg -> TypeExpression schemas (null ( 'PGvararray pg))

-- | fixed length array
--   
--   <pre>
--   &gt;&gt;&gt; renderSQL (fixarray @'[2] json)
--   "json[2]"
--   </pre>
fixarray :: forall dims schemas null pg. All KnownNat dims => TypeExpression schemas pg -> TypeExpression schemas (null ( 'PGfixarray dims pg))

-- | text search query
tsvector :: TypeExpression schemas (null  'PGtsvector)

-- | text search document
tsquery :: TypeExpression schemas (null  'PGtsquery)
instance Control.DeepSeq.NFData (Squeal.PostgreSQL.Expression.Type.TypeExpression schemas ty)
instance GHC.Classes.Ord (Squeal.PostgreSQL.Expression.Type.TypeExpression schemas ty)
instance GHC.Classes.Eq (Squeal.PostgreSQL.Expression.Type.TypeExpression schemas ty)
instance GHC.Show.Show (Squeal.PostgreSQL.Expression.Type.TypeExpression schemas ty)
instance GHC.Generics.Generic (Squeal.PostgreSQL.Expression.Type.TypeExpression schemas ty)
instance Squeal.PostgreSQL.Expression.Type.PGTyped schemas (null 'Squeal.PostgreSQL.Schema.PGbool)
instance Squeal.PostgreSQL.Expression.Type.PGTyped schemas (null 'Squeal.PostgreSQL.Schema.PGint2)
instance Squeal.PostgreSQL.Expression.Type.PGTyped schemas (null 'Squeal.PostgreSQL.Schema.PGint4)
instance Squeal.PostgreSQL.Expression.Type.PGTyped schemas (null 'Squeal.PostgreSQL.Schema.PGint8)
instance Squeal.PostgreSQL.Expression.Type.PGTyped schemas (null 'Squeal.PostgreSQL.Schema.PGnumeric)
instance Squeal.PostgreSQL.Expression.Type.PGTyped schemas (null 'Squeal.PostgreSQL.Schema.PGfloat4)
instance Squeal.PostgreSQL.Expression.Type.PGTyped schemas (null 'Squeal.PostgreSQL.Schema.PGfloat8)
instance Squeal.PostgreSQL.Expression.Type.PGTyped schemas (null 'Squeal.PostgreSQL.Schema.PGmoney)
instance Squeal.PostgreSQL.Expression.Type.PGTyped schemas (null 'Squeal.PostgreSQL.Schema.PGtext)
instance (GHC.TypeNats.KnownNat n, 1 GHC.TypeNats.<= n) => Squeal.PostgreSQL.Expression.Type.PGTyped schemas (null ('Squeal.PostgreSQL.Schema.PGchar n))
instance (GHC.TypeNats.KnownNat n, 1 GHC.TypeNats.<= n) => Squeal.PostgreSQL.Expression.Type.PGTyped schemas (null ('Squeal.PostgreSQL.Schema.PGvarchar n))
instance Squeal.PostgreSQL.Expression.Type.PGTyped schemas (null 'Squeal.PostgreSQL.Schema.PGbytea)
instance Squeal.PostgreSQL.Expression.Type.PGTyped schemas (null 'Squeal.PostgreSQL.Schema.PGtimestamp)
instance Squeal.PostgreSQL.Expression.Type.PGTyped schemas (null 'Squeal.PostgreSQL.Schema.PGtimestamptz)
instance Squeal.PostgreSQL.Expression.Type.PGTyped schemas (null 'Squeal.PostgreSQL.Schema.PGdate)
instance Squeal.PostgreSQL.Expression.Type.PGTyped schemas (null 'Squeal.PostgreSQL.Schema.PGtime)
instance Squeal.PostgreSQL.Expression.Type.PGTyped schemas (null 'Squeal.PostgreSQL.Schema.PGtimetz)
instance Squeal.PostgreSQL.Expression.Type.PGTyped schemas (null 'Squeal.PostgreSQL.Schema.PGinterval)
instance Squeal.PostgreSQL.Expression.Type.PGTyped schemas (null 'Squeal.PostgreSQL.Schema.PGuuid)
instance Squeal.PostgreSQL.Expression.Type.PGTyped schemas (null 'Squeal.PostgreSQL.Schema.PGjson)
instance Squeal.PostgreSQL.Expression.Type.PGTyped schemas (null 'Squeal.PostgreSQL.Schema.PGjsonb)
instance Squeal.PostgreSQL.Expression.Type.PGTyped schemas ty => Squeal.PostgreSQL.Expression.Type.PGTyped schemas (null ('Squeal.PostgreSQL.Schema.PGvararray ty))
instance (Data.SOP.Constraint.All GHC.TypeNats.KnownNat dims, Squeal.PostgreSQL.Expression.Type.PGTyped schemas ty) => Squeal.PostgreSQL.Expression.Type.PGTyped schemas (null ('Squeal.PostgreSQL.Schema.PGfixarray dims ty))
instance Squeal.PostgreSQL.Expression.Type.PGTyped schemas (null 'Squeal.PostgreSQL.Schema.PGtsvector)
instance Squeal.PostgreSQL.Expression.Type.PGTyped schemas (null 'Squeal.PostgreSQL.Schema.PGtsquery)
instance Squeal.PostgreSQL.Render.RenderSQL (Squeal.PostgreSQL.Expression.Type.TypeExpression schemas ty)


-- | Date/Time functions and operators
module Squeal.PostgreSQL.Expression.Time

-- | Affine space operations on time types.
class TimeOp time diff | time -> diff

-- | <pre>
--   &gt;&gt;&gt; printSQL (makeDate (1984 :* 7 *: 3) !+ 365)
--   (make_date(1984, 7, 3) + 365)
--   </pre>
(!+) :: TimeOp time diff => Operator (null time) (null diff) (null time)

-- | <pre>
--   &gt;&gt;&gt; printSQL (365 +! makeDate (1984 :* 7 *: 3))
--   (365 + make_date(1984, 7, 3))
--   </pre>
(+!) :: TimeOp time diff => Operator (null diff) (null time) (null time)

-- | <pre>
--   &gt;&gt;&gt; printSQL (makeDate (1984 :* 7 *: 3) !- 365)
--   (make_date(1984, 7, 3) - 365)
--   </pre>
(!-) :: TimeOp time diff => Operator (null time) (null diff) (null time)

-- | <pre>
--   &gt;&gt;&gt; printSQL (makeDate (1984 :* 7 *: 3) !-! currentDate)
--   (make_date(1984, 7, 3) - CURRENT_DATE)
--   </pre>
(!-!) :: TimeOp time diff => Operator (null time) (null time) (null diff)
infixl 6 !+
infixl 6 +!
infixl 6 !-
infixl 6 !-!

-- | <pre>
--   &gt;&gt;&gt; printSQL currentDate
--   CURRENT_DATE
--   </pre>
currentDate :: Expr (null  'PGdate)

-- | <pre>
--   &gt;&gt;&gt; printSQL currentTime
--   CURRENT_TIME
--   </pre>
currentTime :: Expr (null  'PGtimetz)

-- | <pre>
--   &gt;&gt;&gt; printSQL currentTimestamp
--   CURRENT_TIMESTAMP
--   </pre>
currentTimestamp :: Expr (null  'PGtimestamptz)

-- | <pre>
--   &gt;&gt;&gt; printSQL localTime
--   LOCALTIME
--   </pre>
localTime :: Expr (null  'PGtime)

-- | <pre>
--   &gt;&gt;&gt; printSQL localTimestamp
--   LOCALTIMESTAMP
--   </pre>
localTimestamp :: Expr (null  'PGtimestamp)

-- | Current date and time (equivalent to <a>currentTimestamp</a>)
--   
--   <pre>
--   &gt;&gt;&gt; printSQL now
--   now()
--   </pre>
now :: Expr (null  'PGtimestamptz)

-- | Create date from year, month and day fields
--   
--   <pre>
--   &gt;&gt;&gt; printSQL (makeDate (1984 :* 7 *: 3))
--   make_date(1984, 7, 3)
--   </pre>
makeDate :: FunctionN '[null  'PGint4, null  'PGint4, null  'PGint4] (null  'PGdate)

-- | Create time from hour, minute and seconds fields
--   
--   <pre>
--   &gt;&gt;&gt; printSQL (makeTime (8 :* 15 *: 23.5))
--   make_time(8, 15, 23.5)
--   </pre>
makeTime :: FunctionN '[null  'PGint4, null  'PGint4, null  'PGfloat8] (null  'PGtime)

-- | Create timestamp from year, month, day, hour, minute and seconds
--   fields
--   
--   <pre>
--   &gt;&gt;&gt; printSQL (makeTimestamp (2013 :* 7 :* 15 :* 8 :* 15 *: 23.5))
--   make_timestamp(2013, 7, 15, 8, 15, 23.5)
--   </pre>
makeTimestamp :: FunctionN '[null  'PGint4, null  'PGint4, null  'PGint4, null  'PGint4, null  'PGint4, null  'PGfloat8] (null  'PGtimestamp)

-- | Create timestamp with time zone from year, month, day, hour, minute
--   and seconds fields; the current time zone is used
--   
--   <pre>
--   &gt;&gt;&gt; printSQL (makeTimestamptz (2013 :* 7 :* 15 :* 8 :* 15 *: 23.5))
--   make_timestamptz(2013, 7, 15, 8, 15, 23.5)
--   </pre>
makeTimestamptz :: FunctionN '[null  'PGint4, null  'PGint4, null  'PGint4, null  'PGint4, null  'PGint4, null  'PGfloat8] (null  'PGtimestamptz)

-- | <pre>
--   &gt;&gt;&gt; printSQL $ interval_ 7 Days
--   (INTERVAL '7.0 days')
--   </pre>
interval_ :: Double -> TimeUnit -> Expr (null  'PGinterval)

-- | A <a>TimeUnit</a> to use in <a>interval_</a> construction.
data TimeUnit
Years :: TimeUnit
Months :: TimeUnit
Weeks :: TimeUnit
Days :: TimeUnit
Hours :: TimeUnit
Minutes :: TimeUnit
Seconds :: TimeUnit
Microseconds :: TimeUnit
Milliseconds :: TimeUnit
Decades :: TimeUnit
Centuries :: TimeUnit
Millennia :: TimeUnit
instance GHC.Generics.Generic Squeal.PostgreSQL.Expression.Time.TimeUnit
instance GHC.Enum.Enum Squeal.PostgreSQL.Expression.Time.TimeUnit
instance GHC.Read.Read Squeal.PostgreSQL.Expression.Time.TimeUnit
instance GHC.Show.Show Squeal.PostgreSQL.Expression.Time.TimeUnit
instance GHC.Classes.Ord Squeal.PostgreSQL.Expression.Time.TimeUnit
instance GHC.Classes.Eq Squeal.PostgreSQL.Expression.Time.TimeUnit
instance Generics.SOP.Universe.Generic Squeal.PostgreSQL.Expression.Time.TimeUnit
instance Generics.SOP.Universe.HasDatatypeInfo Squeal.PostgreSQL.Expression.Time.TimeUnit
instance Squeal.PostgreSQL.Render.RenderSQL Squeal.PostgreSQL.Expression.Time.TimeUnit
instance Squeal.PostgreSQL.Expression.Time.TimeOp 'Squeal.PostgreSQL.Schema.PGtimestamp 'Squeal.PostgreSQL.Schema.PGinterval
instance Squeal.PostgreSQL.Expression.Time.TimeOp 'Squeal.PostgreSQL.Schema.PGtimestamptz 'Squeal.PostgreSQL.Schema.PGinterval
instance Squeal.PostgreSQL.Expression.Time.TimeOp 'Squeal.PostgreSQL.Schema.PGtime 'Squeal.PostgreSQL.Schema.PGinterval
instance Squeal.PostgreSQL.Expression.Time.TimeOp 'Squeal.PostgreSQL.Schema.PGtimetz 'Squeal.PostgreSQL.Schema.PGinterval
instance Squeal.PostgreSQL.Expression.Time.TimeOp 'Squeal.PostgreSQL.Schema.PGinterval 'Squeal.PostgreSQL.Schema.PGinterval
instance Squeal.PostgreSQL.Expression.Time.TimeOp 'Squeal.PostgreSQL.Schema.PGdate 'Squeal.PostgreSQL.Schema.PGint4


-- | Text search functions and operators
module Squeal.PostgreSQL.Expression.TextSearch

-- | <a>tsvector</a> matches tsquery ?
(@@) :: Operator (null  'PGtsvector) (null  'PGtsquery) ( 'Null  'PGbool)

-- | AND <a>tsquery</a>s together
(.&) :: Operator (null  'PGtsquery) (null  'PGtsquery) (null  'PGtsquery)

-- | OR <a>tsquery</a>s together
(.|) :: Operator (null  'PGtsquery) (null  'PGtsquery) (null  'PGtsquery)

-- | negate a <a>tsquery</a>
(.!) :: null  'PGtsquery :--> null  'PGtsquery

-- | <a>tsquery</a> followed by <a>tsquery</a>
(<->) :: Operator (null  'PGtsquery) (null  'PGtsquery) (null  'PGtsquery)

-- | convert array of lexemes to <a>tsvector</a>
arrayToTSvector :: null ( 'PGvararray ( 'NotNull  'PGtext)) :--> null  'PGtsvector

-- | number of lexemes in <a>tsvector</a>
tsvectorLength :: null  'PGtsvector :--> null  'PGint4

-- | number of lexemes plus operators in <a>tsquery</a>
numnode :: null  'PGtsquery :--> null  'PGint4

-- | produce <a>tsquery</a> ignoring punctuation
plainToTSquery :: null  'PGtext :--> null  'PGtsquery

-- | produce <a>tsquery</a> that searches for a phrase, ignoring
--   punctuation
phraseToTSquery :: null  'PGtext :--> null  'PGtsquery

-- | produce <a>tsquery</a> from a web search style query
websearchToTSquery :: null  'PGtext :--> null  'PGtsquery

-- | get indexable part of a <a>tsquery</a>
queryTree :: null  'PGtsquery :--> null  'PGtext

-- | normalize words and convert to <a>tsquery</a>
toTSquery :: null  'PGtext :--> null  'PGtsquery

-- | reduce document text to <a>tsvector</a>
toTSvector :: ty `In` '[ 'PGtext,  'PGjson,  'PGjsonb] => null ty :--> null  'PGtsvector

-- | assign weight to each element of <a>tsvector</a>
setWeight :: FunctionN '[null  'PGtsvector, null ( 'PGchar 1)] (null  'PGtsvector)

-- | remove positions and weights from <a>tsvector</a>
strip :: null  'PGtsvector :--> null  'PGtsvector

-- | <tt>jsonToTSvector (document *: filter)</tt> reduce each value in the
--   document, specified by filter to a <a>tsvector</a>, and then
--   concatenate those in document order to produce a single
--   <a>tsvector</a>. filter is a <a>json</a> array, that enumerates what
--   kind of elements need to be included into the resulting
--   <a>tsvector</a>. Possible values for filter are "string" (to include
--   all string values), "numeric" (to include all numeric values in the
--   string format), "boolean" (to include all Boolean values in the string
--   format "true"/"false"), "key" (to include all keys) or "all" (to
--   include all above). These values can be combined together to include,
--   e.g. all string and numeric values.
jsonToTSvector :: FunctionN '[null  'PGjson, null  'PGjson] (null  'PGtsvector)

-- | <tt>jsonbToTSvector (document *: filter)</tt> reduce each value in the
--   document, specified by filter to a <a>tsvector</a>, and then
--   concatenate those in document order to produce a single
--   <a>tsvector</a>. filter is a <a>jsonb</a> array, that enumerates what
--   kind of elements need to be included into the resulting
--   <a>tsvector</a>. Possible values for filter are "string" (to include
--   all string values), "numeric" (to include all numeric values in the
--   string format), "boolean" (to include all Boolean values in the string
--   format "true"/"false"), "key" (to include all keys) or "all" (to
--   include all above). These values can be combined together to include,
--   e.g. all string and numeric values.
jsonbToTSvector :: FunctionN '[null  'PGjsonb, null  'PGjsonb] (null  'PGtsvector)

-- | remove given lexeme from <a>tsvector</a>
tsDelete :: FunctionN '[null  'PGtsvector, null ( 'PGvararray ( 'NotNull  'PGtext))] (null  'PGtsvector)

-- | select only elements with given weights from <a>tsvector</a>
tsFilter :: FunctionN '[null  'PGtsvector, null ( 'PGvararray ( 'NotNull ( 'PGchar 1)))] (null  'PGtsvector)

-- | display a <a>tsquery</a> match
tsHeadline :: document `In` '[ 'PGtext,  'PGjson,  'PGjsonb] => FunctionN '[null document, null  'PGtsquery] (null  'PGtext)


-- | String functions and operators
module Squeal.PostgreSQL.Expression.Text

-- | <pre>
--   &gt;&gt;&gt; printSQL $ lower "ARRRGGG"
--   lower(E'ARRRGGG')
--   </pre>
lower :: null  'PGtext :--> null  'PGtext

-- | <pre>
--   &gt;&gt;&gt; printSQL $ upper "eeee"
--   upper(E'eeee')
--   </pre>
upper :: null  'PGtext :--> null  'PGtext

-- | <pre>
--   &gt;&gt;&gt; printSQL $ charLength "four"
--   char_length(E'four')
--   </pre>
charLength :: null  'PGtext :--> null  'PGint4

-- | The <a>like</a> expression returns true if the <tt>string</tt> matches
--   the supplied <tt>pattern</tt>. If <tt>pattern</tt> does not contain
--   percent signs or underscores, then the pattern only represents the
--   string itself; in that case <a>like</a> acts like the equals operator.
--   An underscore (_) in pattern stands for (matches) any single
--   character; a percent sign (%) matches any sequence of zero or more
--   characters.
--   
--   <pre>
--   &gt;&gt;&gt; printSQL $ "abc" `like` "a%"
--   (E'abc' LIKE E'a%')
--   </pre>
like :: Operator (null  'PGtext) (null  'PGtext) ( 'Null  'PGbool)

-- | The key word ILIKE can be used instead of LIKE to make the match
--   case-insensitive according to the active locale.
--   
--   <pre>
--   &gt;&gt;&gt; printSQL $ "abc" `ilike` "a%"
--   (E'abc' ILIKE E'a%')
--   </pre>
ilike :: Operator (null  'PGtext) (null  'PGtext) ( 'Null  'PGbool)


-- | Sort expressions
module Squeal.PostgreSQL.Expression.Sort

-- | <a>SortExpression</a>s are used by <a>orderBy</a> to optionally sort
--   the results of a <a>Query</a>. <a>Asc</a> or <a>Desc</a> set the sort
--   direction of a <a>NotNull</a> result column to ascending or
--   descending. Ascending order puts smaller values first, where "smaller"
--   is defined in terms of the <a>.&lt;</a> operator. Similarly,
--   descending order is determined with the <a>.&gt;</a> operator.
--   <a>AscNullsFirst</a>, <a>AscNullsLast</a>, <a>DescNullsFirst</a> and
--   <a>DescNullsLast</a> options are used to determine whether nulls
--   appear before or after non-null values in the sort ordering of a
--   <a>Null</a> result column.
data SortExpression outer commons grp schemas params from
[Asc] :: Expression outer commons grp schemas params from ( 'NotNull ty) -> SortExpression outer commons grp schemas params from
[Desc] :: Expression outer commons grp schemas params from ( 'NotNull ty) -> SortExpression outer commons grp schemas params from
[AscNullsFirst] :: Expression outer commons grp schemas params from ( 'Null ty) -> SortExpression outer commons grp schemas params from
[AscNullsLast] :: Expression outer commons grp schemas params from ( 'Null ty) -> SortExpression outer commons grp schemas params from
[DescNullsFirst] :: Expression outer commons grp schemas params from ( 'Null ty) -> SortExpression outer commons grp schemas params from
[DescNullsLast] :: Expression outer commons grp schemas params from ( 'Null ty) -> SortExpression outer commons grp schemas params from

-- | The <a>orderBy</a> clause causes the result rows of a
--   <a>TableExpression</a> to be sorted according to the specified
--   <a>SortExpression</a>(s). If two rows are equal according to the
--   leftmost expression, they are compared according to the next
--   expression and so on. If they are equal according to all specified
--   expressions, they are returned in an implementation-dependent order.
--   
--   You can also control the order in which rows are processed by window
--   functions using <a>orderBy</a> within <a>Over</a>.
class OrderBy expr
orderBy :: OrderBy expr => [SortExpression outer commons grp schemas params from] -> expr outer commons grp schemas params from -> expr outer commons grp schemas params from
instance GHC.Show.Show (Squeal.PostgreSQL.Expression.Sort.SortExpression outer commons grp schemas params from)
instance Squeal.PostgreSQL.Render.RenderSQL (Squeal.PostgreSQL.Expression.Sort.SortExpression outer commons grp schemas params from)


-- | Parameters, out-of-line data values
module Squeal.PostgreSQL.Expression.Parameter

-- | A <a>HasParameter</a> constraint is used to indicate a value that is
--   supplied externally to a SQL statement. <a>manipulateParams</a>,
--   <a>queryParams</a> and <a>traversePrepared</a> support specifying data
--   values separately from the SQL command string, in which case
--   <a>param</a>s are used to refer to the out-of-line data values.
class KnownNat n => HasParameter (n :: Nat) (params :: [NullityType]) (ty :: NullityType) | n params -> ty

-- | <a>parameter</a> takes a <a>Nat</a> using type application and a
--   <a>TypeExpression</a>.
--   
--   <pre>
--   &gt;&gt;&gt; let expr = parameter @1 int4 :: Expression outer '[] grp schemas '[ 'Null 'PGint4] from ('Null 'PGint4)
--   
--   &gt;&gt;&gt; printSQL expr
--   ($1 :: int4)
--   </pre>
parameter :: HasParameter n params ty => TypeExpression schemas ty -> Expression outer commons grp schemas params from ty

-- | <a>param</a> takes a <a>Nat</a> using type application and for basic
--   types, infers a <a>TypeExpression</a>.
--   
--   <pre>
--   &gt;&gt;&gt; let expr = param @1 :: Expression outer commons grp schemas '[ 'Null 'PGint4] from ('Null 'PGint4)
--   
--   &gt;&gt;&gt; printSQL expr
--   ($1 :: int4)
--   </pre>
param :: forall n outer commons schemas params from grp ty. (PGTyped schemas ty, HasParameter n params ty) => Expression outer commons grp schemas params from ty
instance Squeal.PostgreSQL.Expression.Parameter.HasParameter 1 (ty1 : tys) ty1
instance (GHC.TypeNats.KnownNat n, Squeal.PostgreSQL.Expression.Parameter.HasParameter (n GHC.TypeNats.- 1) params ty) => Squeal.PostgreSQL.Expression.Parameter.HasParameter n (ty' : params) ty


-- | Mathematical functions and operators
module Squeal.PostgreSQL.Expression.Math

-- | <pre>
--   &gt;&gt;&gt; :{
--   let
--     expression :: Expr (null 'PGfloat4)
--     expression = atan2_ (pi *: 2)
--   in printSQL expression
--   :}
--   atan2(pi(), 2)
--   </pre>
atan2_ :: float `In` PGFloating => FunctionN '[null float, null float] (null float)

-- | integer division, truncates the result
--   
--   <pre>
--   &gt;&gt;&gt; :{
--   let
--     expression :: Expression outer commons grp schemas params from (null 'PGint2)
--     expression = 5 `quot_` 2
--   in printSQL expression
--   :}
--   (5 / 2)
--   </pre>
quot_ :: int `In` PGIntegral => Operator (null int) (null int) (null int)

-- | remainder upon integer division
--   
--   <pre>
--   &gt;&gt;&gt; :{
--   let
--     expression :: Expression outer commons grp schemas params from (null 'PGint2)
--     expression = 5 `rem_` 2
--   in printSQL expression
--   :}
--   (5 % 2)
--   </pre>
rem_ :: int `In` PGIntegral => Operator (null int) (null int) (null int)

-- | <pre>
--   &gt;&gt;&gt; :{
--   let
--     expression :: Expression outer commons grp schemas params from (null 'PGfloat4)
--     expression = trunc pi
--   in printSQL expression
--   :}
--   trunc(pi())
--   </pre>
trunc :: frac `In` PGFloating => null frac :--> null frac

-- | <pre>
--   &gt;&gt;&gt; :{
--   let
--     expression :: Expression outer commons grp schemas params from (null 'PGfloat4)
--     expression = round_ pi
--   in printSQL expression
--   :}
--   round(pi())
--   </pre>
round_ :: frac `In` PGFloating => null frac :--> null frac

-- | <pre>
--   &gt;&gt;&gt; :{
--   let
--     expression :: Expression outer commons grp schemas params from (null 'PGfloat4)
--     expression = ceiling_ pi
--   in printSQL expression
--   :}
--   ceiling(pi())
--   </pre>
ceiling_ :: frac `In` PGFloating => null frac :--> null frac


-- | Logical expressions and operators
module Squeal.PostgreSQL.Expression.Logic

-- | A <a>Condition</a> is an <a>Expression</a>, which can evaluate to
--   <a>true</a>, <a>false</a> or <a>null_</a>. This is because SQL uses a
--   three valued logic.
type Condition outer commons grp schemas params from = Expression outer commons grp schemas params from ( 'Null  'PGbool)

-- | <pre>
--   &gt;&gt;&gt; printSQL true
--   TRUE
--   </pre>
true :: Expr (null  'PGbool)

-- | <pre>
--   &gt;&gt;&gt; printSQL false
--   FALSE
--   </pre>
false :: Expr (null  'PGbool)

-- | <pre>
--   &gt;&gt;&gt; printSQL $ not_ true
--   (NOT TRUE)
--   </pre>
not_ :: null  'PGbool :--> null  'PGbool

-- | <pre>
--   &gt;&gt;&gt; printSQL $ true .&amp;&amp; false
--   (TRUE AND FALSE)
--   </pre>
(.&&) :: Operator (null  'PGbool) (null  'PGbool) (null  'PGbool)
infixr 3 .&&

-- | <pre>
--   &gt;&gt;&gt; printSQL $ true .|| false
--   (TRUE OR FALSE)
--   </pre>
(.||) :: Operator (null  'PGbool) (null  'PGbool) (null  'PGbool)
infixr 2 .||

-- | <pre>
--   &gt;&gt;&gt; :{
--   let
--     expression :: Expression outer commons grp schemas params from (null 'PGint2)
--     expression = caseWhenThenElse [(true, 1), (false, 2)] 3
--   in printSQL expression
--   :}
--   CASE WHEN TRUE THEN 1 WHEN FALSE THEN 2 ELSE 3 END
--   </pre>
caseWhenThenElse :: [(Condition outer commons grp schemas params from, Expression outer commons grp schemas params from ty)] -> Expression outer commons grp schemas params from ty -> Expression outer commons grp schemas params from ty

-- | <pre>
--   &gt;&gt;&gt; :{
--   let
--     expression :: Expression outer commons grp schemas params from (null 'PGint2)
--     expression = ifThenElse true 1 0
--   in printSQL expression
--   :}
--   CASE WHEN TRUE THEN 1 ELSE 0 END
--   </pre>
ifThenElse :: Condition outer commons grp schemas params from -> Expression outer commons grp schemas params from ty -> Expression outer commons grp schemas params from ty -> Expression outer commons grp schemas params from ty


-- | Null values and null handling functions
module Squeal.PostgreSQL.Expression.Null

-- | analagous to <a>Nothing</a>
--   
--   <pre>
--   &gt;&gt;&gt; printSQL null_
--   NULL
--   </pre>
null_ :: Expr ( 'Null ty)

-- | analagous to <a>Just</a>
--   
--   <pre>
--   &gt;&gt;&gt; printSQL $ notNull true
--   TRUE
--   </pre>
notNull :: 'NotNull ty :-->  'Null ty

-- | return the leftmost value which is not NULL
--   
--   <pre>
--   &gt;&gt;&gt; printSQL $ coalesce [null_, true] false
--   COALESCE(NULL, TRUE, FALSE)
--   </pre>
coalesce :: FunctionVar ( 'Null ty) ( 'NotNull ty) ( 'NotNull ty)

-- | analagous to <a>fromMaybe</a> using <tt>COALESCE</tt>
--   
--   <pre>
--   &gt;&gt;&gt; printSQL $ fromNull true null_
--   COALESCE(NULL, TRUE)
--   </pre>
fromNull :: Expression outer commons grp schemas params from ( 'NotNull ty) -> Expression outer commons grp schemas params from ( 'Null ty) -> Expression outer commons grp schemas params from ( 'NotNull ty)

-- | <pre>
--   &gt;&gt;&gt; printSQL $ null_ &amp; isNull
--   NULL IS NULL
--   </pre>
isNull :: 'Null ty :--> null  'PGbool

-- | <pre>
--   &gt;&gt;&gt; printSQL $ null_ &amp; isNotNull
--   NULL IS NOT NULL
--   </pre>
isNotNull :: 'Null ty :--> null  'PGbool

-- | analagous to <a>maybe</a> using <tt>IS NULL</tt>
--   
--   <pre>
--   &gt;&gt;&gt; printSQL $ matchNull true not_ null_
--   CASE WHEN NULL IS NULL THEN TRUE ELSE (NOT NULL) END
--   </pre>
matchNull :: Expression outer commons grp schemas params from nullty -> (Expression outer commons grp schemas params from ( 'NotNull ty) -> Expression outer commons grp schemas params from nullty) -> Expression outer commons grp schemas params from ( 'Null ty) -> Expression outer commons grp schemas params from nullty

-- | right inverse to <a>fromNull</a>, if its arguments are equal then
--   <a>nullIf</a> gives <tt>NULL</tt>.
--   
--   <pre>
--   &gt;&gt;&gt; :set -XTypeApplications -XDataKinds
--   
--   &gt;&gt;&gt; let expr = nullIf (false *: param @1) :: Expression outer commons grp schemas '[ 'NotNull 'PGbool] from ('Null 'PGbool)
--   
--   &gt;&gt;&gt; printSQL expr
--   NULLIF(FALSE, ($1 :: bool))
--   </pre>
nullIf :: FunctionN '[ 'NotNull ty,  'NotNull ty] ( 'Null ty)


-- | Comparison functions and operators
module Squeal.PostgreSQL.Expression.Comparison

-- | Comparison operations like <a>.==</a>, <a>./=</a>, <a>.&gt;</a>,
--   <a>.&gt;=</a>, <a>.&lt;</a> and <a>.&lt;=</a> will produce
--   <tt>NULL</tt>s if one of their arguments is <tt>NULL</tt>.
--   
--   <pre>
--   &gt;&gt;&gt; printSQL $ true .== null_
--   (TRUE = NULL)
--   </pre>
(.==) :: Operator (null0 ty) (null1 ty) ( 'Null  'PGbool)
infix 4 .==

-- | <pre>
--   &gt;&gt;&gt; printSQL $ true ./= null_
--   (TRUE &lt;&gt; NULL)
--   </pre>
(./=) :: Operator (null0 ty) (null1 ty) ( 'Null  'PGbool)
infix 4 ./=

-- | <pre>
--   &gt;&gt;&gt; printSQL $ true .&gt;= null_
--   (TRUE &gt;= NULL)
--   </pre>
(.>=) :: Operator (null0 ty) (null1 ty) ( 'Null  'PGbool)
infix 4 .>=

-- | <pre>
--   &gt;&gt;&gt; printSQL $ true .&lt; null_
--   (TRUE &lt; NULL)
--   </pre>
(.<) :: Operator (null0 ty) (null1 ty) ( 'Null  'PGbool)
infix 4 .<

-- | <pre>
--   &gt;&gt;&gt; printSQL $ true .&lt;= null_
--   (TRUE &lt;= NULL)
--   </pre>
(.<=) :: Operator (null0 ty) (null1 ty) ( 'Null  'PGbool)
infix 4 .<=

-- | <pre>
--   &gt;&gt;&gt; printSQL $ true .&gt; null_
--   (TRUE &gt; NULL)
--   </pre>
(.>) :: Operator (null0 ty) (null1 ty) ( 'Null  'PGbool)
infix 4 .>

-- | <pre>
--   &gt;&gt;&gt; let expr = greatest [param @1] currentTimestamp :: Expression outer commons grp schemas '[ 'NotNull 'PGtimestamptz] from ('NotNull 'PGtimestamptz)
--   
--   &gt;&gt;&gt; printSQL expr
--   GREATEST(($1 :: timestamp with time zone), CURRENT_TIMESTAMP)
--   </pre>
greatest :: FunctionVar ty ty ty

-- | <pre>
--   &gt;&gt;&gt; printSQL $ least [null_] currentTimestamp
--   LEAST(NULL, CURRENT_TIMESTAMP)
--   </pre>
least :: FunctionVar ty ty ty

-- | A <tt>RankNType</tt> for comparison expressions like <a>between</a>.
type BetweenExpr = forall outer commons grp schemas params from ty. Expression outer commons grp schemas params from ty -> (Expression outer commons grp schemas params from ty, Expression outer commons grp schemas params from ty) " bounds" -> Condition outer commons grp schemas params from

-- | <pre>
--   &gt;&gt;&gt; printSQL $ true `between` (null_, false)
--   TRUE BETWEEN NULL AND FALSE
--   </pre>
between :: BetweenExpr

-- | <pre>
--   &gt;&gt;&gt; printSQL $ true `notBetween` (null_, false)
--   TRUE NOT BETWEEN NULL AND FALSE
--   </pre>
notBetween :: BetweenExpr

-- | between, after sorting the comparison values
--   
--   <pre>
--   &gt;&gt;&gt; printSQL $ true `betweenSymmetric` (null_, false)
--   TRUE BETWEEN SYMMETRIC NULL AND FALSE
--   </pre>
betweenSymmetric :: BetweenExpr

-- | not between, after sorting the comparison values
--   
--   <pre>
--   &gt;&gt;&gt; printSQL $ true `notBetweenSymmetric` (null_, false)
--   TRUE NOT BETWEEN SYMMETRIC NULL AND FALSE
--   </pre>
notBetweenSymmetric :: BetweenExpr

-- | not equal, treating null like an ordinary value
--   
--   <pre>
--   &gt;&gt;&gt; printSQL $ true `isDistinctFrom` null_
--   (TRUE IS DISTINCT FROM NULL)
--   </pre>
isDistinctFrom :: Operator (null0 ty) (null1 ty) ( 'Null  'PGbool)

-- | equal, treating null like an ordinary value
--   
--   <pre>
--   &gt;&gt;&gt; printSQL $ true `isNotDistinctFrom` null_
--   (TRUE IS NOT DISTINCT FROM NULL)
--   </pre>
isNotDistinctFrom :: Operator (null0 ty) (null1 ty) ( 'NotNull  'PGbool)

-- | is true
--   
--   <pre>
--   &gt;&gt;&gt; printSQL $ true &amp; isTrue
--   (TRUE IS TRUE)
--   </pre>
isTrue :: null0  'PGbool :--> null1  'PGbool

-- | is false or unknown
--   
--   <pre>
--   &gt;&gt;&gt; printSQL $ true &amp; isNotTrue
--   (TRUE IS NOT TRUE)
--   </pre>
isNotTrue :: null0  'PGbool :--> null1  'PGbool

-- | is false
--   
--   <pre>
--   &gt;&gt;&gt; printSQL $ true &amp; isFalse
--   (TRUE IS FALSE)
--   </pre>
isFalse :: null0  'PGbool :--> null1  'PGbool

-- | is true or unknown
--   
--   <pre>
--   &gt;&gt;&gt; printSQL $ true &amp; isNotFalse
--   (TRUE IS NOT FALSE)
--   </pre>
isNotFalse :: null0  'PGbool :--> null1  'PGbool

-- | is unknown
--   
--   <pre>
--   &gt;&gt;&gt; printSQL $ true &amp; isUnknown
--   (TRUE IS UNKNOWN)
--   </pre>
isUnknown :: null0  'PGbool :--> null1  'PGbool

-- | is true or false
--   
--   <pre>
--   &gt;&gt;&gt; printSQL $ true &amp; isNotUnknown
--   (TRUE IS NOT UNKNOWN)
--   </pre>
isNotUnknown :: null0  'PGbool :--> null1  'PGbool


-- | Aggregate functions
module Squeal.PostgreSQL.Expression.Aggregate

-- | <a>Aggregate</a> functions compute a single result from a set of input
--   values. <a>Aggregate</a> functions can be used as <a>GroupedBy</a>
--   <a>Expression</a>s as well as <a>WindowFunction</a>s.
class Aggregate expr1 exprN aggr | aggr -> expr1, aggr -> exprN

-- | A special aggregation that does not require an input
--   
--   <pre>
--   &gt;&gt;&gt; :{
--   let
--     expression :: Expression '[] commons ('Grouped bys) schemas params from ('NotNull 'PGint8)
--     expression = countStar
--   in printSQL expression
--   :}
--   count(*)
--   </pre>
countStar :: Aggregate expr1 exprN aggr => aggr ( 'NotNull  'PGint8)

-- | <pre>
--   &gt;&gt;&gt; :{
--   let
--     expression :: Expression '[] commons ('Grouped bys) schemas params '[tab ::: '["col" ::: null ty]] ('NotNull 'PGint8)
--     expression = count (All #col)
--   in printSQL expression
--   :}
--   count(ALL "col")
--   </pre>
count :: Aggregate expr1 exprN aggr => expr1 ty -> aggr ( 'NotNull  'PGint8)

-- | <pre>
--   &gt;&gt;&gt; :{
--   let
--     expression :: Expression '[] commons ('Grouped bys) schemas params '[tab ::: '["col" ::: 'Null 'PGnumeric]] ('Null 'PGnumeric)
--     expression = sum_ (Distinct #col)
--   in printSQL expression
--   :}
--   sum(DISTINCT "col")
--   </pre>
sum_ :: Aggregate expr1 exprN aggr => expr1 (null ty) -> aggr ( 'Null (PGSum ty))

-- | input values, including nulls, concatenated into an array
arrayAgg :: Aggregate expr1 exprN aggr => expr1 ty -> aggr ( 'Null ( 'PGvararray ty))

-- | aggregates values as a JSON array
jsonAgg :: Aggregate expr1 exprN aggr => expr1 ty -> aggr ( 'Null  'PGjson)

-- | aggregates values as a JSON array
jsonbAgg :: Aggregate expr1 exprN aggr => expr1 ty -> aggr ( 'Null  'PGjsonb)

-- | the bitwise AND of all non-null input values, or null if none
--   
--   <pre>
--   &gt;&gt;&gt; :{
--   let
--     expression :: Expression '[] commons ('Grouped bys) schemas params '[tab ::: '["col" ::: null 'PGint4]] ('Null 'PGint4)
--     expression = bitAnd (Distinct #col)
--   in printSQL expression
--   :}
--   bit_and(DISTINCT "col")
--   </pre>
bitAnd :: (Aggregate expr1 exprN aggr, int `In` PGIntegral) => expr1 (null int) -> aggr ( 'Null int)

-- | the bitwise OR of all non-null input values, or null if none
--   
--   <pre>
--   &gt;&gt;&gt; :{
--   let
--     expression :: Expression '[] commons ('Grouped bys) schemas params '[tab ::: '["col" ::: null 'PGint4]] ('Null 'PGint4)
--     expression = bitOr (All #col)
--   in printSQL expression
--   :}
--   bit_or(ALL "col")
--   </pre>
bitOr :: (Aggregate expr1 exprN aggr, int `In` PGIntegral) => expr1 (null int) -> aggr ( 'Null int)

-- | true if all input values are true, otherwise false
--   
--   <pre>
--   &gt;&gt;&gt; :{
--   let
--     winFun :: WindowFunction '[] commons 'Ungrouped schemas params '[tab ::: '["col" ::: null 'PGbool]] ('Null 'PGbool)
--     winFun = boolAnd #col
--   in printSQL winFun
--   :}
--   bool_and("col")
--   </pre>
boolAnd :: Aggregate expr1 exprN aggr => expr1 (null  'PGbool) -> aggr ( 'Null  'PGbool)

-- | true if at least one input value is true, otherwise false
--   
--   <pre>
--   &gt;&gt;&gt; :{
--   let
--     expression :: Expression '[] commons ('Grouped bys) schemas params '[tab ::: '["col" ::: null 'PGbool]] ('Null 'PGbool)
--     expression = boolOr (All #col)
--   in printSQL expression
--   :}
--   bool_or(ALL "col")
--   </pre>
boolOr :: Aggregate expr1 exprN aggr => expr1 (null  'PGbool) -> aggr ( 'Null  'PGbool)

-- | equivalent to <a>boolAnd</a>
--   
--   <pre>
--   &gt;&gt;&gt; :{
--   let
--     expression :: Expression '[] commons ('Grouped bys) schemas params '[tab ::: '["col" ::: null 'PGbool]] ('Null 'PGbool)
--     expression = every (Distinct #col)
--   in printSQL expression
--   :}
--   every(DISTINCT "col")
--   </pre>
every :: Aggregate expr1 exprN aggr => expr1 (null  'PGbool) -> aggr ( 'Null  'PGbool)

-- | maximum value of expression across all input values
max_ :: Aggregate expr1 exprN aggr => expr1 (null ty) -> aggr ( 'Null ty)

-- | minimum value of expression across all input values
min_ :: Aggregate expr1 exprN aggr => expr1 (null ty) -> aggr ( 'Null ty)

-- | the average (arithmetic mean) of all input values
avg :: Aggregate expr1 exprN aggr => expr1 (null ty) -> aggr ( 'Null (PGAvg ty))

-- | correlation coefficient
--   
--   <pre>
--   &gt;&gt;&gt; :{
--   let
--     expression :: Expression '[] c ('Grouped g) s p '[t ::: '["x" ::: 'NotNull 'PGfloat8, "y" ::: 'NotNull 'PGfloat8]] ('Null 'PGfloat8)
--     expression = corr (All (#y *: #x))
--   in printSQL expression
--   :}
--   corr(ALL "y", "x")
--   </pre>
corr :: Aggregate expr1 exprN aggr => exprN '[null  'PGfloat8, null  'PGfloat8] -> aggr ( 'Null  'PGfloat8)

-- | population covariance
--   
--   <pre>
--   &gt;&gt;&gt; :{
--   let
--     expression :: Expression '[] c ('Grouped g) s p '[t ::: '["x" ::: 'NotNull 'PGfloat8, "y" ::: 'NotNull 'PGfloat8]] ('Null 'PGfloat8)
--     expression = covarPop (All (#y *: #x))
--   in printSQL expression
--   :}
--   covar_pop(ALL "y", "x")
--   </pre>
covarPop :: Aggregate expr1 exprN aggr => exprN '[null  'PGfloat8, null  'PGfloat8] -> aggr ( 'Null  'PGfloat8)

-- | sample covariance
--   
--   <pre>
--   &gt;&gt;&gt; :{
--   let
--     winFun :: WindowFunction '[] c 'Ungrouped s p '[t ::: '["x" ::: 'NotNull 'PGfloat8, "y" ::: 'NotNull 'PGfloat8]] ('Null 'PGfloat8)
--     winFun = covarSamp (#y *: #x)
--   in printSQL winFun
--   :}
--   covar_samp("y", "x")
--   </pre>
covarSamp :: Aggregate expr1 exprN aggr => exprN '[null  'PGfloat8, null  'PGfloat8] -> aggr ( 'Null  'PGfloat8)

-- | average of the independent variable (sum(X)/N)
--   
--   <pre>
--   &gt;&gt;&gt; :{
--   let
--     expression :: Expression '[] c ('Grouped g) s p '[t ::: '["x" ::: 'NotNull 'PGfloat8, "y" ::: 'NotNull 'PGfloat8]] ('Null 'PGfloat8)
--     expression = regrAvgX (All (#y *: #x))
--   in printSQL expression
--   :}
--   regr_avgx(ALL "y", "x")
--   </pre>
regrAvgX :: Aggregate expr1 exprN aggr => exprN '[null  'PGfloat8, null  'PGfloat8] -> aggr ( 'Null  'PGfloat8)

-- | average of the dependent variable (sum(Y)/N)
--   
--   <pre>
--   &gt;&gt;&gt; :{
--   let
--     winFun :: WindowFunction '[] c 'Ungrouped s p '[t ::: '["x" ::: 'NotNull 'PGfloat8, "y" ::: 'NotNull 'PGfloat8]] ('Null 'PGfloat8)
--     winFun = regrAvgY (#y *: #x)
--   in printSQL winFun
--   :}
--   regr_avgy("y", "x")
--   </pre>
regrAvgY :: Aggregate expr1 exprN aggr => exprN '[null  'PGfloat8, null  'PGfloat8] -> aggr ( 'Null  'PGfloat8)

-- | number of input rows in which both expressions are nonnull
--   
--   <pre>
--   &gt;&gt;&gt; :{
--   let
--     winFun :: WindowFunction '[] c 'Ungrouped s p '[t ::: '["x" ::: 'NotNull 'PGfloat8, "y" ::: 'NotNull 'PGfloat8]] ('Null 'PGint8)
--     winFun = regrCount (#y *: #x)
--   in printSQL winFun
--   :}
--   regr_count("y", "x")
--   </pre>
regrCount :: Aggregate expr1 exprN aggr => exprN '[null  'PGfloat8, null  'PGfloat8] -> aggr ( 'Null  'PGint8)

-- | y-intercept of the least-squares-fit linear equation determined by the
--   (X, Y) pairs &gt;&gt;&gt; :{ let expression :: Expression '[] c
--   ('Grouped g) s p '[t ::: '["x" ::: 'NotNull 'PGfloat8, "y" :::
--   'NotNull 'PGfloat8]] ('Null 'PGfloat8) expression = regrIntercept (All
--   (x)) in printSQL expression :} regr_intercept(ALL "y", "x")
regrIntercept :: Aggregate expr1 exprN aggr => exprN '[null  'PGfloat8, null  'PGfloat8] -> aggr ( 'Null  'PGfloat8)

-- | <tt>regr_r2(Y, X)</tt>, square of the correlation coefficient
regrR2 :: Aggregate expr1 exprN aggr => exprN '[null  'PGfloat8, null  'PGfloat8] -> aggr ( 'Null  'PGfloat8)

-- | <tt>regr_slope(Y, X)</tt>, slope of the least-squares-fit linear
--   equation determined by the (X, Y) pairs
regrSlope :: Aggregate expr1 exprN aggr => exprN '[null  'PGfloat8, null  'PGfloat8] -> aggr ( 'Null  'PGfloat8)

-- | <tt>regr_sxx(Y, X)</tt>, sum(X^2) - sum(X)^2/N (“sum of squares” of
--   the independent variable)
regrSxx :: Aggregate expr1 exprN aggr => exprN '[null  'PGfloat8, null  'PGfloat8] -> aggr ( 'Null  'PGfloat8)

-- | <tt>regr_sxy(Y, X)</tt>, sum(X*Y) - sum(X) * sum(Y)/N (“sum of
--   products” of independent times dependent variable)
regrSxy :: Aggregate expr1 exprN aggr => exprN '[null  'PGfloat8, null  'PGfloat8] -> aggr ( 'Null  'PGfloat8)

-- | <tt>regr_syy(Y, X)</tt>, sum(Y^2) - sum(Y)^2/N (“sum of squares” of
--   the dependent variable)
regrSyy :: Aggregate expr1 exprN aggr => exprN '[null  'PGfloat8, null  'PGfloat8] -> aggr ( 'Null  'PGfloat8)

-- | historical alias for <a>stddevSamp</a>
stddev :: Aggregate expr1 exprN aggr => expr1 (null ty) -> aggr ( 'Null (PGAvg ty))

-- | population standard deviation of the input values
stddevPop :: Aggregate expr1 exprN aggr => expr1 (null ty) -> aggr ( 'Null (PGAvg ty))

-- | sample standard deviation of the input values
stddevSamp :: Aggregate expr1 exprN aggr => expr1 (null ty) -> aggr ( 'Null (PGAvg ty))

-- | historical alias for <a>varSamp</a>
variance :: Aggregate expr1 exprN aggr => expr1 (null ty) -> aggr ( 'Null (PGAvg ty))

-- | population variance of the input values (square of the population
--   standard deviation)
varPop :: Aggregate expr1 exprN aggr => expr1 (null ty) -> aggr ( 'Null (PGAvg ty))

-- | sample variance of the input values (square of the sample standard
--   deviation)
varSamp :: Aggregate expr1 exprN aggr => expr1 (null ty) -> aggr ( 'Null (PGAvg ty))

-- | <a>Distinction</a>s are used for the input of <a>Aggregate</a>
--   <a>Expression</a>s. <a>All</a> invokes the aggregate once for each
--   input row. <a>Distinct</a> invokes the aggregate once for each
--   distinct value of the expression (or distinct set of values, for
--   multiple expressions) found in the input
data Distinction (expr :: kind -> Type) (ty :: kind)
All :: expr ty -> Distinction
Distinct :: expr ty -> Distinction

-- | A type family that calculates <a>PGSum</a><a>PGType</a> of a given
--   argument <a>PGType</a>.
type family PGSum ty

-- | A type family that calculates <a>PGAvg</a> type of a <a>PGType</a>.
type family PGAvg ty
instance forall kind (expr :: kind -> *) (ty :: kind). GHC.Classes.Ord (expr ty) => GHC.Classes.Ord (Squeal.PostgreSQL.Expression.Aggregate.Distinction expr ty)
instance forall kind (expr :: kind -> *) (ty :: kind). GHC.Classes.Eq (expr ty) => GHC.Classes.Eq (Squeal.PostgreSQL.Expression.Aggregate.Distinction expr ty)
instance forall kind (expr :: kind -> *) (ty :: kind). GHC.Show.Show (expr ty) => GHC.Show.Show (Squeal.PostgreSQL.Expression.Aggregate.Distinction expr ty)
instance forall kind (expr :: kind -> *) (ty :: kind). GHC.Generics.Generic (Squeal.PostgreSQL.Expression.Aggregate.Distinction expr ty)
instance Squeal.PostgreSQL.Expression.Aggregate.Aggregate (Squeal.PostgreSQL.Expression.Aggregate.Distinction (Squeal.PostgreSQL.Expression.Expression outer commons 'Squeal.PostgreSQL.Alias.Ungrouped schemas params from)) (Squeal.PostgreSQL.Expression.Aggregate.Distinction (Data.SOP.NP.NP (Squeal.PostgreSQL.Expression.Expression outer commons 'Squeal.PostgreSQL.Alias.Ungrouped schemas params from))) (Squeal.PostgreSQL.Expression.Expression outer commons ('Squeal.PostgreSQL.Alias.Grouped bys) schemas params from)
instance Control.DeepSeq.NFData (Squeal.PostgreSQL.Expression.Aggregate.Distinction (Squeal.PostgreSQL.Expression.Expression outer commons grp schemas params from) ty)
instance Squeal.PostgreSQL.Render.RenderSQL (Squeal.PostgreSQL.Expression.Aggregate.Distinction (Squeal.PostgreSQL.Expression.Expression outer commons grp schemas params from) ty)
instance Data.SOP.Constraint.SListI tys => Squeal.PostgreSQL.Render.RenderSQL (Squeal.PostgreSQL.Expression.Aggregate.Distinction (Data.SOP.NP.NP (Squeal.PostgreSQL.Expression.Expression outer commons grp schemas params from)) tys)


-- | Window functions and definitions
module Squeal.PostgreSQL.Expression.Window

-- | The <a>partitionBy</a> clause within <a>Over</a> divides the rows into
--   groups, or partitions, that share the same values of the
--   <a>partitionBy</a> <a>Expression</a>(s). For each row, the window
--   function is computed across the rows that fall into the same partition
--   as the current row.
partitionBy :: SListI bys => NP (Expression outer commons grp schemas params from) bys -> WindowDefinition outer commons grp schemas params from

-- | rank of the current row with gaps; same as <a>rowNumber</a> of its
--   first peer
--   
--   <pre>
--   &gt;&gt;&gt; printSQL rank
--   rank()
--   </pre>
rank :: WinFun0 ( 'NotNull  'PGint8)

-- | number of the current row within its partition, counting from 1
--   
--   <pre>
--   &gt;&gt;&gt; printSQL rowNumber
--   row_number()
--   </pre>
rowNumber :: WinFun0 ( 'NotNull  'PGint8)

-- | rank of the current row without gaps; this function counts peer groups
--   
--   <pre>
--   &gt;&gt;&gt; printSQL denseRank
--   dense_rank()
--   </pre>
denseRank :: WinFun0 ( 'NotNull  'PGint8)

-- | relative rank of the current row: (rank - 1) / (total partition rows -
--   1)
--   
--   <pre>
--   &gt;&gt;&gt; printSQL percentRank
--   percent_rank()
--   </pre>
percentRank :: WinFun0 ( 'NotNull  'PGfloat8)

-- | cumulative distribution: (number of partition rows preceding or peer
--   with current row) / total partition rows
--   
--   <pre>
--   &gt;&gt;&gt; printSQL cumeDist
--   cume_dist()
--   </pre>
cumeDist :: WinFun0 ( 'NotNull  'PGfloat8)

-- | integer ranging from 1 to the argument value, dividing the partition
--   as equally as possible
--   
--   <pre>
--   &gt;&gt;&gt; printSQL $ ntile 5
--   ntile(5)
--   </pre>
ntile :: WinFun1 ( 'NotNull  'PGint4) ( 'NotNull  'PGint4)

-- | returns value evaluated at the row that is offset rows before the
--   current row within the partition; if there is no such row, instead
--   return default (which must be of the same type as value). Both offset
--   and default are evaluated with respect to the current row.
lag :: WinFunN '[ty,  'NotNull  'PGint4, ty] ty

-- | returns value evaluated at the row that is offset rows after the
--   current row within the partition; if there is no such row, instead
--   return default (which must be of the same type as value). Both offset
--   and default are evaluated with respect to the current row.
lead :: WinFunN '[ty,  'NotNull  'PGint4, ty] ty

-- | returns value evaluated at the row that is the first row of the window
--   frame
firstValue :: WinFun1 ty ty

-- | returns value evaluated at the row that is the last row of the window
--   frame
lastValue :: WinFun1 ty ty

-- | returns value evaluated at the row that is the nth row of the window
--   frame (counting from 1); null if no such row
nthValue :: WinFunN '[null ty,  'NotNull  'PGint4] ( 'Null ty)

-- | escape hatch for defining window functions
unsafeWindowFunction1 :: ByteString -> WinFun1 x y

-- | escape hatch for defining multi-argument window functions
unsafeWindowFunctionN :: SListI xs => ByteString -> WinFunN xs y

-- | A window function performs a calculation across a set of table rows
--   that are somehow related to the current row. This is comparable to the
--   type of calculation that can be done with an aggregate function.
--   However, window functions do not cause rows to become grouped into a
--   single output row like non-window aggregate calls would. Instead, the
--   rows retain their separate identities. Behind the scenes, the window
--   function is able to access more than just the current row of the query
--   result.
newtype WindowFunction (outer :: FromType) (commons :: FromType) (grp :: Grouping) (schemas :: SchemasType) (params :: [NullityType]) (from :: FromType) (ty :: NullityType)
UnsafeWindowFunction :: ByteString -> WindowFunction
[renderWindowFunction] :: WindowFunction -> ByteString

-- | A <a>WindowDefinition</a> is a set of table rows that are somehow
--   related to the current row
data WindowDefinition outer commons grp schemas params from
[WindowDefinition] :: SListI bys => NP (Expression outer commons grp schemas params from) bys -> [SortExpression outer commons grp schemas params from] -> WindowDefinition outer commons grp schemas params from

-- | A <tt>RankNType</tt> for window functions with no arguments.
type WinFun0 x = forall outer commons grp schemas params from. WindowFunction outer commons grp schemas params from x " cannot reference aliases"

-- | A <tt>RankNType</tt> for window functions with 1 argument.
type WinFun1 x y = forall outer commons grp schemas params from. Expression outer commons grp schemas params from x " input" -> WindowFunction outer commons grp schemas params from y " output"

-- | A <tt>RankNType</tt> for window functions with a fixed-length list of
--   heterogeneous arguments. Use the <a>*:</a> operator to end your
--   argument lists.
type WinFunN xs y = forall outer commons grp schemas params from. NP (Expression outer commons grp schemas params from) xs " inputs" -> WindowFunction outer commons grp schemas params from y " output"
instance Control.DeepSeq.NFData (Squeal.PostgreSQL.Expression.Window.WindowFunction outer commons grp schemas params from ty)
instance GHC.Classes.Ord (Squeal.PostgreSQL.Expression.Window.WindowFunction outer commons grp schemas params from ty)
instance GHC.Classes.Eq (Squeal.PostgreSQL.Expression.Window.WindowFunction outer commons grp schemas params from ty)
instance GHC.Show.Show (Squeal.PostgreSQL.Expression.Window.WindowFunction outer commons grp schemas params from ty)
instance GHC.Generics.Generic (Squeal.PostgreSQL.Expression.Window.WindowFunction outer commons grp schemas params from ty)
instance Squeal.PostgreSQL.Expression.Aggregate.Aggregate (Squeal.PostgreSQL.Expression.Expression outer commons grp schemas params from) (Data.SOP.NP.NP (Squeal.PostgreSQL.Expression.Expression outer commons grp schemas params from)) (Squeal.PostgreSQL.Expression.Window.WindowFunction outer commons grp schemas params from)
instance Squeal.PostgreSQL.Render.RenderSQL (Squeal.PostgreSQL.Expression.Window.WindowFunction outer commons grp schemas params from ty)
instance Squeal.PostgreSQL.Expression.Sort.OrderBy Squeal.PostgreSQL.Expression.Window.WindowDefinition
instance Squeal.PostgreSQL.Render.RenderSQL (Squeal.PostgreSQL.Expression.Window.WindowDefinition outer commons schemas from grp params)


-- | Squeal queries.
module Squeal.PostgreSQL.Query

-- | The top level <a>Query_</a> type is parameterized by a
--   <tt>schemas</tt> <a>SchemasType</a>, against which the query is
--   type-checked, an input <tt>parameters</tt> Haskell <a>Type</a>, and an
--   ouput row Haskell <a>Type</a>.
--   
--   A top-level query can be run using <a>runQueryParams</a>, or if
--   <tt>parameters = ()</tt> using <a>runQuery</a>.
--   
--   Generally, <tt>parameters</tt> will be a Haskell tuple or record whose
--   entries may be referenced using positional <a>parameter</a>s and
--   <tt>row</tt> will be a Haskell record, whose entries will be targeted
--   using overloaded labels.
--   
--   Let's see some examples of queries.
--   
--   <pre>
--   &gt;&gt;&gt; :set -XDeriveAnyClass -XDerivingStrategies
--   
--   &gt;&gt;&gt; :{
--   data Row a b = Row { col1 :: a, col2 :: b }
--     deriving stock (GHC.Generic)
--     deriving anyclass (SOP.Generic, SOP.HasDatatypeInfo)
--   :}
--   </pre>
--   
--   simple query:
--   
--   <pre>
--   &gt;&gt;&gt; type Columns = '["col1" ::: 'NoDef :=&gt; 'NotNull 'PGint4, "col2" ::: 'NoDef :=&gt; 'NotNull 'PGint4]
--   
--   &gt;&gt;&gt; type Schema = '["tab" ::: 'Table ('[] :=&gt; Columns)]
--   
--   &gt;&gt;&gt; :{
--   let
--     query :: Query_ (Public Schema) () (Row Int32 Int32)
--     query = select Star (from (table #tab))
--   in printSQL query
--   :}
--   SELECT * FROM "tab" AS "tab"
--   </pre>
--   
--   restricted query:
--   
--   <pre>
--   &gt;&gt;&gt; :{
--   let
--     query :: Query_ (Public Schema) () (Row Int32 Int32)
--     query =
--       select_ ((#col1 + #col2) `as` #col1 :* #col1 `as` #col2)
--         ( from (table #tab)
--           &amp; where_ (#col1 .&gt; #col2)
--           &amp; where_ (#col2 .&gt; 0) )
--   in printSQL query
--   :}
--   SELECT ("col1" + "col2") AS "col1", "col1" AS "col2" FROM "tab" AS "tab" WHERE (("col1" &gt; "col2") AND ("col2" &gt; 0))
--   </pre>
--   
--   subquery:
--   
--   <pre>
--   &gt;&gt;&gt; :{
--   let
--     query :: Query_ (Public Schema) () (Row Int32 Int32)
--     query = select Star (from (subquery (select Star (from (table #tab)) `as` #sub)))
--   in printSQL query
--   :}
--   SELECT * FROM (SELECT * FROM "tab" AS "tab") AS "sub"
--   </pre>
--   
--   limits and offsets:
--   
--   <pre>
--   &gt;&gt;&gt; :{
--   let
--     query :: Query_ (Public Schema) () (Row Int32 Int32)
--     query = select Star (from (table #tab) &amp; limit 100 &amp; offset 2 &amp; limit 50 &amp; offset 2)
--   in printSQL query
--   :}
--   SELECT * FROM "tab" AS "tab" LIMIT 50 OFFSET 4
--   </pre>
--   
--   parameterized query:
--   
--   <pre>
--   &gt;&gt;&gt; :{
--   let
--     query :: Query_ (Public Schema) (Only Int32) (Row Int32 Int32)
--     query = select Star (from (table #tab) &amp; where_ (#col1 .&gt; param @1))
--   in printSQL query
--   :}
--   SELECT * FROM "tab" AS "tab" WHERE ("col1" &gt; ($1 :: int4))
--   </pre>
--   
--   aggregation query:
--   
--   <pre>
--   &gt;&gt;&gt; :{
--   let
--     query :: Query_ (Public Schema) () (Row Int64 Int32)
--     query =
--       select_ ((fromNull 0 (sum_ (All #col2))) `as` #col1 :* #col1 `as` #col2)
--       ( from (table (#tab `as` #table1))
--         &amp; groupBy #col1
--         &amp; having (sum_ (Distinct #col2) .&gt; 1) )
--   in printSQL query
--   :}
--   SELECT COALESCE(sum(ALL "col2"), 0) AS "col1", "col1" AS "col2" FROM "tab" AS "table1" GROUP BY "col1" HAVING (sum(DISTINCT "col2") &gt; 1)
--   </pre>
--   
--   sorted query:
--   
--   <pre>
--   &gt;&gt;&gt; :{
--   let
--     query :: Query_ (Public Schema) () (Row Int32 Int32)
--     query = select Star (from (table #tab) &amp; orderBy [#col1 &amp; Asc])
--   in printSQL query
--   :}
--   SELECT * FROM "tab" AS "tab" ORDER BY "col1" ASC
--   </pre>
--   
--   joins:
--   
--   <pre>
--   &gt;&gt;&gt; :{
--   type OrdersColumns =
--     '[ "id"         ::: 'NoDef :=&gt; 'NotNull 'PGint4
--      , "price"       ::: 'NoDef :=&gt; 'NotNull 'PGfloat4
--      , "customer_id" ::: 'NoDef :=&gt; 'NotNull 'PGint4
--      , "shipper_id"  ::: 'NoDef :=&gt; 'NotNull 'PGint4  ]
--   :}
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; :{
--   type OrdersConstraints =
--     '["pk_orders" ::: PrimaryKey '["id"]
--     ,"fk_customers" ::: ForeignKey '["customer_id"] "customers" '["id"]
--     ,"fk_shippers" ::: ForeignKey '["shipper_id"] "shippers" '["id"] ]
--   :}
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; type NamesColumns = '["id" ::: 'NoDef :=&gt; 'NotNull 'PGint4, "name" ::: 'NoDef :=&gt; 'NotNull 'PGtext]
--   
--   &gt;&gt;&gt; type CustomersConstraints = '["pk_customers" ::: PrimaryKey '["id"]]
--   
--   &gt;&gt;&gt; type ShippersConstraints = '["pk_shippers" ::: PrimaryKey '["id"]]
--   
--   &gt;&gt;&gt; :{
--   type OrdersSchema =
--     '[ "orders"   ::: 'Table (OrdersConstraints :=&gt; OrdersColumns)
--      , "customers" ::: 'Table (CustomersConstraints :=&gt; NamesColumns)
--      , "shippers" ::: 'Table (ShippersConstraints :=&gt; NamesColumns) ]
--   :}
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; :{
--   data Order = Order
--     { price :: Float
--     , customerName :: Text
--     , shipperName :: Text
--     } deriving GHC.Generic
--   instance SOP.Generic Order
--   instance SOP.HasDatatypeInfo Order
--   :}
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; :{
--   let
--     query :: Query_ (Public OrdersSchema) () Order
--     query = select_
--       ( #o ! #price `as` #price :*
--         #c ! #name `as` #customerName :*
--         #s ! #name `as` #shipperName )
--       ( from (table (#orders `as` #o)
--         &amp; innerJoin (table (#customers `as` #c))
--           (#o ! #customer_id .== #c ! #id)
--         &amp; innerJoin (table (#shippers `as` #s))
--           (#o ! #shipper_id .== #s ! #id)) )
--   in printSQL query
--   :}
--   SELECT "o"."price" AS "price", "c"."name" AS "customerName", "s"."name" AS "shipperName" FROM "orders" AS "o" INNER JOIN "customers" AS "c" ON ("o"."customer_id" = "c"."id") INNER JOIN "shippers" AS "s" ON ("o"."shipper_id" = "s"."id")
--   </pre>
--   
--   self-join:
--   
--   <pre>
--   &gt;&gt;&gt; :{
--   let
--     query :: Query_ (Public Schema) () (Row Int32 Int32)
--     query = select
--       (#t1 &amp; DotStar)
--       (from (table (#tab `as` #t1) &amp; crossJoin (table (#tab `as` #t2))))
--   in printSQL query
--   :}
--   SELECT "t1".* FROM "tab" AS "t1" CROSS JOIN "tab" AS "t2"
--   </pre>
--   
--   value queries:
--   
--   <pre>
--   &gt;&gt;&gt; :{
--   let
--     query :: Query_ schemas () (Row String Bool)
--     query = values
--       ("true" `as` #col1 :* true `as` #col2)
--       ["false" `as` #col1 :* false `as` #col2]
--   in printSQL query
--   :}
--   SELECT * FROM (VALUES (E'true', TRUE), (E'false', FALSE)) AS t ("col1", "col2")
--   </pre>
--   
--   set operations:
--   
--   <pre>
--   &gt;&gt;&gt; :{
--   let
--     query :: Query_ (Public Schema) () (Row Int32 Int32)
--     query = select Star (from (table #tab)) `unionAll` select Star (from (table #tab))
--   in printSQL query
--   :}
--   (SELECT * FROM "tab" AS "tab") UNION ALL (SELECT * FROM "tab" AS "tab")
--   </pre>
--   
--   with queries:
--   
--   <pre>
--   &gt;&gt;&gt; :{
--   let
--     query :: Query_ (Public Schema) () (Row Int32 Int32)
--     query = with (
--       select Star (from (table #tab)) `as` #cte1 :&gt;&gt;
--       select Star (from (common #cte1)) `as` #cte2
--       ) (select Star (from (common #cte2)))
--   in printSQL query
--   :}
--   WITH "cte1" AS (SELECT * FROM "tab" AS "tab"), "cte2" AS (SELECT * FROM "cte1" AS "cte1") SELECT * FROM "cte2" AS "cte2"
--   </pre>
--   
--   window function queries
--   
--   <pre>
--   &gt;&gt;&gt; :{
--   let
--     query :: Query_ (Public Schema) () (Row Int32 Int64)
--     query = select
--       (#col1 &amp; Also (rank `as` #col2 `Over` (partitionBy #col1 &amp; orderBy [#col2 &amp; Asc])))
--       (from (table #tab))
--   in printSQL query
--   :}
--   SELECT "col1" AS "col1", rank() OVER (PARTITION BY "col1" ORDER BY "col2" ASC) AS "col2" FROM "tab" AS "tab"
--   </pre>
--   
--   correlated subqueries
--   
--   <pre>
--   &gt;&gt;&gt; :{
--   let
--     query :: Query_ (Public Schema) () (Only Int32)
--     query =
--       select (#col1 `as` #fromOnly) (from (table (#tab `as` #t1))
--       &amp; where_ (exists (
--         select Star (from (table (#tab `as` #t2))
--         &amp; where_ (#t2 ! #col2 .== #t1 ! #col1)))))
--   in printSQL query
--   :}
--   SELECT "col1" AS "fromOnly" FROM "tab" AS "t1" WHERE EXISTS (SELECT * FROM "tab" AS "t2" WHERE ("t2"."col2" = "t1"."col1"))
--   </pre>
type family Query_ (schemas :: SchemasType) (parameters :: Type) (row :: Type)

-- | The process of retrieving or the command to retrieve data from a
--   database is called a <a>Query</a>.
--   
--   The general <a>Query</a> type is parameterized by
--   
--   <ul>
--   <li><tt>outer :: FromType</tt> - outer scope for a correlated
--   subquery,</li>
--   <li><tt>commons :: FromType</tt> - scope for all <a>common</a> table
--   expressions,</li>
--   <li><tt>schemas :: SchemasType</tt> - scope for all <a>table</a>s and
--   <a>view</a>s,</li>
--   <li><tt>params :: [NullityType]</tt> - scope for all
--   <a>parameter</a>s,</li>
--   <li><tt>row :: RowType</tt> - return type of the <a>Query</a>.</li>
--   </ul>
newtype Query (outer :: FromType) (commons :: FromType) (schemas :: SchemasType) (params :: [NullityType]) (row :: RowType)
UnsafeQuery :: ByteString -> Query
[renderQuery] :: Query -> ByteString

-- | the <a>TableExpression</a> in the <a>select</a> command constructs an
--   intermediate virtual table by possibly combining tables, views,
--   eliminating rows, grouping, etc. This table is finally passed on to
--   processing by the select list. The <a>Selection</a> determines which
--   columns of the intermediate table are actually output.
select :: (SListI row, row ~ (x : xs)) => Selection outer commons grp schemas params from row -> TableExpression outer commons grp schemas params from -> Query outer commons schemas params row

-- | Like <a>select</a> but takes an <a>NP</a> list of <a>Expression</a>s
--   instead of a general <a>Selection</a>.
select_ :: (SListI row, row ~ (x : xs)) => NP (Aliased (Expression outer commons grp schemas params from)) row -> TableExpression outer commons grp schemas params from -> Query outer commons schemas params row

-- | After the select list has been processed, the result table can be
--   subject to the elimination of duplicate rows using
--   <a>selectDistinct</a>.
selectDistinct :: (SListI columns, columns ~ (col : cols)) => Selection outer commons  'Ungrouped schemas params from columns -> TableExpression outer commons  'Ungrouped schemas params from -> Query outer commons schemas params columns

-- | Like <a>selectDistinct</a> but takes an <a>NP</a> list of
--   <a>Expression</a>s instead of a general <a>Selection</a>.
selectDistinct_ :: (SListI columns, columns ~ (col : cols)) => NP (Aliased (Expression outer commons  'Ungrouped schemas params from)) columns -> TableExpression outer commons  'Ungrouped schemas params from -> Query outer commons schemas params columns

-- | The simplest kinds of <a>Selection</a> are <a>Star</a> and
--   <a>DotStar</a> which emits all columns that a <a>TableExpression</a>
--   produces. A select <a>List</a> is a list of <a>Expression</a>s. A
--   <a>Selection</a> could be a list of <a>WindowFunction</a>s <a>Over</a>
--   <a>WindowDefinition</a>. <a>Additional</a> <a>Selection</a>s can be
--   selected with <a>Also</a>.
data Selection outer commons grp schemas params from row
[Star] :: HasUnique tab from row => Selection outer commons  'Ungrouped schemas params from row
[DotStar] :: Has tab from row => Alias tab -> Selection outer commons  'Ungrouped schemas params from row
[List] :: SListI row => NP (Aliased (Expression outer commons grp schemas params from)) row -> Selection outer commons grp schemas params from row
[Over] :: SListI row => NP (Aliased (WindowFunction outer commons grp schemas params from)) row -> WindowDefinition outer commons grp schemas params from -> Selection outer commons grp schemas params from row
[Also] :: Selection outer commons grp schemas params from right -> Selection outer commons grp schemas params from left -> Selection outer commons grp schemas params from (Join left right)

-- | <a>values</a> computes a row value or set of row values specified by
--   value expressions. It is most commonly used to generate a “constant
--   table” within a larger command, but it can be used on its own.
--   
--   <pre>
--   &gt;&gt;&gt; type Row = '["a" ::: 'NotNull 'PGint4, "b" ::: 'NotNull 'PGtext]
--   
--   &gt;&gt;&gt; let query = values (1 `as` #a :* "one" `as` #b) [] :: Query outer commons schemas '[] Row
--   
--   &gt;&gt;&gt; printSQL query
--   SELECT * FROM (VALUES (1, E'one')) AS t ("a", "b")
--   </pre>
values :: SListI cols => NP (Aliased (Expression outer commons  'Ungrouped schemas params '[])) cols -> [NP (Aliased (Expression outer commons  'Ungrouped schemas params '[])) cols] -> Query outer commons schemas params cols

-- | <a>values_</a> computes a row value or set of row values specified by
--   value expressions.
values_ :: SListI cols => NP (Aliased (Expression outer commons  'Ungrouped schemas params '[])) cols -> Query outer commons schemas params cols

-- | The results of two queries can be combined using the set operation
--   <a>union</a>. Duplicate rows are eliminated.
union :: Query outer commons schemas params columns -> Query outer commons schemas params columns -> Query outer commons schemas params columns

-- | The results of two queries can be combined using the set operation
--   <a>unionAll</a>, the disjoint union. Duplicate rows are retained.
unionAll :: Query outer commons schemas params columns -> Query outer commons schemas params columns -> Query outer commons schemas params columns

-- | The results of two queries can be combined using the set operation
--   <a>intersect</a>, the intersection. Duplicate rows are eliminated.
intersect :: Query outer commons schemas params columns -> Query outer commons schemas params columns -> Query outer commons schemas params columns

-- | The results of two queries can be combined using the set operation
--   <a>intersectAll</a>, the intersection. Duplicate rows are retained.
intersectAll :: Query outer commons schemas params columns -> Query outer commons schemas params columns -> Query outer commons schemas params columns

-- | The results of two queries can be combined using the set operation
--   <a>except</a>, the set difference. Duplicate rows are eliminated.
except :: Query outer commons schemas params columns -> Query outer commons schemas params columns -> Query outer commons schemas params columns

-- | The results of two queries can be combined using the set operation
--   <a>exceptAll</a>, the set difference. Duplicate rows are retained.
exceptAll :: Query outer commons schemas params columns -> Query outer commons schemas params columns -> Query outer commons schemas params columns

-- | <a>with</a> provides a way to write auxiliary statements for use in a
--   larger query. These statements, referred to as
--   <a>CommonTableExpression</a>s, can be thought of as defining temporary
--   tables that exist just for one query.
class With statement
with :: With statement => AlignedList (CommonTableExpression statement schemas params) commons0 commons1 -> statement commons1 schemas params row -> statement commons0 schemas params row

-- | A <a>CommonTableExpression</a> is an auxiliary statement in a
--   <a>with</a> clause.
data CommonTableExpression statement (schemas :: SchemasType) (params :: [NullityType]) (commons0 :: FromType) (commons1 :: FromType)
[CommonTableExpression] :: Aliased (statement commons schemas params) (cte ::: common) -> CommonTableExpression statement schemas params commons ((cte ::: common) : commons)

-- | <pre>
--   &gt;&gt;&gt; import Data.Monoid (Sum (..))
--   
--   &gt;&gt;&gt; import Data.Int (Int64)
--   
--   &gt;&gt;&gt; :{
--     let
--       query :: Query_ schema () (Sum Int64)
--       query = withRecursive
--         ( values_ ((1 &amp; astype int) `as` #n)
--           `unionAll`
--           select_ ((#n + 1) `as` #n)
--             (from (common #t) &amp; where_ (#n .&lt; 100)) `as` #t )
--         ( select_ (fromNull 0 (sum_ (All #n)) `as` #getSum) (from (common #t) &amp; groupBy Nil))
--     in printSQL query
--   :}
--   WITH RECURSIVE "t" AS ((SELECT * FROM (VALUES ((1 :: int))) AS t ("n")) UNION ALL (SELECT ("n" + 1) AS "n" FROM "t" AS "t" WHERE ("n" &lt; 100))) SELECT COALESCE(sum(ALL "n"), 0) AS "getSum" FROM "t" AS "t"
--   </pre>
withRecursive :: Aliased (Query outer (recursive : commons) schemas params) recursive -> Query outer (recursive : commons) schemas params row -> Query outer commons schemas params row

-- | A <a>TableExpression</a> computes a table. The table expression
--   contains a <a>fromClause</a> that is optionally followed by a
--   <a>whereClause</a>, <a>groupByClause</a>, <a>havingClause</a>,
--   <a>orderByClause</a>, <a>limitClause</a> and <a>offsetClause</a>s.
--   Trivial table expressions simply refer to a table on disk, a so-called
--   base table, but more complex expressions can be used to modify or
--   combine base tables in various ways.
data TableExpression (outer :: FromType) (commons :: FromType) (grp :: Grouping) (schemas :: SchemasType) (params :: [NullityType]) (from :: FromType)
TableExpression :: FromClause outer commons schemas params from -> [Condition outer commons  'Ungrouped schemas params from] -> GroupByClause grp from -> HavingClause outer commons grp schemas params from -> [SortExpression outer commons grp schemas params from] -> [Word64] -> [Word64] -> TableExpression

-- | A table reference that can be a table name, or a derived table such as
--   a subquery, a <tt>JOIN</tt> construct, or complex combinations of
--   these.
[fromClause] :: TableExpression -> FromClause outer commons schemas params from

-- | optional search coditions, combined with <a>.&amp;&amp;</a>. After the
--   processing of the <a>fromClause</a> is done, each row of the derived
--   virtual table is checked against the search condition. If the result
--   of the condition is true, the row is kept in the output table,
--   otherwise it is discarded. The search condition typically references
--   at least one column of the table generated in the <a>fromClause</a>;
--   this is not required, but otherwise the WHERE clause will be fairly
--   useless.
[whereClause] :: TableExpression -> [Condition outer commons  'Ungrouped schemas params from]

-- | The <a>groupByClause</a> 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.
[groupByClause] :: TableExpression -> GroupByClause grp from

-- | If a table has been grouped using <a>groupBy</a>, but only certain
--   groups are of interest, the <a>havingClause</a> can be used, much like
--   a <a>whereClause</a>, to eliminate groups from the result. Expressions
--   in the <a>havingClause</a> can refer both to grouped expressions and
--   to ungrouped expressions (which necessarily involve an aggregate
--   function).
[havingClause] :: TableExpression -> HavingClause outer commons grp schemas params from

-- | The <a>orderByClause</a> is for optional sorting. When more than one
--   <a>SortExpression</a> is specified, the later (right) values are used
--   to sort rows that are equal according to the earlier (left) values.
[orderByClause] :: TableExpression -> [SortExpression outer commons grp schemas params from]

-- | The <a>limitClause</a> is combined with <a>min</a> to give a limit
--   count if nonempty. If a limit count is given, no more than that many
--   rows will be returned (but possibly fewer, if the query itself yields
--   fewer rows).
[limitClause] :: TableExpression -> [Word64]

-- | The <a>offsetClause</a> is combined with <a>+</a> to give an offset
--   count if nonempty. The offset count says to skip that many rows before
--   beginning to return rows. The rows are skipped before the limit count
--   is applied.
[offsetClause] :: TableExpression -> [Word64]

-- | A <a>from</a> generates a <a>TableExpression</a> 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. A
--   <a>from</a> may be transformed by <a>where_</a>, <a>groupBy</a>,
--   <a>having</a>, <a>orderBy</a>, <a>limit</a> and <a>offset</a>, using
--   the <a>&amp;</a> operator to match the left-to-right sequencing of
--   their placement in SQL.
from :: FromClause outer commons schemas params from -> TableExpression outer commons  'Ungrouped schemas params from

-- | A <a>where_</a> is an endomorphism of <a>TableExpression</a>s which
--   adds a search condition to the <a>whereClause</a>.
where_ :: Condition outer commons  'Ungrouped schemas params from -> TableExpression outer commons grp schemas params from -> TableExpression outer commons grp schemas params from

-- | A <a>groupBy</a> is a transformation of <a>TableExpression</a>s which
--   switches its <a>Grouping</a> from <a>Ungrouped</a> to <a>Grouped</a>.
--   Use <tt>groupBy Nil</tt> to perform a "grand total" aggregation query.
groupBy :: SListI bys => NP (By from) bys -> TableExpression outer commons  'Ungrouped schemas params from -> TableExpression outer commons ( 'Grouped bys) schemas params from

-- | A <a>having</a> is an endomorphism of <a>TableExpression</a>s which
--   adds a search condition to the <a>havingClause</a>.
having :: Condition outer commons ( 'Grouped bys) schemas params from -> TableExpression outer commons ( 'Grouped bys) schemas params from -> TableExpression outer commons ( 'Grouped bys) schemas params from

-- | A <a>limit</a> is an endomorphism of <a>TableExpression</a>s which
--   adds to the <a>limitClause</a>.
limit :: Word64 -> TableExpression outer commons grp schemas params from -> TableExpression outer commons grp schemas params from

-- | An <a>offset</a> is an endomorphism of <a>TableExpression</a>s which
--   adds to the <a>offsetClause</a>.
offset :: Word64 -> TableExpression outer commons grp schemas params from -> TableExpression outer commons grp schemas params from

-- | A <a>FromClause</a> can be a table name, or a derived table such as a
--   subquery, a <tt>JOIN</tt> construct, or complex combinations of these.
newtype FromClause outer commons schemas params from
UnsafeFromClause :: ByteString -> FromClause outer commons schemas params from
[renderFromClause] :: FromClause outer commons schemas params from -> ByteString

-- | A real <a>table</a> is a table from the database.
table :: (Has sch schemas schema, Has tab schema ( 'Table table)) => Aliased (QualifiedAlias sch) (alias ::: tab) -> FromClause outer commons schemas params '[alias ::: TableToRow table]

-- | <a>subquery</a> derives a table from a <a>Query</a>.
subquery :: Aliased (Query outer commons schemas params) query -> FromClause outer commons schemas params '[query]

-- | <a>view</a> derives a table from a <a>View</a>.
view :: (Has sch schemas schema, Has vw schema ( 'View view)) => Aliased (QualifiedAlias sch) (alias ::: vw) -> FromClause outer commons schemas params '[alias ::: view]

-- | <a>common</a> derives a table from a common table expression.
common :: Has cte commons common => Aliased Alias (alias ::: cte) -> FromClause outer commons schemas params '[alias ::: common]

-- | <tt>left &amp; crossJoin right</tt>. For every possible combination of
--   rows from <tt>left</tt> and <tt>right</tt> (i.e., a Cartesian
--   product), the joined table will contain a row consisting of all
--   columns in <tt>left</tt> followed by all columns in <tt>right</tt>. If
--   the tables have <tt>n</tt> and <tt>m</tt> rows respectively, the
--   joined table will have <tt>n * m</tt> rows.
crossJoin :: FromClause outer commons schemas params right -> FromClause outer commons schemas params left -> FromClause outer commons schemas params (Join left right)

-- | <tt>left &amp; innerJoin right on</tt>. The joined table is filtered
--   by the <tt>on</tt> condition.
innerJoin :: FromClause outer commons schemas params right -> Condition outer commons  'Ungrouped schemas params (Join left right) -> FromClause outer commons schemas params left -> FromClause outer commons schemas params (Join left right)

-- | <tt>left &amp; leftOuterJoin right on</tt>. First, an inner join is
--   performed. Then, for each row in <tt>left</tt> that does not satisfy
--   the <tt>on</tt> condition with any row in <tt>right</tt>, a joined row
--   is added with null values in columns of <tt>right</tt>. Thus, the
--   joined table always has at least one row for each row in
--   <tt>left</tt>.
leftOuterJoin :: FromClause outer commons schemas params right -> Condition outer commons  'Ungrouped schemas params (Join left right) -> FromClause outer commons schemas params left -> FromClause outer commons schemas params (Join left (NullifyFrom right))

-- | <tt>left &amp; rightOuterJoin right on</tt>. First, an inner join is
--   performed. Then, for each row in <tt>right</tt> that does not satisfy
--   the <tt>on</tt> condition with any row in <tt>left</tt>, a joined row
--   is added with null values in columns of <tt>left</tt>. This is the
--   converse of a left join: the result table will always have a row for
--   each row in <tt>right</tt>.
rightOuterJoin :: FromClause outer commons schemas params right -> Condition outer commons  'Ungrouped schemas params (Join left right) -> FromClause outer commons schemas params left -> FromClause outer commons schemas params (Join (NullifyFrom left) right)

-- | <tt>left &amp; fullOuterJoin right on</tt>. First, an inner join is
--   performed. Then, for each row in <tt>left</tt> that does not satisfy
--   the <tt>on</tt> condition with any row in <tt>right</tt>, a joined row
--   is added with null values in columns of <tt>right</tt>. Also, for each
--   row of <tt>right</tt> that does not satisfy the join condition with
--   any row in <tt>left</tt>, a joined row with null values in the columns
--   of <tt>left</tt> is added.
fullOuterJoin :: FromClause outer commons schemas params right -> Condition outer commons  'Ungrouped schemas params (Join left right) -> FromClause outer commons schemas params left -> FromClause outer commons schemas params (Join (NullifyFrom left) (NullifyFrom right))

-- | <a>By</a>s are used in <a>groupBy</a> to reference a list of columns
--   which are then used to group together those rows in a table that have
--   the same values in all the columns listed. <tt>By #col</tt> will
--   reference an unambiguous column <tt>col</tt>; otherwise <tt>By2 (#tab
--   ! #col)</tt> will reference a table qualified column <tt>tab.col</tt>.
data By (from :: FromType) (by :: (Symbol, Symbol))
[By1] :: (HasUnique table from columns, Has column columns ty) => Alias column -> By from '(table, column)
[By2] :: (Has table from columns, Has column columns ty) => Alias table -> Alias column -> By from '(table, column)

-- | A <a>GroupByClause</a> indicates the <a>Grouping</a> of a
--   <a>TableExpression</a>. A <a>NoGroups</a> indicates <a>Ungrouped</a>
--   while a <a>Group</a> indicates <a>Grouped</a>. <tt>NoGroups</tt> is
--   distinguised from <tt>Group Nil</tt> since no aggregation can be done
--   on <tt>NoGroups</tt> while all output <a>Expression</a>s must be
--   aggregated in <tt>Group Nil</tt>. In general, all output
--   <a>Expression</a>s in the complement of <tt>bys</tt> must be
--   aggregated in <tt>Group bys</tt>.
data GroupByClause grp from
[NoGroups] :: GroupByClause  'Ungrouped from
[Group] :: SListI bys => NP (By from) bys -> GroupByClause ( 'Grouped bys) from

-- | A <a>HavingClause</a> is used to eliminate groups that are not of
--   interest. An <a>Ungrouped</a> <a>TableExpression</a> may only use
--   <a>NoHaving</a> while a <a>Grouped</a> <a>TableExpression</a> must use
--   <a>Having</a> whose conditions are combined with <a>.&amp;&amp;</a>.
data HavingClause outer commons grp schemas params from
[NoHaving] :: HavingClause outer commons  'Ungrouped schemas params from
[Having] :: [Condition outer commons ( 'Grouped bys) schemas params from] -> HavingClause outer commons ( 'Grouped bys) schemas params from
instance GHC.Generics.Generic (Squeal.PostgreSQL.Query.TableExpression outer commons grp schemas params from)
instance forall k1 (outer :: k1) k2 (commons :: k2) k3 (schemas :: k3) k4 (params :: k4) k5 (from :: k5). Control.DeepSeq.NFData (Squeal.PostgreSQL.Query.FromClause outer commons schemas params from)
instance forall k1 (outer :: k1) k2 (commons :: k2) k3 (schemas :: k3) k4 (params :: k4) k5 (from :: k5). GHC.Classes.Ord (Squeal.PostgreSQL.Query.FromClause outer commons schemas params from)
instance forall k1 (outer :: k1) k2 (commons :: k2) k3 (schemas :: k3) k4 (params :: k4) k5 (from :: k5). GHC.Classes.Eq (Squeal.PostgreSQL.Query.FromClause outer commons schemas params from)
instance forall k1 (outer :: k1) k2 (commons :: k2) k3 (schemas :: k3) k4 (params :: k4) k5 (from :: k5). GHC.Show.Show (Squeal.PostgreSQL.Query.FromClause outer commons schemas params from)
instance forall k1 (outer :: k1) k2 (commons :: k2) k3 (schemas :: k3) k4 (params :: k4) k5 (from :: k5). GHC.Generics.Generic (Squeal.PostgreSQL.Query.FromClause outer commons schemas params from)
instance Control.DeepSeq.NFData (Squeal.PostgreSQL.Query.Query outer commons schemas params row)
instance GHC.Classes.Ord (Squeal.PostgreSQL.Query.Query outer commons schemas params row)
instance GHC.Classes.Eq (Squeal.PostgreSQL.Query.Query outer commons schemas params row)
instance GHC.Show.Show (Squeal.PostgreSQL.Query.Query outer commons schemas params row)
instance GHC.Generics.Generic (Squeal.PostgreSQL.Query.Query outer commons schemas params row)
instance GHC.Show.Show (Squeal.PostgreSQL.Query.By from by)
instance GHC.Classes.Eq (Squeal.PostgreSQL.Query.By from by)
instance GHC.Classes.Ord (Squeal.PostgreSQL.Query.By from by)
instance GHC.Show.Show (Squeal.PostgreSQL.Query.HavingClause outer commons grp schemas params from)
instance GHC.Classes.Eq (Squeal.PostgreSQL.Query.HavingClause outer commons grp schemas params from)
instance GHC.Classes.Ord (Squeal.PostgreSQL.Query.HavingClause outer commons grp schemas params from)
instance Squeal.PostgreSQL.Query.With (Squeal.PostgreSQL.Query.Query outer)
instance (GHC.TypeLits.KnownSymbol cte, commons1 Data.Type.Equality.~ ((cte Squeal.PostgreSQL.Alias.::: common) : commons)) => Squeal.PostgreSQL.Alias.Aliasable cte (statement commons schemas params common) (Squeal.PostgreSQL.Query.CommonTableExpression statement schemas params commons commons1)
instance (GHC.TypeLits.KnownSymbol cte, commons1 Data.Type.Equality.~ ((cte Squeal.PostgreSQL.Alias.::: common) : commons)) => Squeal.PostgreSQL.Alias.Aliasable cte (statement commons schemas params common) (Squeal.PostgreSQL.List.AlignedList (Squeal.PostgreSQL.Query.CommonTableExpression statement schemas params) commons commons1)
instance (forall (c :: Squeal.PostgreSQL.Schema.FromType) (s :: Squeal.PostgreSQL.Schema.SchemasType) (p :: [Squeal.PostgreSQL.Schema.NullityType]) (r :: Squeal.PostgreSQL.Schema.RowType). Squeal.PostgreSQL.Render.RenderSQL (statement c s p r)) => Squeal.PostgreSQL.Render.RenderSQL (Squeal.PostgreSQL.Query.CommonTableExpression statement schemas params commons0 commons1)
instance Squeal.PostgreSQL.Render.RenderSQL (Squeal.PostgreSQL.Query.TableExpression outer commons grp schemas params from)
instance Squeal.PostgreSQL.Expression.Sort.OrderBy Squeal.PostgreSQL.Query.TableExpression
instance Squeal.PostgreSQL.Render.RenderSQL (Squeal.PostgreSQL.Query.HavingClause outer commons grp schemas params from)
instance Squeal.PostgreSQL.Render.RenderSQL (Squeal.PostgreSQL.Query.GroupByClause grp from)
instance Squeal.PostgreSQL.Render.RenderSQL (Squeal.PostgreSQL.Query.By from by)
instance (Squeal.PostgreSQL.Alias.HasUnique rel rels cols, Squeal.PostgreSQL.Alias.Has col cols ty, by Data.Type.Equality.~ '(rel, col)) => GHC.OverloadedLabels.IsLabel col (Squeal.PostgreSQL.Query.By rels by)
instance (Squeal.PostgreSQL.Alias.HasUnique rel rels cols, Squeal.PostgreSQL.Alias.Has col cols ty, bys Data.Type.Equality.~ '[ '(rel, col)]) => GHC.OverloadedLabels.IsLabel col (Data.SOP.NP.NP (Squeal.PostgreSQL.Query.By rels) bys)
instance (Squeal.PostgreSQL.Alias.Has rel rels cols, Squeal.PostgreSQL.Alias.Has col cols ty, by Data.Type.Equality.~ '(rel, col)) => Squeal.PostgreSQL.Alias.IsQualified rel col (Squeal.PostgreSQL.Query.By rels by)
instance (Squeal.PostgreSQL.Alias.Has rel rels cols, Squeal.PostgreSQL.Alias.Has col cols ty, bys Data.Type.Equality.~ '[ '(rel, col)]) => Squeal.PostgreSQL.Alias.IsQualified rel col (Data.SOP.NP.NP (Squeal.PostgreSQL.Query.By rels) bys)
instance forall k1 k2 k3 k4 k5 (outer :: k5) (commons :: k4) (schemas :: k3) (params :: k2) (from :: k1). Squeal.PostgreSQL.Render.RenderSQL (Squeal.PostgreSQL.Query.FromClause outer commons schemas params from)
instance forall a k1 k2 k3 k4 (outer :: k4) (commons :: k3) (schemas :: k2) (params :: k1). Squeal.PostgreSQL.List.Additional (Squeal.PostgreSQL.Query.FromClause outer commons schemas params)
instance Squeal.PostgreSQL.List.Additional (Squeal.PostgreSQL.Query.Selection outer commons grp schemas params from)
instance (GHC.TypeLits.KnownSymbol col, row Data.Type.Equality.~ '[col Squeal.PostgreSQL.Alias.::: ty]) => Squeal.PostgreSQL.Alias.Aliasable col (Squeal.PostgreSQL.Expression.Expression outer commons grp schemas params from ty) (Squeal.PostgreSQL.Query.Selection outer commons grp schemas params from row)
instance (Squeal.PostgreSQL.Alias.Has tab (Squeal.PostgreSQL.List.Join outer from) row0, Squeal.PostgreSQL.Alias.Has col row0 ty, row1 Data.Type.Equality.~ '[col Squeal.PostgreSQL.Alias.::: ty]) => Squeal.PostgreSQL.Alias.IsQualified tab col (Squeal.PostgreSQL.Query.Selection outer commons 'Squeal.PostgreSQL.Alias.Ungrouped schemas params from row1)
instance (Squeal.PostgreSQL.Alias.Has tab (Squeal.PostgreSQL.List.Join outer from) row0, Squeal.PostgreSQL.Alias.Has col row0 ty, row1 Data.Type.Equality.~ '[col Squeal.PostgreSQL.Alias.::: ty], Squeal.PostgreSQL.Alias.GroupedBy tab col bys) => Squeal.PostgreSQL.Alias.IsQualified tab col (Squeal.PostgreSQL.Query.Selection outer commons ('Squeal.PostgreSQL.Alias.Grouped bys) schemas params from row1)
instance (Squeal.PostgreSQL.Alias.HasUnique tab (Squeal.PostgreSQL.List.Join outer from) row0, Squeal.PostgreSQL.Alias.Has col row0 ty, row1 Data.Type.Equality.~ '[col Squeal.PostgreSQL.Alias.::: ty]) => GHC.OverloadedLabels.IsLabel col (Squeal.PostgreSQL.Query.Selection outer commons 'Squeal.PostgreSQL.Alias.Ungrouped schemas params from row1)
instance (Squeal.PostgreSQL.Alias.HasUnique tab (Squeal.PostgreSQL.List.Join outer from) row0, Squeal.PostgreSQL.Alias.Has col row0 ty, row1 Data.Type.Equality.~ '[col Squeal.PostgreSQL.Alias.::: ty], Squeal.PostgreSQL.Alias.GroupedBy tab col bys) => GHC.OverloadedLabels.IsLabel col (Squeal.PostgreSQL.Query.Selection outer commons ('Squeal.PostgreSQL.Alias.Grouped bys) schemas params from row1)
instance Squeal.PostgreSQL.Render.RenderSQL (Squeal.PostgreSQL.Query.Selection outer commons grp schemas params from row)
instance Data.String.IsString (Squeal.PostgreSQL.Query.Selection outer commons grp schemas params from '["fromOnly" Squeal.PostgreSQL.Alias.::: 'Squeal.PostgreSQL.Schema.NotNull 'Squeal.PostgreSQL.Schema.PGtext])
instance Squeal.PostgreSQL.Render.RenderSQL (Squeal.PostgreSQL.Query.Query outer commons schemas params row)


-- | Squeal data manipulation language.
module Squeal.PostgreSQL.Manipulation

-- | The top level <a>Manipulation_</a> type is parameterized by a
--   <tt>schemas</tt> <a>SchemasType</a>, against which the query is
--   type-checked, an input <tt>parameters</tt> Haskell <a>Type</a>, and an
--   ouput row Haskell <a>Type</a>.
--   
--   A top-level <a>Manipulation_</a> can be run using
--   <a>manipulateParams</a>, or if <tt>parameters = ()</tt> using
--   <a>manipulate</a>.
--   
--   Generally, <tt>parameters</tt> will be a Haskell tuple or record whose
--   entries may be referenced using positional <a>parameter</a>s and
--   <tt>row</tt> will be a Haskell record, whose entries will be targeted
--   using overloaded labels.
--   
--   <pre>
--   &gt;&gt;&gt; :set -XDeriveAnyClass -XDerivingStrategies
--   
--   &gt;&gt;&gt; :{
--   data Row a b = Row { col1 :: a, col2 :: b }
--     deriving stock (GHC.Generic)
--     deriving anyclass (SOP.Generic, SOP.HasDatatypeInfo)
--   :}
--   </pre>
--   
--   simple insert:
--   
--   <pre>
--   &gt;&gt;&gt; type Columns = '["col1" ::: 'NoDef :=&gt; 'Null 'PGint4, "col2" ::: 'Def :=&gt; 'NotNull 'PGint4]
--   
--   &gt;&gt;&gt; type Schema = '["tab" ::: 'Table ('[] :=&gt; Columns)]
--   
--   &gt;&gt;&gt; :{
--   let
--     manipulation :: Manipulation_ (Public Schema) () ()
--     manipulation =
--       insertInto_ #tab (Values_ (Set 2 `as` #col1 :* Default `as` #col2))
--   in printSQL manipulation
--   :}
--   INSERT INTO "tab" ("col1", "col2") VALUES (2, DEFAULT)
--   </pre>
--   
--   parameterized insert:
--   
--   <pre>
--   &gt;&gt;&gt; type Columns = '["col1" ::: 'NoDef :=&gt; 'NotNull 'PGint4, "col2" ::: 'NoDef :=&gt; 'NotNull 'PGint4]
--   
--   &gt;&gt;&gt; type Schema = '["tab" ::: 'Table ('[] :=&gt; Columns)]
--   
--   &gt;&gt;&gt; :{
--   let
--     manipulation :: Manipulation_ (Public Schema) (Int32, Int32) ()
--     manipulation =
--       insertInto_ #tab (Values_ (Set (param @1) `as` #col1 :* Set (param @2) `as` #col2))
--   in printSQL manipulation
--   :}
--   INSERT INTO "tab" ("col1", "col2") VALUES (($1 :: int4), ($2 :: int4))
--   </pre>
--   
--   returning insert:
--   
--   <pre>
--   &gt;&gt;&gt; :{
--   let
--     manipulation :: Manipulation_ (Public Schema) () (Only Int32)
--     manipulation =
--       insertInto #tab (Values_ (Set 2 `as` #col1 :* Set 3 `as` #col2))
--         OnConflictDoRaise (Returning (#col1 `as` #fromOnly))
--   in printSQL manipulation
--   :}
--   INSERT INTO "tab" ("col1", "col2") VALUES (2, 3) RETURNING "col1" AS "fromOnly"
--   </pre>
--   
--   upsert:
--   
--   <pre>
--   &gt;&gt;&gt; type CustomersColumns = '["name" ::: 'NoDef :=&gt; 'NotNull 'PGtext, "email" ::: 'NoDef :=&gt; 'NotNull 'PGtext]
--   
--   &gt;&gt;&gt; type CustomersConstraints = '["uq" ::: 'Unique '["name"]]
--   
--   &gt;&gt;&gt; type CustomersSchema = '["customers" ::: 'Table (CustomersConstraints :=&gt; CustomersColumns)]
--   
--   &gt;&gt;&gt; :{
--   let
--     manipulation :: Manipulation_ (Public CustomersSchema) () ()
--     manipulation =
--       insertInto #customers
--         (Values_ (Set "John Smith" `as` #name :* Set "john@smith.com" `as` #email))
--         (OnConflict (OnConstraint #uq)
--           (DoUpdate (Set (#excluded ! #email &lt;&gt; "; " &lt;&gt; #customers ! #email) `as` #email) []))
--         (Returning_ Nil)
--   in printSQL manipulation
--   :}
--   INSERT INTO "customers" ("name", "email") VALUES (E'John Smith', E'john@smith.com') ON CONFLICT ON CONSTRAINT "uq" DO UPDATE SET "email" = ("excluded"."email" || (E'; ' || "customers"."email"))
--   </pre>
--   
--   query insert:
--   
--   <pre>
--   &gt;&gt;&gt; :{
--   let
--     manipulation :: Manipulation_ (Public Schema) () ()
--     manipulation = insertInto_ #tab (Subquery (select Star (from (table #tab))))
--   in printSQL manipulation
--   :}
--   INSERT INTO "tab" SELECT * FROM "tab" AS "tab"
--   </pre>
--   
--   update:
--   
--   <pre>
--   &gt;&gt;&gt; :{
--   let
--     manipulation :: Manipulation_ (Public Schema) () ()
--     manipulation = update_ #tab (Set 2 `as` #col1) (#col1 ./= #col2)
--   in printSQL manipulation
--   :}
--   UPDATE "tab" SET "col1" = 2 WHERE ("col1" &lt;&gt; "col2")
--   </pre>
--   
--   delete:
--   
--   <pre>
--   &gt;&gt;&gt; :{
--   let
--     manipulation :: Manipulation_ (Public Schema) () (Row Int32 Int32)
--     manipulation = deleteFrom #tab NoUsing (#col1 .== #col2) (Returning Star)
--   in printSQL manipulation
--   :}
--   DELETE FROM "tab" WHERE ("col1" = "col2") RETURNING *
--   </pre>
--   
--   delete and using clause:
--   
--   <pre>
--   &gt;&gt;&gt; :{
--   type Schema3 =
--     '[ "tab" ::: 'Table ('[] :=&gt; Columns)
--      , "other_tab" ::: 'Table ('[] :=&gt; Columns)
--      , "third_tab" ::: 'Table ('[] :=&gt; Columns) ]
--   :}
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; :{
--   let
--     manipulation :: Manipulation_ (Public Schema3) () ()
--     manipulation =
--       deleteFrom #tab (Using (table #other_tab &amp; also (table #third_tab)))
--       ( (#tab ! #col2 .== #other_tab ! #col2)
--       .&amp;&amp; (#tab ! #col2 .== #third_tab ! #col2) )
--       (Returning_ Nil)
--   in printSQL manipulation
--   :}
--   DELETE FROM "tab" USING "other_tab" AS "other_tab", "third_tab" AS "third_tab" WHERE (("tab"."col2" = "other_tab"."col2") AND ("tab"."col2" = "third_tab"."col2"))
--   </pre>
--   
--   with manipulation:
--   
--   <pre>
--   &gt;&gt;&gt; type ProductsColumns = '["product" ::: 'NoDef :=&gt; 'NotNull 'PGtext, "date" ::: 'Def :=&gt; 'NotNull 'PGdate]
--   
--   &gt;&gt;&gt; type ProductsSchema = '["products" ::: 'Table ('[] :=&gt; ProductsColumns), "products_deleted" ::: 'Table ('[] :=&gt; ProductsColumns)]
--   
--   &gt;&gt;&gt; :{
--   let
--     manipulation :: Manipulation_ (Public ProductsSchema) (Only Day) ()
--     manipulation = with
--       (deleteFrom #products NoUsing (#date .&lt; param @1) (Returning Star) `as` #del)
--       (insertInto_ #products_deleted (Subquery (select Star (from (common #del)))))
--   in printSQL manipulation
--   :}
--   WITH "del" AS (DELETE FROM "products" WHERE ("date" &lt; ($1 :: date)) RETURNING *) INSERT INTO "products_deleted" SELECT * FROM "del" AS "del"
--   </pre>
type family Manipulation_ (schemas :: SchemasType) (params :: Type) (row :: Type)

-- | A <a>Manipulation</a> is a statement which may modify data in the
--   database, but does not alter its schemas. Examples are inserts,
--   updates and deletes. A <a>Query</a> is also considered a
--   <a>Manipulation</a> even though it does not modify data.
--   
--   The general <a>Manipulation</a> type is parameterized by
--   
--   <ul>
--   <li><tt>commons :: FromType</tt> - scope for all <a>common</a> table
--   expressions,</li>
--   <li><tt>schemas :: SchemasType</tt> - scope for all <a>table</a>s and
--   <a>view</a>s,</li>
--   <li><tt>params :: [NullityType]</tt> - scope for all
--   <a>parameter</a>s,</li>
--   <li><tt>row :: RowType</tt> - return type of the <a>Query</a>.</li>
--   </ul>
newtype Manipulation (commons :: FromType) (schemas :: SchemasType) (params :: [NullityType]) (columns :: RowType)
UnsafeManipulation :: ByteString -> Manipulation
[renderManipulation] :: Manipulation -> ByteString

-- | Convert a <a>Query</a> into a <a>Manipulation</a>.
queryStatement :: Query '[] commons schemas params columns -> Manipulation commons schemas params columns

-- | When a table is created, it contains no data. The first thing to do
--   before a database can be of much use is to insert data. Data is
--   conceptually inserted one row at a time. Of course you can also insert
--   more than one row, but there is no way to insert less than one row.
--   Even if you know only some column values, a complete row must be
--   created.
insertInto :: (Has sch schemas schema, Has tab schema ( 'Table table), columns ~ TableToColumns table, row0 ~ TableToRow table, SListI columns, SListI row1) => QualifiedAlias sch tab -> QueryClause commons schemas params columns -> ConflictClause tab commons schemas params table -> ReturningClause commons schemas params '[tab ::: row0] row1 -> Manipulation commons schemas params row1

-- | Like <a>insertInto</a> but with <a>OnConflictDoRaise</a> and no
--   <a>ReturningClause</a>.
insertInto_ :: (Has sch schemas schema, Has tab schema ( 'Table table), columns ~ TableToColumns table, row ~ TableToRow table, SListI columns) => QualifiedAlias sch tab -> QueryClause commons schemas params columns -> Manipulation commons schemas params '[]

-- | An <a>update</a> command changes the values of the specified columns
--   in all rows that satisfy the condition.
update :: (SListI columns, SListI row1, db ~ (commons :=> schemas), Has sch schemas schema, Has tab schema ( 'Table table), row0 ~ TableToRow table, columns ~ TableToColumns table, All (HasIn columns) subcolumns, AllUnique subcolumns) => QualifiedAlias sch tab -> NP (Aliased (Optional (Expression '[] '[]  'Ungrouped schemas params '[tab ::: row0]))) subcolumns -> Condition '[] commons  'Ungrouped schemas params '[tab ::: row0] -> ReturningClause commons schemas params '[tab ::: row0] row1 -> Manipulation commons schemas params row1

-- | Update a row returning <a>Nil</a>.
update_ :: (SListI columns, db ~ (commons :=> schemas), Has sch schemas schema, Has tab schema ( 'Table table), row ~ TableToRow table, columns ~ TableToColumns table, All (HasIn columns) subcolumns, AllUnique subcolumns) => QualifiedAlias sch tab -> NP (Aliased (Optional (Expression '[] '[]  'Ungrouped schemas params '[tab ::: row]))) subcolumns -> Condition '[] commons  'Ungrouped schemas params '[tab ::: row] -> Manipulation commons schemas params '[]

-- | Delete rows from a table.
deleteFrom :: (SListI row1, db ~ (commons :=> schemas), Has sch schemas schema, Has tab schema ( 'Table table), row0 ~ TableToRow table, columns ~ TableToColumns table) => QualifiedAlias sch tab -> UsingClause commons schemas params from -> Condition '[] commons  'Ungrouped schemas params ((tab ::: row0) : from) -> ReturningClause commons schemas params '[tab ::: row0] row1 -> Manipulation commons schemas params row1

-- | Delete rows returning <a>Nil</a>.
deleteFrom_ :: (db ~ (commons :=> schemas), Has sch schemas schema, Has tab schema ( 'Table table), row ~ TableToRow table, columns ~ TableToColumns table) => QualifiedAlias sch tab -> Condition '[] commons  'Ungrouped schemas params '[tab ::: row] -> Manipulation commons schemas params '[]

-- | <a>Optional</a> is either <a>Default</a> or a value, parameterized by
--   an appropriate <a>ColumnConstraint</a>.
data Optional expr ty

-- | Use the <a>Default</a> value for a column.
[Default] :: Optional expr ( 'Def :=> ty)

-- | <a>Set</a> a value for a column.
[Set] :: expr ty -> Optional expr (def :=> ty)

-- | A <a>QueryClause</a> describes what to <a>insertInto</a> a table.
data QueryClause commons schemas params columns

-- | <a>Values</a> describes <a>NP</a> lists of <a>Aliased</a>
--   <a>Optional</a> <a>Expression</a>s whose <a>ColumnsType</a> must match
--   the tables'.
[Values] :: SListI columns => NP (Aliased (Optional (Expression '[] commons  'Ungrouped schemas params '[]))) columns -> [NP (Aliased (Optional (Expression '[] commons  'Ungrouped schemas params '[]))) columns] -> QueryClause commons schemas params columns

-- | <a>Select</a> describes a subquery that permits use of <a>Optional</a>
--   <a>Expression</a>s.
[Select] :: SListI columns => NP (Aliased (Optional (Expression '[] commons grp schemas params from))) columns -> TableExpression '[] commons grp schemas params from -> QueryClause commons schemas params columns

-- | <a>Subquery</a> describes a subquery whose <a>RowType</a> must match
--   the tables'.
[Subquery] :: ColumnsToRow columns ~ row => Query '[] commons schemas params row -> QueryClause commons schemas params columns

-- | <a>Values_</a> describes a single <a>NP</a> list of <a>Aliased</a>
--   <a>Optional</a> <a>Expression</a>s whose <a>ColumnsType</a> must match
--   the tables'.
pattern Values_ :: SListI columns => NP (Aliased (Optional (Expression '[] commons  'Ungrouped schemas params '[]))) columns -> QueryClause commons schemas params columns

-- | A <a>ReturningClause</a> computes and return value(s) based on each
--   row actually inserted, updated or deleted. This is primarily useful
--   for obtaining values that were supplied by defaults, such as a serial
--   sequence number. However, any expression using the table's columns is
--   allowed. Only rows that were successfully inserted or updated or
--   deleted will be returned. For example, if a row was locked but not
--   updated because an <a>OnConflict</a> <a>DoUpdate</a> condition was not
--   satisfied, the row will not be returned. <a>Returning</a> <a>Star</a>
--   will return all columns in the row. Use <tt>Returning Nil</tt> in the
--   common case where no return values are desired.
newtype ReturningClause commons schemas params from row
Returning :: Selection '[] commons  'Ungrouped schemas params from row -> ReturningClause commons schemas params from row

-- | <a>Returning</a> a <a>List</a>
pattern Returning_ :: SListI row => NP (Aliased (Expression '[] commons  'Ungrouped schemas params from)) row -> ReturningClause commons schemas params from row

-- | A <a>ConflictClause</a> specifies an action to perform upon a
--   constraint violation. <a>OnConflictDoRaise</a> will raise an error.
--   <a>OnConflict</a> <a>DoNothing</a> simply avoids inserting a row.
--   <a>OnConflict</a> <a>DoUpdate</a> updates the existing row that
--   conflicts with the row proposed for insertion.
data ConflictClause tab commons schemas params table
[OnConflictDoRaise] :: ConflictClause tab commons schemas params table
[OnConflict] :: ConflictTarget constraints -> ConflictAction tab commons schemas params columns -> ConflictClause tab commons schemas params (constraints :=> columns)

-- | A <a>ConflictTarget</a> specifies the constraint violation that
--   triggers a <a>ConflictAction</a>.
data ConflictTarget constraints
[OnConstraint] :: Has con constraints constraint => Alias con -> ConflictTarget constraints

-- | <a>ConflictAction</a> specifies an alternative <a>OnConflict</a>
--   action. It can be either <a>DoNothing</a>, or a <a>DoUpdate</a> clause
--   specifying the exact details of the <a>update</a> action to be
--   performed in case of a conflict. The <a>Set</a> and WHERE
--   <a>Condition</a>s in <a>OnConflict</a> <a>DoUpdate</a> have access to
--   the existing row using the table's name (or an alias), and to rows
--   proposed for insertion using the special <tt>#excluded</tt> table.
data ConflictAction tab commons schemas params columns

-- | <a>OnConflict</a> <a>DoNothing</a> simply avoids inserting a row as
--   its alternative action.
[DoNothing] :: ConflictAction tab commons schemas params columns

-- | <a>OnConflict</a> <a>DoUpdate</a> updates the existing row that
--   conflicts with the row proposed for insertion as its alternative
--   action.
[DoUpdate] :: (row ~ ColumnsToRow columns, SListI columns, columns ~ (col0 : cols), All (HasIn columns) subcolumns, AllUnique subcolumns) => NP (Aliased (Optional (Expression '[] commons  'Ungrouped schemas params '[tab ::: row, "excluded" ::: row]))) subcolumns -> [Condition '[] commons  'Ungrouped schemas params '[tab ::: row, "excluded" ::: row]] -> ConflictAction tab commons schemas params columns

-- | Specify additional tables.
data UsingClause commons schemas params from

-- | No <a>UsingClause</a>
[NoUsing] :: UsingClause commons schemas params '[]

-- | An <a>also</a> list of table expressions, allowing columns from other
--   tables to appear in the WHERE condition. This is similar to the list
--   of tables that can be specified in the FROM Clause of a SELECT
--   statement; for example, an alias for the table name can be specified.
--   Do not repeat the target table in the <a>Using</a> list, unless you
--   wish to set up a self-join.
[Using] :: FromClause '[] commons schemas params from -> UsingClause commons schemas params from
instance Control.DeepSeq.NFData (Squeal.PostgreSQL.Manipulation.Manipulation commons schemas params columns)
instance GHC.Classes.Ord (Squeal.PostgreSQL.Manipulation.Manipulation commons schemas params columns)
instance GHC.Classes.Eq (Squeal.PostgreSQL.Manipulation.Manipulation commons schemas params columns)
instance GHC.Show.Show (Squeal.PostgreSQL.Manipulation.Manipulation commons schemas params columns)
instance GHC.Generics.Generic (Squeal.PostgreSQL.Manipulation.Manipulation commons schemas params columns)
instance Data.SOP.Constraint.SListI (Squeal.PostgreSQL.Schema.TableToColumns table) => Squeal.PostgreSQL.Render.RenderSQL (Squeal.PostgreSQL.Manipulation.ConflictClause tab commons schemas params table)
instance forall kind (constraints :: [(GHC.Types.Symbol, kind)]). Squeal.PostgreSQL.Render.RenderSQL (Squeal.PostgreSQL.Manipulation.ConflictTarget constraints)
instance Squeal.PostgreSQL.Render.RenderSQL (Squeal.PostgreSQL.Manipulation.ConflictAction tab commons schemas params columns)
instance Squeal.PostgreSQL.Render.RenderSQL (Squeal.PostgreSQL.Manipulation.ReturningClause commons schemas params from row)
instance Squeal.PostgreSQL.Render.RenderSQL (Squeal.PostgreSQL.Manipulation.QueryClause commons schemas params columns)
instance forall k (expr :: k -> *) (ty :: (Squeal.PostgreSQL.Schema.ColumnConstraint, k)). (forall (x :: k). Squeal.PostgreSQL.Render.RenderSQL (expr x)) => Squeal.PostgreSQL.Render.RenderSQL (Squeal.PostgreSQL.Manipulation.Optional expr ty)
instance Squeal.PostgreSQL.Render.RenderSQL (Squeal.PostgreSQL.Manipulation.Manipulation commons schemas params columns)
instance Squeal.PostgreSQL.Query.With Squeal.PostgreSQL.Manipulation.Manipulation


-- | Subquery expressions
module Squeal.PostgreSQL.Expression.Subquery

-- | The argument of <a>exists</a> is an arbitrary subquery. The subquery
--   is evaluated to determine whether it returns any rows. If it returns
--   at least one row, the result of <a>exists</a> is <a>true</a>; if the
--   subquery returns no rows, the result of <a>exists</a> is <a>false</a>.
--   
--   The subquery can refer to variables from the surrounding query, which
--   will act as constants during any one evaluation of the subquery.
--   
--   The subquery will generally only be executed long enough to determine
--   whether at least one row is returned, not all the way to completion.
exists :: Query (Join outer from) commons schemas params row -> Condition outer commons grp schemas params from

-- | The result is <a>true</a> if the left-hand expression's result is
--   equal to any of the right-hand expressions.
--   
--   <pre>
--   &gt;&gt;&gt; printSQL $ true `in_` [true, false, null_]
--   TRUE IN (TRUE, FALSE, NULL)
--   </pre>
in_ :: Expression outer commons grp schemas params from ty -> [Expression outer commons grp schemas params from ty] -> Condition outer commons grp schemas params from

-- | The result is <a>true</a> if the left-hand expression's result is not
--   equal to any of the right-hand expressions.
--   
--   <pre>
--   &gt;&gt;&gt; printSQL $ true `notIn` [false, null_]
--   TRUE NOT IN (FALSE, NULL)
--   </pre>
notIn :: Expression outer commons grp schemas params from ty -> [Expression outer commons grp schemas params from ty] -> Condition outer commons grp schemas params from

-- | The right-hand side is a parenthesized subquery, which must return
--   exactly one column. The left-hand expression is evaluated and compared
--   to each row of the subquery result using the given <a>Operator</a>,
--   which must yield a Boolean result. The result of <a>subAll</a> is
--   <a>true</a> if all rows yield true (including the case where the
--   subquery returns no rows). The result is <a>false</a> if any
--   <a>false</a> result is found. The result is <a>null_</a> if no
--   comparison with a subquery row returns <a>false</a>, and at least one
--   comparison returns <a>null_</a>.
--   
--   <pre>
--   &gt;&gt;&gt; printSQL $ subAll true (.==) (values_ (true `as` #foo))
--   (TRUE = ALL (SELECT * FROM (VALUES (TRUE)) AS t ("foo")))
--   </pre>
subAll :: Expression outer commons grp schemas params from ty1 -> Operator ty1 ty2 ( 'Null  'PGbool) -> Query (Join outer from) commons schemas params '[col ::: ty2] -> Condition outer commons grp schemas params from

-- | The right-hand side is a parenthesized subquery, which must return
--   exactly one column. The left-hand expression is evaluated and compared
--   to each row of the subquery result using the given <a>Operator</a>,
--   which must yield a Boolean result. The result of <a>subAny</a> is
--   <a>true</a> if any <a>true</a> result is obtained. The result is
--   <a>false</a> if no true result is found (including the case where the
--   subquery returns no rows).
--   
--   <pre>
--   &gt;&gt;&gt; printSQL $ subAny "foo" like (values_ ("foobar" `as` #foo))
--   (E'foo' LIKE ANY (SELECT * FROM (VALUES (E'foobar')) AS t ("foo")))
--   </pre>
subAny :: Expression outer commons grp schemas params from ty1 -> Operator ty1 ty2 ( 'Null  'PGbool) -> Query (Join outer from) commons schemas params '[col ::: ty2] -> Condition outer commons grp schemas params from


-- | Set returning functions
module Squeal.PostgreSQL.Expression.SetOf

-- | <pre>
--   generateSeries (start *: stop)
--   </pre>
--   
--   Generate a series of values, from <tt>start</tt> to <tt>stop</tt> with
--   a step size of one
generateSeries :: ty `In` '[ 'PGint4,  'PGint8,  'PGnumeric] => SetOfFunctionN "generate_series" '[null ty, null ty] '["generate_series" ::: null ty]

-- | <pre>
--   generateSeries (start :* stop *: step)
--   </pre>
--   
--   Generate a series of values, from <tt>start</tt> to <tt>stop</tt> with
--   a step size of <tt>step</tt>
generateSeriesStep :: ty `In` '[ 'PGint4,  'PGint8,  'PGnumeric] => SetOfFunctionN "generate_series" '[null ty, null ty, null ty] '["generate_series" ::: null ty]

-- | <pre>
--   generateSeries (start :* stop *: step)
--   </pre>
--   
--   Generate a series of values, from <tt>start</tt> to <tt>stop</tt> with
--   a step size of <tt>step</tt>
generateSeriesTimestamp :: ty `In` '[ 'PGtimestamp,  'PGtimestamptz] => SetOfFunctionN "generate_series" '[null ty, null ty, null  'PGinterval] '["generate_series" ::: null ty]

-- | A <tt>RankNType</tt> for set returning functions with 1 argument.
type SetOfFunction fun ty setof = forall outer commons schemas params. Expression outer commons  'Ungrouped schemas params '[] ty " input" -> FromClause outer commons schemas params '[fun ::: setof] " output"

-- | Escape hatch for a set returning function with 1 argument.
unsafeSetOfFunction :: forall fun ty setof. KnownSymbol fun => SetOfFunction fun ty setof

-- | A <tt>RankNType</tt> for set returning functions with multiple
--   argument.
type SetOfFunctionN fun tys setof = forall outer commons schemas params. NP (Expression outer commons  'Ungrouped schemas params '[]) tys " inputs" -> FromClause outer commons schemas params '[fun ::: setof] " output"

-- | Escape hatch for a set returning function with multiple argument.
unsafeSetOfFunctionN :: forall fun tys setof. (SListI tys, KnownSymbol fun) => SetOfFunctionN fun tys setof


-- | Array and composite functions
module Squeal.PostgreSQL.Expression.Collection

-- | <pre>
--   &gt;&gt;&gt; printSQL $ array [null_, false, true]
--   ARRAY[NULL, FALSE, TRUE]
--   </pre>
array :: [Expression outer commons grp schemas params from ty] -> Expression outer commons grp schemas params from (null ( 'PGvararray ty))

-- | construct a 1-dimensional fixed length array
--   
--   <pre>
--   &gt;&gt;&gt; printSQL $ array1 (null_ :* false *: true)
--   ARRAY[NULL, FALSE, TRUE]
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; :type array1 (null_ :* false *: true)
--   array1 (null_ :* false *: true)
--     :: Expression
--          outer
--          commons
--          grp
--          schemas
--          params
--          from
--          (null ('PGfixarray '[3] ('Null 'PGbool)))
--   </pre>
array1 :: (n ~ Length tys, All ((~) ty) tys) => NP (Expression outer commons grp schemas params from) tys -> Expression outer commons grp schemas params from (null ( 'PGfixarray '[n] ty))

-- | construct a 2-dimensional fixed length array
--   
--   <pre>
--   &gt;&gt;&gt; printSQL $ array2 ((null_ :* false *: true) *: (false :* null_ *: true))
--   ARRAY[[NULL, FALSE, TRUE], [FALSE, NULL, TRUE]]
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; :type array2 ((null_ :* false *: true) *: (false :* null_ *: true))
--   array2 ((null_ :* false *: true) *: (false :* null_ *: true))
--     :: Expression
--          outer
--          commons
--          grp
--          schemas
--          params
--          from
--          (null ('PGfixarray '[2, 3] ('Null 'PGbool)))
--   </pre>
array2 :: (All ((~) tys) tyss, All SListI tyss, Length tyss ~ n1, All ((~) ty) tys, Length tys ~ n2) => NP (NP (Expression outer commons grp schemas params from)) tyss -> Expression outer commons grp schemas params from (null ( 'PGfixarray '[n1, n2] ty))

-- | <pre>
--   &gt;&gt;&gt; printSQL $ cardinality (array [null_, false, true])
--   cardinality(ARRAY[NULL, FALSE, TRUE])
--   </pre>
cardinality :: null ( 'PGvararray ty) :--> null  'PGint8

-- | <pre>
--   &gt;&gt;&gt; printSQL $ array [null_, false, true] &amp; index 2
--   (ARRAY[NULL, FALSE, TRUE])[2]
--   </pre>
index :: Word64 -> null ( 'PGvararray ty) :--> NullifyType ty

-- | Expand an array to a set of rows
unnest :: SetOfFunction "unnest" (null ( 'PGvararray ty)) '["unnest" ::: ty]

-- | A row constructor is an expression that builds a row value (also
--   called a composite value) using values for its member fields.
--   
--   <pre>
--   &gt;&gt;&gt; :{
--   type Complex = 'PGcomposite
--     '[ "real"      ::: 'NotNull 'PGfloat8
--      , "imaginary" ::: 'NotNull 'PGfloat8 ]
--   :}
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; let i = row (0 `as` #real :* 1 `as` #imaginary) :: Expression outer commons grp schemas params from ('NotNull Complex)
--   
--   &gt;&gt;&gt; printSQL i
--   ROW(0, 1)
--   </pre>
row :: SListI row => NP (Aliased (Expression outer commons grp schemas params from)) row -> Expression outer commons grp schemas params from (null ( 'PGcomposite row))

-- | <pre>
--   &gt;&gt;&gt; :{
--   type Complex = 'PGcomposite
--     '[ "real"      ::: 'NotNull 'PGfloat8
--      , "imaginary" ::: 'NotNull 'PGfloat8 ]
--   type Schema = '["complex" ::: 'Typedef Complex]
--   :}
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; let i = row (0 `as` #real :* 1 `as` #imaginary) :: Expression outer '[] grp (Public Schema) from params ('NotNull Complex)
--   
--   &gt;&gt;&gt; printSQL $ i &amp; field #complex #imaginary
--   (ROW(0, 1)::"complex")."imaginary"
--   </pre>
field :: (Has sch schemas schema, Has tydef schema ( 'Typedef ( 'PGcomposite row)), Has field row ty) => QualifiedAlias sch tydef -> Alias field -> Expression outer commons grp schemas params from ( 'NotNull ( 'PGcomposite row)) -> Expression outer commons grp schemas params from ty


-- | Json and Jsonb functions and operators
module Squeal.PostgreSQL.Expression.Json

-- | Get JSON value (object field or array element) at a key.
(.->) :: (json `In` PGJsonType, key `In` PGJsonKey) => Operator (null json) (null key) ( 'Null json)
infixl 8 .->

-- | Get JSON value (object field or array element) at a key, as text.
(.->>) :: (json `In` PGJsonType, key `In` PGJsonKey) => Operator (null json) (null key) ( 'Null  'PGtext)
infixl 8 .->>

-- | Get JSON value at a specified path.
(.#>) :: json `In` PGJsonType => Operator (null json) (null ( 'PGvararray ( 'NotNull  'PGtext))) ( 'Null json)
infixl 8 .#>

-- | Get JSON value at a specified path as text.
(.#>>) :: json `In` PGJsonType => Operator (null json) (null ( 'PGvararray ( 'NotNull  'PGtext))) ( 'Null  'PGtext)
infixl 8 .#>>

-- | Does the string exist as a top-level key within the JSON value?
(.?) :: Operator (null  'PGjsonb) (null  'PGtext) ( 'Null  'PGbool)
infixl 9 .?

-- | Do any of these array strings exist as top-level keys?
(.?|) :: Operator (null  'PGjsonb) (null ( 'PGvararray ( 'NotNull  'PGtext))) ( 'Null  'PGbool)
infixl 9 .?|

-- | Do all of these array strings exist as top-level keys?
(.?&) :: Operator (null  'PGjsonb) (null ( 'PGvararray ( 'NotNull  'PGtext))) ( 'Null  'PGbool)
infixl 9 .?&

-- | Delete a key or keys from a JSON object, or remove an array element.
--   
--   If the right operand is
--   
--   <tt> text </tt>: Delete key / value pair or string element from left
--   operand. Key / value pairs are matched based on their key value,
--   
--   <tt> text[] </tt>: Delete multiple key / value pairs or string
--   elements from left operand. Key / value pairs are matched based on
--   their key value,
--   
--   <tt> integer </tt>: 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 ( 'NotNull  'PGtext),  'PGint4,  'PGint2] => Operator (null  'PGjsonb) (null key) (null  'PGjsonb)
infixl 6 .-.

-- | Delete the field or element with specified path (for JSON arrays,
--   negative integers count from the end)
(#-.) :: Operator (null  'PGjsonb) (null ( 'PGvararray ( 'NotNull  'PGtext))) (null  'PGjsonb)
infixl 6 #-.

-- | Returns the value as json. Arrays and composites are converted
--   (recursively) to arrays and objects; otherwise, if there is a cast
--   from the type to json, the cast function will be used to perform the
--   conversion; otherwise, a scalar value is produced. For any scalar type
--   other than a 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 :: null ty :--> null  'PGjson

-- | Returns the value as jsonb. Arrays and composites are converted
--   (recursively) to arrays and objects; otherwise, if there is a cast
--   from the type to json, the cast function will be used to perform the
--   conversion; otherwise, a scalar value is produced. For any scalar type
--   other than a 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 :: null ty :--> null  'PGjsonb

-- | Returns the array as a JSON array. A PostgreSQL multidimensional array
--   becomes a JSON array of arrays.
arrayToJson :: null ( 'PGvararray ty) :--> null  'PGjson

-- | Returns the row as a JSON object.
rowToJson :: null ( 'PGcomposite ty) :--> null  'PGjson

-- | Builds a possibly-heterogeneously-typed JSON array out of a variadic
--   argument list.
jsonBuildArray :: SListI tuple => FunctionN tuple (null  'PGjson)

-- | Builds a possibly-heterogeneously-typed (binary) JSON array out of a
--   variadic argument list.
jsonbBuildArray :: SListI tuple => FunctionN tuple (null  'PGjsonb)

-- | Builds a possibly-heterogeneously-typed JSON object out of a variadic
--   argument list. The elements of the argument list must alternate
--   between text and values.
class SListI tys => JsonBuildObject tys
jsonBuildObject :: JsonBuildObject tys => FunctionN tys (null  'PGjson)
jsonbBuildObject :: JsonBuildObject tys => FunctionN tys (null  'PGjsonb)

-- | Builds a JSON object out of a text array. The array must have two
--   dimensions such that each inner array has exactly two elements, which
--   are taken as a key/value pair.
jsonObject :: null ( 'PGfixarray '[n, 2] ( 'NotNull  'PGtext)) :--> null  'PGjson

-- | Builds a binary JSON object out of a text array. The array must have
--   two dimensions such that each inner array has exactly two elements,
--   which are taken as a key/value pair.
jsonbObject :: null ( 'PGfixarray '[n, 2] ( 'NotNull  'PGtext)) :--> null  'PGjsonb

-- | This is an alternate form of <a>jsonObject</a> that takes two arrays;
--   one for keys and one for values, that are zipped pairwise to create a
--   JSON object.
jsonZipObject :: FunctionN '[null ( 'PGvararray ( 'NotNull  'PGtext)), null ( 'PGvararray ( 'NotNull  'PGtext))] (null  'PGjson)

-- | This is an alternate form of <a>jsonbObject</a> that takes two arrays;
--   one for keys and one for values, that are zipped pairwise to create a
--   binary JSON object.
jsonbZipObject :: FunctionN '[null ( 'PGvararray ( 'NotNull  'PGtext)), null ( 'PGvararray ( 'NotNull  'PGtext))] (null  'PGjsonb)

-- | Returns the number of elements in the outermost JSON array.
jsonArrayLength :: null  'PGjson :--> null  'PGint4

-- | Returns the number of elements in the outermost binary JSON array.
jsonbArrayLength :: null  'PGjsonb :--> null  'PGint4

-- | Returns the type of the outermost JSON value as a text string.
--   Possible types are object, array, string, number, boolean, and null.
jsonTypeof :: null  'PGjson :--> null  'PGtext

-- | Returns the type of the outermost binary JSON value as a text string.
--   Possible types are object, array, string, number, boolean, and null.
jsonbTypeof :: null  'PGjsonb :--> null  'PGtext

-- | Returns its argument with all object fields that have null values
--   omitted. Other null values are untouched.
jsonStripNulls :: null  'PGjson :--> null  'PGjson

-- | Returns its argument with all object fields that have null values
--   omitted. Other null values are untouched.
jsonbStripNulls :: null  'PGjsonb :--> null  'PGjsonb

-- | <pre>
--   jsonbSet target path new_value create_missing
--   </pre>
--   
--   Returns target with the section designated by path replaced by
--   <tt>new_value</tt>, or with <tt>new_value</tt> added if create_missing
--   is <a>true</a> and the item designated by path does not exist. As with
--   the path orientated operators, negative integers that appear in path
--   count from the end of JSON arrays.
jsonbSet :: FunctionN '[null  'PGjsonb, null ( 'PGvararray ( 'NotNull  'PGtext)), null  'PGjsonb, null  'PGbool] (null  'PGjsonb)

-- | <pre>
--   jsonbInsert target path new_value insert_after
--   </pre>
--   
--   Returns target with <tt>new_value</tt> inserted. If target section
--   designated by path is in a JSONB array, <tt>new_value</tt> will be
--   inserted before target or after if <tt>insert_after</tt> is
--   <a>true</a>. If target section designated by path is in JSONB object,
--   <tt>new_value</tt> will be inserted only if target does not exist. As
--   with the path orientated operators, negative integers that appear in
--   path count from the end of JSON arrays.
jsonbInsert :: FunctionN '[null  'PGjsonb, null ( 'PGvararray ( 'NotNull  'PGtext)), null  'PGjsonb, null  'PGbool] (null  'PGjsonb)

-- | Returns its argument as indented JSON text.
jsonbPretty :: null  'PGjsonb :--> null  'PGtext

-- | Expands the outermost JSON object into a set of key/value pairs.
--   
--   <pre>
--   &gt;&gt;&gt; printSQL (select Star (from (jsonEach (literal (Json (object ["a" .= "foo", "b" .= "bar"]))))))
--   SELECT * FROM json_each(('{"a":"foo","b":"bar"}' :: json))
--   </pre>
jsonEach :: SetOfFunction "json_each" (null  'PGjson) '["key" :::  'NotNull  'PGtext, "value" :::  'NotNull  'PGjson]

-- | Expands the outermost binary JSON object into a set of key/value
--   pairs.
--   
--   <pre>
--   &gt;&gt;&gt; printSQL (select Star (from (jsonbEach (literal (Jsonb (object ["a" .= "foo", "b" .= "bar"]))))))
--   SELECT * FROM jsonb_each(('{"a":"foo","b":"bar"}' :: jsonb))
--   </pre>
jsonbEach :: SetOfFunction "jsonb_each" (nullity  'PGjsonb) '["key" :::  'NotNull  'PGtext, "value" :::  'NotNull  'PGjson]

-- | Expands the outermost JSON object into a set of key/value pairs.
--   
--   <pre>
--   &gt;&gt;&gt; printSQL (select Star (from (jsonEachText (literal (Json (object ["a" .= "foo", "b" .= "bar"]))))))
--   SELECT * FROM json_each_text(('{"a":"foo","b":"bar"}' :: json))
--   </pre>
jsonEachText :: SetOfFunction "json_each_text" (null  'PGjson) '["key" :::  'NotNull  'PGtext, "value" :::  'NotNull  'PGtext]

-- | Expands the outermost binary JSON object into a set of key/value
--   pairs.
--   
--   <pre>
--   &gt;&gt;&gt; printSQL (select Star (from (jsonbEachText (literal (Jsonb (object ["a" .= "foo", "b" .= "bar"]))))))
--   SELECT * FROM jsonb_each_text(('{"a":"foo","b":"bar"}' :: jsonb))
--   </pre>
jsonbEachText :: SetOfFunction "jsonb_each_text" (null  'PGjsonb) '["key" :::  'NotNull  'PGtext, "value" :::  'NotNull  'PGtext]

-- | Returns set of keys in the outermost JSON object.
--   
--   <pre>
--   &gt;&gt;&gt; printSQL (jsonObjectKeys (literal (Json (object ["a" .= "foo", "b" .= "bar"]))))
--   json_object_keys(('{"a":"foo","b":"bar"}' :: json))
--   </pre>
jsonObjectKeys :: SetOfFunction "json_object_keys" (nullity  'PGjson) '["json_object_keys" :::  'NotNull  'PGtext]

-- | Returns set of keys in the outermost JSON object.
--   
--   <pre>
--   &gt;&gt;&gt; printSQL (jsonbObjectKeys (literal (Jsonb (object ["a" .= "foo", "b" .= "bar"]))))
--   jsonb_object_keys(('{"a":"foo","b":"bar"}' :: jsonb))
--   </pre>
jsonbObjectKeys :: SetOfFunction "jsonb_object_keys" (null  'PGjsonb) '["jsonb_object_keys" :::  'NotNull  'PGtext]

-- | Build rows from Json types.
type JsonPopulateFunction fun json = forall schemas row outer commons params. json `In` PGJsonType => TypeExpression schemas ( 'NotNull ( 'PGcomposite row)) " row type" -> Expression outer commons  'Ungrouped schemas params '[] ( 'NotNull json) " json type" -> FromClause outer commons schemas params '[fun ::: row]

-- | Expands the JSON expression to a row whose columns match the record
--   type defined by the given table.
jsonPopulateRecord :: JsonPopulateFunction "json_populate_record"  'PGjson

-- | Expands the binary JSON expression to a row whose columns match the
--   record type defined by the given table.
jsonbPopulateRecord :: JsonPopulateFunction "jsonb_populate_record"  'PGjsonb

-- | 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.
jsonPopulateRecordSet :: JsonPopulateFunction "json_populate_record_set"  'PGjson

-- | 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.
jsonbPopulateRecordSet :: JsonPopulateFunction "jsonb_populate_record_set"  'PGjsonb

-- | Build rows from Json types.
type JsonToRecordFunction json = forall outer commons schemas params tab row. (SListI row, json `In` PGJsonType) => Expression outer commons  'Ungrouped schemas params '[] ( 'NotNull json) " json type" -> Aliased (NP (Aliased (TypeExpression schemas))) (tab ::: row) " row type" -> FromClause outer commons schemas params '[tab ::: row]

-- | Builds an arbitrary record from a JSON object.
jsonToRecord :: JsonToRecordFunction  'PGjson

-- | Builds an arbitrary record from a binary JSON object.
jsonbToRecord :: JsonToRecordFunction  'PGjsonb

-- | Builds an arbitrary set of records from a JSON array of objects.
jsonToRecordSet :: JsonToRecordFunction  'PGjson

-- | Builds an arbitrary set of records from a binary JSON array of
--   objects.
jsonbToRecordSet :: JsonToRecordFunction  'PGjsonb
instance Squeal.PostgreSQL.Expression.Json.JsonBuildObject '[]
instance (Squeal.PostgreSQL.Expression.Json.JsonBuildObject tys, Squeal.PostgreSQL.List.In key Squeal.PostgreSQL.Schema.PGJsonKey) => Squeal.PostgreSQL.Expression.Json.JsonBuildObject ('Squeal.PostgreSQL.Schema.NotNull key : value : tys)


-- | Squeal data definition language.
module Squeal.PostgreSQL.Definition

-- | A <a>Definition</a> is a statement that changes the schemas of the
--   database, like a <a>createTable</a>, <a>dropTable</a>, or
--   <a>alterTable</a> command. <a>Definition</a>s may be composed using
--   the <a>&gt;&gt;&gt;</a> operator.
newtype Definition (schemas0 :: SchemasType) (schemas1 :: SchemasType)
UnsafeDefinition :: ByteString -> Definition
[renderDefinition] :: Definition -> ByteString

-- | Left-to-right composition
(>>>) :: Category cat => cat a b -> cat b c -> cat a c
infixr 1 >>>

-- | A <a>Manipulation</a> without input or output can be run as a
--   statement along with other <a>Definition</a>s, by embedding it using
--   <a>manipDefinition</a>.
manipDefinition :: Manipulation '[] schemas '[] '[] -> Definition schemas schemas

-- | <a>createSchema</a> enters a new schema into the current database. The
--   schema name must be distinct from the name of any existing schema in
--   the current database.
--   
--   A schema is essentially a namespace: it contains named objects
--   (tables, data types, functions, and operators) whose names can
--   duplicate those of other objects existing in other schemas. Named
--   objects are accessed by <a>QualifiedAlias</a>es with the schema name
--   as a prefix.
createSchema :: KnownSymbol sch => Alias sch -> Definition schemas (Create sch '[] schemas)

-- | Idempotent version of <a>createSchema</a>.
createSchemaIfNotExists :: (KnownSymbol sch, Has sch schemas schema) => Alias sch -> Definition schemas schemas

-- | <a>createTable</a> adds a table to the schema.
--   
--   <pre>
--   &gt;&gt;&gt; :set -XOverloadedLabels
--   
--   &gt;&gt;&gt; :{
--   type Table = '[] :=&gt;
--     '[ "a" ::: 'NoDef :=&gt; 'Null 'PGint4
--      , "b" ::: 'NoDef :=&gt; 'Null 'PGfloat4 ]
--   :}
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; :{
--   let
--     setup :: Definition (Public '[]) (Public '["tab" ::: 'Table Table])
--     setup = createTable #tab
--       (nullable int `as` #a :* nullable real `as` #b) Nil
--   in printSQL setup
--   :}
--   CREATE TABLE "tab" ("a" int NULL, "b" real NULL);
--   </pre>
createTable :: (KnownSymbol sch, KnownSymbol tab, columns ~ (col : cols), SListI columns, SListI constraints, Has sch schemas0 schema0, schemas1 ~ Alter sch (Create tab ( 'Table (constraints :=> columns)) schema0) schemas0) => QualifiedAlias sch tab -> NP (Aliased (ColumnTypeExpression schemas0)) columns -> NP (Aliased (TableConstraintExpression sch tab schemas1)) constraints -> Definition schemas0 schemas1

-- | <a>createTableIfNotExists</a> creates a table if it doesn't exist, but
--   does not add it to the schema. Instead, the schema already has the
--   table so if the table did not yet exist, the schema was wrong.
--   <a>createTableIfNotExists</a> fixes this. Interestingly, this property
--   makes it an idempotent in the <a>Category</a> of <a>Definition</a>s.
--   
--   <pre>
--   &gt;&gt;&gt; :set -XOverloadedLabels -XTypeApplications
--   
--   &gt;&gt;&gt; :{
--   type Table = '[] :=&gt;
--     '[ "a" ::: 'NoDef :=&gt; 'Null 'PGint4
--      , "b" ::: 'NoDef :=&gt; 'Null 'PGfloat4 ]
--   :}
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; type Schemas = Public '["tab" ::: 'Table Table]
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; :{
--   let
--     setup :: Definition Schemas Schemas
--     setup = createTableIfNotExists #tab
--       (nullable int `as` #a :* nullable real `as` #b) Nil
--   in printSQL setup
--   :}
--   CREATE TABLE IF NOT EXISTS "tab" ("a" int NULL, "b" real NULL);
--   </pre>
createTableIfNotExists :: (Has sch schemas schema, Has tab schema ( 'Table (constraints :=> columns)), SListI columns, SListI constraints) => QualifiedAlias sch tab -> NP (Aliased (ColumnTypeExpression schemas)) columns -> NP (Aliased (TableConstraintExpression sch tab schemas)) constraints -> Definition schemas schemas

-- | Create a view. &gt;&gt;&gt; type ABC = '["a" ::: 'NoDef :=&gt; 'Null
--   'PGint4, "b" ::: 'NoDef :=&gt; 'Null 'PGint4, "c" ::: 'NoDef :=&gt;
--   'Null 'PGint4] &gt;&gt;&gt; type BC = '["b" ::: 'Null 'PGint4, "c" :::
--   'Null 'PGint4] &gt;&gt;&gt; :{ let definition :: Definition '[
--   "public" ::: '["abc" ::: 'Table ('[] :=&gt; ABC)]] '[ "public" :::
--   '["abc" ::: 'Table ('[] :=&gt; ABC), "bc" ::: 'View BC]] definition =
--   createView b :* abc))) in printSQL definition :} CREATE VIEW "bc" AS
--   SELECT "b" AS "b", "c" AS "c" FROM "abc" AS "abc";
createView :: (KnownSymbol sch, KnownSymbol vw, Has sch schemas schema) => QualifiedAlias sch vw -> Query '[] '[] schemas '[] view -> Definition schemas (Alter sch (Create vw ( 'View view) schema) schemas)

-- | Enumerated types are created using the <a>createTypeEnum</a> command,
--   for example
--   
--   <pre>
--   &gt;&gt;&gt; printSQL $ (createTypeEnum #mood (label @"sad" :* label @"ok" :* label @"happy") :: Definition (Public '[]) '["public" ::: '["mood" ::: 'Typedef ('PGenum '["sad","ok","happy"])]])
--   CREATE TYPE "mood" AS ENUM ('sad', 'ok', 'happy');
--   </pre>
createTypeEnum :: (KnownSymbol enum, Has sch schemas schema, All KnownSymbol labels) => QualifiedAlias sch enum -> NP PGlabel labels -> Definition schemas (Alter sch (Create enum ( 'Typedef ( 'PGenum labels)) schema) schemas)

-- | Enumerated types can also be generated from a Haskell type, for
--   example
--   
--   <pre>
--   &gt;&gt;&gt; data Schwarma = Beef | Lamb | Chicken deriving GHC.Generic
--   
--   &gt;&gt;&gt; instance SOP.Generic Schwarma
--   
--   &gt;&gt;&gt; instance SOP.HasDatatypeInfo Schwarma
--   
--   &gt;&gt;&gt; :{
--   let
--     createSchwarma :: Definition (Public '[]) '["public" ::: '["schwarma" ::: 'Typedef (PG (Enumerated Schwarma))]]
--     createSchwarma = createTypeEnumFrom @Schwarma #schwarma
--   in
--     printSQL createSchwarma
--   :}
--   CREATE TYPE "schwarma" AS ENUM ('Beef', 'Lamb', 'Chicken');
--   </pre>
createTypeEnumFrom :: forall hask sch enum schemas schema. (Generic hask, All KnownSymbol (LabelsPG hask), KnownSymbol enum, Has sch schemas schema) => QualifiedAlias sch enum -> Definition schemas (Alter sch (Create enum ( 'Typedef (PG (Enumerated hask))) schema) schemas)

-- | <a>createTypeComposite</a> creates a composite type. The composite
--   type is specified by a list of attribute names and data types.
--   
--   <pre>
--   &gt;&gt;&gt; :{
--   type PGcomplex = 'PGcomposite
--     '[ "real"      ::: 'NotNull 'PGfloat8
--      , "imaginary" ::: 'NotNull 'PGfloat8 ]
--   :}
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; :{
--   let
--     setup :: Definition (Public '[]) '["public" ::: '["complex" ::: 'Typedef PGcomplex]]
--     setup = createTypeComposite #complex
--       (float8 `as` #real :* float8 `as` #imaginary)
--   in printSQL setup
--   :}
--   CREATE TYPE "complex" AS ("real" float8, "imaginary" float8);
--   </pre>
createTypeComposite :: (KnownSymbol ty, Has sch schemas schema, SListI fields) => QualifiedAlias sch ty -> NP (Aliased (TypeExpression schemas)) fields -> Definition schemas (Alter sch (Create ty ( 'Typedef ( 'PGcomposite fields)) schema) schemas)

-- | Composite types can also be generated from a Haskell type, for example
--   
--   <pre>
--   &gt;&gt;&gt; data Complex = Complex {real :: Double, imaginary :: Double} deriving GHC.Generic
--   
--   &gt;&gt;&gt; instance SOP.Generic Complex
--   
--   &gt;&gt;&gt; instance SOP.HasDatatypeInfo Complex
--   
--   &gt;&gt;&gt; type Schema = '["complex" ::: 'Typedef (PG (Composite Complex))]
--   
--   &gt;&gt;&gt; :{
--   let
--     createComplex :: Definition (Public '[]) (Public Schema)
--     createComplex = createTypeCompositeFrom @Complex #complex
--   in
--     printSQL createComplex
--   :}
--   CREATE TYPE "complex" AS ("real" float8, "imaginary" float8);
--   </pre>
createTypeCompositeFrom :: forall hask sch ty schemas schema. (All (FieldTyped schemas) (RowPG hask), KnownSymbol ty, Has sch schemas schema) => QualifiedAlias sch ty -> Definition schemas (Alter sch (Create ty ( 'Typedef (PG (Composite hask))) schema) schemas)

-- | Lift <a>PGTyped</a> to a field
class FieldTyped schemas ty
fieldtype :: FieldTyped schemas ty => Aliased (TypeExpression schemas) ty

-- | <a>createDomain</a> creates a new domain. A domain is essentially a
--   data type with constraints (restrictions on the allowed set of
--   values).
--   
--   Domains are useful for abstracting common constraints on fields into a
--   single location for maintenance. For example, several tables might
--   contain email address columns, all requiring the same <a>check</a>
--   constraint to verify the address syntax. Define a domain rather than
--   setting up each table's constraint individually.
--   
--   <pre>
--   &gt;&gt;&gt; :{
--   let
--     createPositive :: Definition (Public '[]) (Public '["positive" ::: 'Typedef 'PGfloat4])
--     createPositive = createDomain #positive real (#value .&gt; 0 .&amp;&amp; (#value &amp; isNotNull))
--   in printSQL createPositive
--   :}
--   CREATE DOMAIN "positive" AS real CHECK ((("value" &gt; 0) AND "value" IS NOT NULL));
--   </pre>
createDomain :: (Has sch schemas schema, KnownSymbol dom) => QualifiedAlias sch dom -> (forall nullity. TypeExpression schemas (nullity ty)) -> (forall tab. Condition '[] '[]  'Ungrouped schemas '[] '[tab ::: '["value" :::  'Null ty]]) -> Definition schemas (Alter sch (Create alias ( 'Typedef ty) schema) schemas)

-- | Data types are a way to limit the kind of data that can be stored in a
--   table. For many applications, however, the constraint they provide is
--   too coarse. For example, a column containing a product price should
--   probably only accept positive values. But there is no standard data
--   type that accepts only positive numbers. Another issue is that you
--   might want to constrain column data with respect to other columns or
--   rows. For example, in a table containing product information, there
--   should be only one row for each product number.
--   <a>TableConstraint</a>s give you as much control over the data in your
--   tables as you wish. If a user attempts to store data in a column that
--   would violate a constraint, an error is raised. This applies even if
--   the value came from the default value definition.
newtype TableConstraintExpression (sch :: Symbol) (tab :: Symbol) (schemas :: SchemasType) (constraint :: TableConstraint)
UnsafeTableConstraintExpression :: ByteString -> TableConstraintExpression
[renderTableConstraintExpression] :: TableConstraintExpression -> ByteString

-- | A <a>check</a> constraint is the most generic <a>TableConstraint</a>
--   type. It allows you to specify that the value in a certain column must
--   satisfy a Boolean (truth-value) expression.
--   
--   <pre>
--   &gt;&gt;&gt; :{
--   type Schema = '[
--     "tab" ::: 'Table ('[ "inequality" ::: 'Check '["a","b"]] :=&gt; '[
--       "a" ::: 'NoDef :=&gt; 'NotNull 'PGint4,
--       "b" ::: 'NoDef :=&gt; 'NotNull 'PGint4
--     ])]
--   :}
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; :{
--   let
--     definition :: Definition (Public '[]) (Public Schema)
--     definition = createTable #tab
--       ( (int &amp; notNullable) `as` #a :*
--         (int &amp; notNullable) `as` #b )
--       ( check (#a :* #b) (#a .&gt; #b) `as` #inequality )
--   :}
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; printSQL definition
--   CREATE TABLE "tab" ("a" int NOT NULL, "b" int NOT NULL, CONSTRAINT "inequality" CHECK (("a" &gt; "b")));
--   </pre>
check :: (Has sch schemas schema, Has tab schema ( 'Table table), HasAll aliases (TableToRow table) subcolumns) => NP Alias aliases -> (forall t. Condition '[] '[]  'Ungrouped schemas '[] '[t ::: subcolumns]) -> TableConstraintExpression sch tab schemas ( 'Check aliases)

-- | A <a>unique</a> constraint ensure that the data contained in a column,
--   or a group of columns, is unique among all the rows in the table.
--   
--   <pre>
--   &gt;&gt;&gt; :{
--   type Schema = '[
--     "tab" ::: 'Table( '[ "uq_a_b" ::: 'Unique '["a","b"]] :=&gt; '[
--       "a" ::: 'NoDef :=&gt; 'Null 'PGint4,
--       "b" ::: 'NoDef :=&gt; 'Null 'PGint4
--     ])]
--   :}
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; :{
--   let
--     definition :: Definition (Public '[]) (Public Schema)
--     definition = createTable #tab
--       ( (int &amp; nullable) `as` #a :*
--         (int &amp; nullable) `as` #b )
--       ( unique (#a :* #b) `as` #uq_a_b )
--   :}
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; printSQL definition
--   CREATE TABLE "tab" ("a" int NULL, "b" int NULL, CONSTRAINT "uq_a_b" UNIQUE ("a", "b"));
--   </pre>
unique :: (Has sch schemas schema, Has tab schema ( 'Table table), HasAll aliases (TableToRow table) subcolumns) => NP Alias aliases -> TableConstraintExpression sch tab schemas ( 'Unique aliases)

-- | A <a>primaryKey</a> constraint indicates that a column, or group of
--   columns, can be used as a unique identifier for rows in the table.
--   This requires that the values be both unique and not null.
--   
--   <pre>
--   &gt;&gt;&gt; :{
--   type Schema = '[
--     "tab" ::: 'Table ('[ "pk_id" ::: 'PrimaryKey '["id"]] :=&gt; '[
--       "id" ::: 'Def :=&gt; 'NotNull 'PGint4,
--       "name" ::: 'NoDef :=&gt; 'NotNull 'PGtext
--     ])]
--   :}
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; :{
--   let
--     definition :: Definition (Public '[]) (Public Schema)
--     definition = createTable #tab
--       ( serial `as` #id :*
--         (text &amp; notNullable) `as` #name )
--       ( primaryKey #id `as` #pk_id )
--   :}
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; printSQL definition
--   CREATE TABLE "tab" ("id" serial, "name" text NOT NULL, CONSTRAINT "pk_id" PRIMARY KEY ("id"));
--   </pre>
primaryKey :: (Has sch schemas schema, Has tab schema ( 'Table table), HasAll aliases (TableToColumns table) subcolumns, AllNotNull subcolumns) => NP Alias aliases -> TableConstraintExpression sch tab schemas ( 'PrimaryKey aliases)

-- | A <a>foreignKey</a> specifies that the values in a column (or a group
--   of columns) must match the values appearing in some row of another
--   table. We say this maintains the referential integrity between two
--   related tables.
--   
--   <pre>
--   &gt;&gt;&gt; :{
--   type Schema =
--     '[ "users" ::: 'Table (
--          '[ "pk_users" ::: 'PrimaryKey '["id"] ] :=&gt;
--          '[ "id" ::: 'Def :=&gt; 'NotNull 'PGint4
--           , "name" ::: 'NoDef :=&gt; 'NotNull 'PGtext
--           ])
--      , "emails" ::: 'Table (
--          '[  "pk_emails" ::: 'PrimaryKey '["id"]
--           , "fk_user_id" ::: 'ForeignKey '["user_id"] "users" '["id"]
--           ] :=&gt;
--          '[ "id" ::: 'Def :=&gt; 'NotNull 'PGint4
--           , "user_id" ::: 'NoDef :=&gt; 'NotNull 'PGint4
--           , "email" ::: 'NoDef :=&gt; 'Null 'PGtext
--           ])
--      ]
--   :}
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; :{
--   let
--     setup :: Definition (Public '[]) (Public Schema)
--     setup =
--      createTable #users
--        ( serial `as` #id :*
--          (text &amp; notNullable) `as` #name )
--        ( primaryKey #id `as` #pk_users ) &gt;&gt;&gt;
--      createTable #emails
--        ( serial `as` #id :*
--          (int &amp; notNullable) `as` #user_id :*
--          (text &amp; nullable) `as` #email )
--        ( primaryKey #id `as` #pk_emails :*
--          foreignKey #user_id #users #id
--            OnDeleteCascade OnUpdateCascade `as` #fk_user_id )
--   in printSQL setup
--   :}
--   CREATE TABLE "users" ("id" serial, "name" text NOT NULL, CONSTRAINT "pk_users" PRIMARY KEY ("id"));
--   CREATE TABLE "emails" ("id" serial, "user_id" int NOT NULL, "email" text NULL, CONSTRAINT "pk_emails" PRIMARY KEY ("id"), CONSTRAINT "fk_user_id" FOREIGN KEY ("user_id") REFERENCES "users" ("id") ON DELETE CASCADE ON UPDATE CASCADE);
--   </pre>
--   
--   A <a>foreignKey</a> can even be a table self-reference.
--   
--   <pre>
--   &gt;&gt;&gt; :{
--   type Schema =
--     '[ "employees" ::: 'Table (
--          '[ "employees_pk"          ::: 'PrimaryKey '["id"]
--           , "employees_employer_fk" ::: 'ForeignKey '["employer_id"] "employees" '["id"]
--           ] :=&gt;
--          '[ "id"          :::   'Def :=&gt; 'NotNull 'PGint4
--           , "name"        ::: 'NoDef :=&gt; 'NotNull 'PGtext
--           , "employer_id" ::: 'NoDef :=&gt;    'Null 'PGint4
--           ])
--      ]
--   :}
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; :{
--   let
--     setup :: Definition (Public '[]) (Public Schema)
--     setup =
--      createTable #employees
--        ( serial `as` #id :*
--          (text &amp; notNullable) `as` #name :*
--          (integer &amp; nullable) `as` #employer_id )
--        ( primaryKey #id `as` #employees_pk :*
--          foreignKey #employer_id #employees #id
--            OnDeleteCascade OnUpdateCascade `as` #employees_employer_fk )
--   in printSQL setup
--   :}
--   CREATE TABLE "employees" ("id" serial, "name" text NOT NULL, "employer_id" integer NULL, CONSTRAINT "employees_pk" PRIMARY KEY ("id"), CONSTRAINT "employees_employer_fk" FOREIGN KEY ("employer_id") REFERENCES "employees" ("id") ON DELETE CASCADE ON UPDATE CASCADE);
--   </pre>
foreignKey :: ForeignKeyed schemas sch schema child parent table reftable columns refcolumns constraints cols reftys tys => NP Alias columns -> Alias parent -> NP Alias refcolumns -> OnDeleteClause -> OnUpdateClause -> TableConstraintExpression sch child schemas ( 'ForeignKey columns parent refcolumns)

-- | A constraint synonym between types involved in a foreign key
--   constraint.
type ForeignKeyed schemas sch schema child parent table reftable columns refcolumns constraints cols reftys tys = (Has sch schemas schema, Has child schema ( 'Table table), Has parent schema ( 'Table reftable), HasAll columns (TableToColumns table) tys, reftable ~ (constraints :=> cols), HasAll refcolumns cols reftys, AllZip SamePGType tys reftys, Uniquely refcolumns constraints)

-- | <a>OnDeleteClause</a> indicates what to do with rows that reference a
--   deleted row.
data OnDeleteClause

-- | if any referencing rows still exist when the constraint is checked, an
--   error is raised
OnDeleteNoAction :: OnDeleteClause

-- | prevents deletion of a referenced row
OnDeleteRestrict :: OnDeleteClause

-- | specifies that when a referenced row is deleted, row(s) referencing it
--   should be automatically deleted as well
OnDeleteCascade :: OnDeleteClause

-- | Analagous to <a>OnDeleteClause</a> there is also <a>OnUpdateClause</a>
--   which is invoked when a referenced column is changed (updated).
data OnUpdateClause

-- | if any referencing rows has not changed when the constraint is
--   checked, an error is raised
OnUpdateNoAction :: OnUpdateClause

-- | prevents update of a referenced row
OnUpdateRestrict :: OnUpdateClause

-- | the updated values of the referenced column(s) should be copied into
--   the referencing row(s)
OnUpdateCascade :: OnUpdateClause

-- | <pre>
--   &gt;&gt;&gt; :{
--   let
--     definition :: Definition '["muh_schema" ::: schema, "public" ::: public] '["public" ::: public]
--     definition = dropSchema #muh_schema
--   :}
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; printSQL definition
--   DROP SCHEMA "muh_schema";
--   </pre>
dropSchema :: Has sch schemas schema => Alias sch -> Definition schemas (Drop sch schemas)

-- | <a>dropTable</a> removes a table from the schema.
--   
--   <pre>
--   &gt;&gt;&gt; :{
--   let
--     definition :: Definition '["public" ::: '["muh_table" ::: 'Table t]] (Public '[])
--     definition = dropTable #muh_table
--   :}
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; printSQL definition
--   DROP TABLE "muh_table";
--   </pre>
dropTable :: (Has sch schemas schema, Has tab schema ( 'Table table)) => QualifiedAlias sch tab -> Definition schemas (Alter sch (Drop tab schema) schemas)

-- | Drop a view.
--   
--   <pre>
--   &gt;&gt;&gt; :{
--   let
--     definition :: Definition
--       '[ "public" ::: '["abc" ::: 'Table ('[] :=&gt; '["a" ::: 'NoDef :=&gt; 'Null 'PGint4, "b" ::: 'NoDef :=&gt; 'Null 'PGint4, "c" ::: 'NoDef :=&gt; 'Null 'PGint4])
--        , "bc"  ::: 'View ('["b" ::: 'Null 'PGint4, "c" ::: 'Null 'PGint4])]]
--       '[ "public" ::: '["abc" ::: 'Table ('[] :=&gt; '["a" ::: 'NoDef :=&gt; 'Null 'PGint4, "b" ::: 'NoDef :=&gt; 'Null 'PGint4, "c" ::: 'NoDef :=&gt; 'Null 'PGint4])]]
--     definition = dropView #bc
--   in printSQL definition
--   :}
--   DROP VIEW "bc";
--   </pre>
dropView :: (Has sch schemas schema, Has vw schema ( 'View view)) => QualifiedAlias sch vw -> Definition schemas (Alter sch (Drop vw schema) schemas)

-- | Drop a type.
--   
--   <pre>
--   &gt;&gt;&gt; data Schwarma = Beef | Lamb | Chicken deriving GHC.Generic
--   
--   &gt;&gt;&gt; instance SOP.Generic Schwarma
--   
--   &gt;&gt;&gt; instance SOP.HasDatatypeInfo Schwarma
--   
--   &gt;&gt;&gt; printSQL (dropType #schwarma :: Definition '["public" ::: '["schwarma" ::: 'Typedef (PG (Enumerated Schwarma))]] (Public '[]))
--   DROP TYPE "schwarma";
--   </pre>
dropType :: (Has sch schemas schema, Has td schema ( 'Typedef ty)) => QualifiedAlias sch td -> Definition schemas (Alter sch (Drop td schema) schemas)

-- | <a>alterTable</a> changes the definition of a table from the schema.
alterTable :: (Has sch schemas schema, Has tab schema ( 'Table table0)) => QualifiedAlias sch tab -> AlterTable sch tab schemas table1 -> Definition schemas (Alter sch (Alter tab ( 'Table table1) schema) schemas)

-- | <a>alterTableRename</a> changes the name of a table from the schema.
--   
--   <pre>
--   &gt;&gt;&gt; printSQL $ alterTableRename #foo #bar
--   ALTER TABLE "foo" RENAME TO "bar";
--   </pre>
alterTableRename :: (KnownSymbol table0, KnownSymbol table1) => Alias table0 -> Alias table1 -> Definition schema (Rename table0 table1 schema)

-- | An <a>AlterTable</a> describes the alteration to perform on the
--   columns of a table.
newtype AlterTable (sch :: Symbol) (tab :: Symbol) (schemas :: SchemasType) (table :: TableType)
UnsafeAlterTable :: ByteString -> AlterTable
[renderAlterTable] :: AlterTable -> ByteString

-- | An <a>addConstraint</a> adds a table constraint.
--   
--   <pre>
--   &gt;&gt;&gt; :{
--   let
--     definition :: Definition
--       '["public" ::: '["tab" ::: 'Table ('[] :=&gt; '["col" ::: 'NoDef :=&gt; 'NotNull 'PGint4])]]
--       '["public" ::: '["tab" ::: 'Table ('["positive" ::: 'Check '["col"]] :=&gt; '["col" ::: 'NoDef :=&gt; 'NotNull 'PGint4])]]
--     definition = alterTable #tab (addConstraint #positive (check #col (#col .&gt; 0)))
--   in printSQL definition
--   :}
--   ALTER TABLE "tab" ADD CONSTRAINT "positive" CHECK (("col" &gt; 0));
--   </pre>
addConstraint :: (KnownSymbol alias, Has sch schemas schema, Has tab schema ( 'Table table0), table0 ~ (constraints :=> columns), table1 ~ (Create alias constraint constraints :=> columns)) => Alias alias -> TableConstraintExpression sch tab schemas constraint -> AlterTable sch tab schemas table1

-- | A <a>dropConstraint</a> drops a table constraint.
--   
--   <pre>
--   &gt;&gt;&gt; :{
--   let
--     definition :: Definition
--       '["public" ::: '["tab" ::: 'Table ('["positive" ::: Check '["col"]] :=&gt; '["col" ::: 'NoDef :=&gt; 'NotNull 'PGint4])]]
--       '["public" ::: '["tab" ::: 'Table ('[] :=&gt; '["col" ::: 'NoDef :=&gt; 'NotNull 'PGint4])]]
--     definition = alterTable #tab (dropConstraint #positive)
--   in printSQL definition
--   :}
--   ALTER TABLE "tab" DROP CONSTRAINT "positive";
--   </pre>
dropConstraint :: (KnownSymbol constraint, Has sch schemas schema, Has tab schema ( 'Table table0), table0 ~ (constraints :=> columns), table1 ~ (Drop constraint constraints :=> columns)) => Alias constraint -> AlterTable sch tab schemas table1

-- | An <a>AddColumn</a> is either <tt>NULL</tt> or has <tt>DEFAULT</tt>.
class AddColumn ty

-- | <a>addColumn</a> adds a new column, initially filled with whatever
--   default value is given or with <tt>NULL</tt>.
--   
--   <pre>
--   &gt;&gt;&gt; :{
--   let
--     definition :: Definition
--       '["public" ::: '["tab" ::: 'Table ('[] :=&gt; '["col1" ::: 'NoDef :=&gt; 'Null 'PGint4])]]
--       '["public" ::: '["tab" ::: 'Table ('[] :=&gt;
--          '[ "col1" ::: 'NoDef :=&gt; 'Null 'PGint4
--           , "col2" ::: 'Def :=&gt; 'Null 'PGtext ])]]
--     definition = alterTable #tab (addColumn #col2 (text &amp; nullable &amp; default_ "foo"))
--   in printSQL definition
--   :}
--   ALTER TABLE "tab" ADD COLUMN "col2" text NULL DEFAULT E'foo';
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; :{
--   let
--     definition :: Definition
--       '["public" ::: '["tab" ::: 'Table ('[] :=&gt; '["col1" ::: 'NoDef :=&gt; 'Null 'PGint4])]]
--       '["public" ::: '["tab" ::: 'Table ('[] :=&gt;
--          '[ "col1" ::: 'NoDef :=&gt; 'Null 'PGint4
--           , "col2" ::: 'NoDef :=&gt; 'Null 'PGtext ])]]
--     definition = alterTable #tab (addColumn #col2 (text &amp; nullable))
--   in printSQL definition
--   :}
--   ALTER TABLE "tab" ADD COLUMN "col2" text NULL;
--   </pre>
addColumn :: (AddColumn ty, KnownSymbol column, Has sch schemas schema, Has tab schema ( 'Table table0), table0 ~ (constraints :=> columns)) => Alias column -> ColumnTypeExpression schemas ty -> AlterTable sch tab schemas (constraints :=> Create column ty columns)

-- | A <a>dropColumn</a> removes a column. Whatever data was in the column
--   disappears. Table constraints involving the column are dropped, too.
--   However, if the column is referenced by a foreign key constraint of
--   another table, PostgreSQL will not silently drop that constraint.
--   
--   <pre>
--   &gt;&gt;&gt; :{
--   let
--     definition :: Definition
--       '["public" ::: '["tab" ::: 'Table ('[] :=&gt;
--          '[ "col1" ::: 'NoDef :=&gt; 'Null 'PGint4
--           , "col2" ::: 'NoDef :=&gt; 'Null 'PGtext ])]]
--       '["public" ::: '["tab" ::: 'Table ('[] :=&gt; '["col1" ::: 'NoDef :=&gt; 'Null 'PGint4])]]
--     definition = alterTable #tab (dropColumn #col2)
--   in printSQL definition
--   :}
--   ALTER TABLE "tab" DROP COLUMN "col2";
--   </pre>
dropColumn :: (KnownSymbol column, Has sch schemas schema, Has tab schema ( 'Table table0), table0 ~ (constraints :=> columns), table1 ~ (constraints :=> Drop column columns)) => Alias column -> AlterTable sch tab schemas table1

-- | A <a>renameColumn</a> renames a column.
--   
--   <pre>
--   &gt;&gt;&gt; :{
--   let
--     definition :: Definition
--       '["public" ::: '["tab" ::: 'Table ('[] :=&gt; '["foo" ::: 'NoDef :=&gt; 'Null 'PGint4])]]
--       '["public" ::: '["tab" ::: 'Table ('[] :=&gt; '["bar" ::: 'NoDef :=&gt; 'Null 'PGint4])]]
--     definition = alterTable #tab (renameColumn #foo #bar)
--   in printSQL definition
--   :}
--   ALTER TABLE "tab" RENAME COLUMN "foo" TO "bar";
--   </pre>
renameColumn :: (KnownSymbol column0, KnownSymbol column1, Has sch schemas schema, Has tab schema ( 'Table table0), table0 ~ (constraints :=> columns), table1 ~ (constraints :=> Rename column0 column1 columns)) => Alias column0 -> Alias column1 -> AlterTable sch tab schemas table1

-- | An <a>alterColumn</a> alters a single column.
alterColumn :: (KnownSymbol column, Has sch schemas schema, Has tab schema ( 'Table table0), table0 ~ (constraints :=> columns), Has column columns ty0, table1 ~ (constraints :=> Alter column ty1 columns)) => Alias column -> AlterColumn schemas ty0 ty1 -> AlterTable sch tab schemas table1

-- | An <a>AlterColumn</a> describes the alteration to perform on a single
--   column.
newtype AlterColumn (schemas :: SchemasType) (ty0 :: ColumnType) (ty1 :: ColumnType)
UnsafeAlterColumn :: ByteString -> AlterColumn
[renderAlterColumn] :: AlterColumn -> ByteString

-- | A <a>setDefault</a> sets a new default for a column. Note that this
--   doesn't affect any existing rows in the table, it just changes the
--   default for future insert and update commands.
--   
--   <pre>
--   &gt;&gt;&gt; :{
--   let
--     definition :: Definition
--       '["public" ::: '["tab" ::: 'Table ('[] :=&gt; '["col" ::: 'NoDef :=&gt; 'Null 'PGint4])]]
--       '["public" ::: '["tab" ::: 'Table ('[] :=&gt; '["col" ::: 'Def :=&gt; 'Null 'PGint4])]]
--     definition = alterTable #tab (alterColumn #col (setDefault 5))
--   in printSQL definition
--   :}
--   ALTER TABLE "tab" ALTER COLUMN "col" SET DEFAULT 5;
--   </pre>
setDefault :: Expression '[] '[]  'Ungrouped schemas '[] '[] ty -> AlterColumn schemas (constraint :=> ty) ( 'Def :=> ty)

-- | A <a>dropDefault</a> removes any default value for a column.
--   
--   <pre>
--   &gt;&gt;&gt; :{
--   let
--     definition :: Definition
--       '["public" ::: '["tab" ::: 'Table ('[] :=&gt; '["col" ::: 'Def :=&gt; 'Null 'PGint4])]]
--       '["public" ::: '["tab" ::: 'Table ('[] :=&gt; '["col" ::: 'NoDef :=&gt; 'Null 'PGint4])]]
--     definition = alterTable #tab (alterColumn #col dropDefault)
--   in printSQL definition
--   :}
--   ALTER TABLE "tab" ALTER COLUMN "col" DROP DEFAULT;
--   </pre>
dropDefault :: AlterColumn schemas ( 'Def :=> ty) ( 'NoDef :=> ty)

-- | A <a>setNotNull</a> adds a <tt>NOT NULL</tt> constraint to a column.
--   The constraint will be checked immediately, so the table data must
--   satisfy the constraint before it can be added.
--   
--   <pre>
--   &gt;&gt;&gt; :{
--   let
--     definition :: Definition
--       '["public" ::: '["tab" ::: 'Table ('[] :=&gt; '["col" ::: 'NoDef :=&gt; 'Null 'PGint4])]]
--       '["public" ::: '["tab" ::: 'Table ('[] :=&gt; '["col" ::: 'NoDef :=&gt; 'NotNull 'PGint4])]]
--     definition = alterTable #tab (alterColumn #col setNotNull)
--   in printSQL definition
--   :}
--   ALTER TABLE "tab" ALTER COLUMN "col" SET NOT NULL;
--   </pre>
setNotNull :: AlterColumn schemas (constraint :=>  'Null ty) (constraint :=>  'NotNull ty)

-- | A <a>dropNotNull</a> drops a <tt>NOT NULL</tt> constraint from a
--   column.
--   
--   <pre>
--   &gt;&gt;&gt; :{
--   let
--     definition :: Definition
--       '["public" ::: '["tab" ::: 'Table ('[] :=&gt; '["col" ::: 'NoDef :=&gt; 'NotNull 'PGint4])]]
--       '["public" ::: '["tab" ::: 'Table ('[] :=&gt; '["col" ::: 'NoDef :=&gt; 'Null 'PGint4])]]
--     definition = alterTable #tab (alterColumn #col dropNotNull)
--   in printSQL definition
--   :}
--   ALTER TABLE "tab" ALTER COLUMN "col" DROP NOT NULL;
--   </pre>
dropNotNull :: AlterColumn schemas (constraint :=>  'NotNull ty) (constraint :=>  'Null ty)

-- | An <a>alterType</a> converts a column to a different data type. This
--   will succeed only if each existing entry in the column can be
--   converted to the new type by an implicit cast.
--   
--   <pre>
--   &gt;&gt;&gt; :{
--   let
--     definition :: Definition
--       '["public" ::: '["tab" ::: 'Table ('[] :=&gt; '["col" ::: 'NoDef :=&gt; 'NotNull 'PGint4])]]
--       '["public" ::: '["tab" ::: 'Table ('[] :=&gt; '["col" ::: 'NoDef :=&gt; 'NotNull 'PGnumeric])]]
--     definition =
--       alterTable #tab (alterColumn #col (alterType (numeric &amp; notNullable)))
--   in printSQL definition
--   :}
--   ALTER TABLE "tab" ALTER COLUMN "col" TYPE numeric NOT NULL;
--   </pre>
alterType :: ColumnTypeExpression schemas ty -> AlterColumn schemas ty0 ty

-- | <a>ColumnTypeExpression</a>s are used in <a>createTable</a> commands.
newtype ColumnTypeExpression (schemas :: SchemasType) (ty :: ColumnType)
UnsafeColumnTypeExpression :: ByteString -> ColumnTypeExpression
[renderColumnTypeExpression] :: ColumnTypeExpression -> ByteString

-- | used in <a>createTable</a> commands as a column constraint to note
--   that <tt>NULL</tt> may be present in a column
nullable :: TypeExpression schemas (nullity ty) -> ColumnTypeExpression schemas ( 'NoDef :=>  'Null ty)

-- | used in <a>createTable</a> commands as a column constraint to ensure
--   <tt>NULL</tt> is not present in a column
notNullable :: TypeExpression schemas (nullity ty) -> ColumnTypeExpression schemas ( 'NoDef :=>  'NotNull ty)

-- | used in <a>createTable</a> commands as a column constraint to give a
--   default
default_ :: Expression '[] '[]  'Ungrouped schemas '[] '[] ty -> ColumnTypeExpression schemas ( 'NoDef :=> ty) -> ColumnTypeExpression schemas ( 'Def :=> ty)

-- | not a true type, but merely a notational convenience for creating
--   unique identifier columns with type <a>PGint2</a>
serial2 :: ColumnTypeExpression schemas ( 'Def :=>  'NotNull  'PGint2)

-- | not a true type, but merely a notational convenience for creating
--   unique identifier columns with type <a>PGint2</a>
smallserial :: ColumnTypeExpression schemas ( 'Def :=>  'NotNull  'PGint2)

-- | not a true type, but merely a notational convenience for creating
--   unique identifier columns with type <a>PGint4</a>
serial4 :: ColumnTypeExpression schemas ( 'Def :=>  'NotNull  'PGint4)

-- | not a true type, but merely a notational convenience for creating
--   unique identifier columns with type <a>PGint4</a>
serial :: ColumnTypeExpression schemas ( 'Def :=>  'NotNull  'PGint4)

-- | not a true type, but merely a notational convenience for creating
--   unique identifier columns with type <a>PGint8</a>
serial8 :: ColumnTypeExpression schemas ( 'Def :=>  'NotNull  'PGint8)

-- | not a true type, but merely a notational convenience for creating
--   unique identifier columns with type <a>PGint8</a>
bigserial :: ColumnTypeExpression schemas ( 'Def :=>  'NotNull  'PGint8)
instance Control.DeepSeq.NFData (Squeal.PostgreSQL.Definition.ColumnTypeExpression schemas ty)
instance GHC.Classes.Ord (Squeal.PostgreSQL.Definition.ColumnTypeExpression schemas ty)
instance GHC.Classes.Eq (Squeal.PostgreSQL.Definition.ColumnTypeExpression schemas ty)
instance GHC.Show.Show (Squeal.PostgreSQL.Definition.ColumnTypeExpression schemas ty)
instance GHC.Generics.Generic (Squeal.PostgreSQL.Definition.ColumnTypeExpression schemas ty)
instance Control.DeepSeq.NFData (Squeal.PostgreSQL.Definition.AlterColumn schemas ty0 ty1)
instance GHC.Classes.Ord (Squeal.PostgreSQL.Definition.AlterColumn schemas ty0 ty1)
instance GHC.Classes.Eq (Squeal.PostgreSQL.Definition.AlterColumn schemas ty0 ty1)
instance GHC.Show.Show (Squeal.PostgreSQL.Definition.AlterColumn schemas ty0 ty1)
instance GHC.Generics.Generic (Squeal.PostgreSQL.Definition.AlterColumn schemas ty0 ty1)
instance Control.DeepSeq.NFData (Squeal.PostgreSQL.Definition.AlterTable sch tab schemas table)
instance GHC.Classes.Ord (Squeal.PostgreSQL.Definition.AlterTable sch tab schemas table)
instance GHC.Classes.Eq (Squeal.PostgreSQL.Definition.AlterTable sch tab schemas table)
instance GHC.Show.Show (Squeal.PostgreSQL.Definition.AlterTable sch tab schemas table)
instance GHC.Generics.Generic (Squeal.PostgreSQL.Definition.AlterTable sch tab schemas table)
instance GHC.Classes.Ord Squeal.PostgreSQL.Definition.OnUpdateClause
instance GHC.Classes.Eq Squeal.PostgreSQL.Definition.OnUpdateClause
instance GHC.Show.Show Squeal.PostgreSQL.Definition.OnUpdateClause
instance GHC.Generics.Generic Squeal.PostgreSQL.Definition.OnUpdateClause
instance GHC.Classes.Ord Squeal.PostgreSQL.Definition.OnDeleteClause
instance GHC.Classes.Eq Squeal.PostgreSQL.Definition.OnDeleteClause
instance GHC.Show.Show Squeal.PostgreSQL.Definition.OnDeleteClause
instance GHC.Generics.Generic Squeal.PostgreSQL.Definition.OnDeleteClause
instance Control.DeepSeq.NFData (Squeal.PostgreSQL.Definition.TableConstraintExpression sch tab schemas constraint)
instance GHC.Classes.Ord (Squeal.PostgreSQL.Definition.TableConstraintExpression sch tab schemas constraint)
instance GHC.Classes.Eq (Squeal.PostgreSQL.Definition.TableConstraintExpression sch tab schemas constraint)
instance GHC.Show.Show (Squeal.PostgreSQL.Definition.TableConstraintExpression sch tab schemas constraint)
instance GHC.Generics.Generic (Squeal.PostgreSQL.Definition.TableConstraintExpression sch tab schemas constraint)
instance Control.DeepSeq.NFData (Squeal.PostgreSQL.Definition.Definition schemas0 schemas1)
instance GHC.Classes.Ord (Squeal.PostgreSQL.Definition.Definition schemas0 schemas1)
instance GHC.Classes.Eq (Squeal.PostgreSQL.Definition.Definition schemas0 schemas1)
instance GHC.Show.Show (Squeal.PostgreSQL.Definition.Definition schemas0 schemas1)
instance GHC.Generics.Generic (Squeal.PostgreSQL.Definition.Definition schemas0 schemas1)
instance Squeal.PostgreSQL.Definition.AddColumn ('Squeal.PostgreSQL.Schema.Def Squeal.PostgreSQL.Schema.:=> ty)
instance Squeal.PostgreSQL.Definition.AddColumn ('Squeal.PostgreSQL.Schema.NoDef Squeal.PostgreSQL.Schema.:=> 'Squeal.PostgreSQL.Schema.Null ty)
instance Squeal.PostgreSQL.Render.RenderSQL (Squeal.PostgreSQL.Definition.ColumnTypeExpression schemas ty)
instance (GHC.TypeLits.KnownSymbol alias, Squeal.PostgreSQL.Expression.Type.PGTyped schemas ty) => Squeal.PostgreSQL.Definition.FieldTyped schemas (alias Squeal.PostgreSQL.Alias.::: ty)
instance Control.DeepSeq.NFData Squeal.PostgreSQL.Definition.OnUpdateClause
instance Squeal.PostgreSQL.Render.RenderSQL Squeal.PostgreSQL.Definition.OnUpdateClause
instance Control.DeepSeq.NFData Squeal.PostgreSQL.Definition.OnDeleteClause
instance Squeal.PostgreSQL.Render.RenderSQL Squeal.PostgreSQL.Definition.OnDeleteClause
instance Squeal.PostgreSQL.Render.RenderSQL (Squeal.PostgreSQL.Definition.TableConstraintExpression sch tab schemas constraint)
instance Squeal.PostgreSQL.Render.RenderSQL (Squeal.PostgreSQL.Definition.Definition schemas0 schemas1)
instance Control.Category.Category Squeal.PostgreSQL.Definition.Definition


-- | This module provides binary encoding and decoding between Haskell and
--   PostgreSQL types.
--   
--   Instances are governed by the <a>Generic</a> and
--   <a>HasDatatypeInfo</a> typeclasses, so you absolutely 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
--   
--   <pre>
--   &gt;&gt;&gt; import Data.Int (Int16)
--   
--   &gt;&gt;&gt; import Data.Text (Text)
--   
--   &gt;&gt;&gt; import Control.Monad (void)
--   
--   &gt;&gt;&gt; import Control.Monad.IO.Class (liftIO)
--   
--   &gt;&gt;&gt; import Squeal.PostgreSQL
--   </pre>
--   
--   Define a Haskell datatype <tt>Row</tt> that will serve as both the
--   input and output of a simple round trip query.
--   
--   <pre>
--   &gt;&gt;&gt; data Row = Row { col1 :: Int16, col2 :: Text, col3 :: Maybe Bool } deriving (Eq, GHC.Generic)
--   
--   &gt;&gt;&gt; instance Generic Row
--   
--   &gt;&gt;&gt; instance HasDatatypeInfo Row
--   
--   &gt;&gt;&gt; :{
--   let
--     roundTrip :: Query_ (Public '[]) Row Row
--     roundTrip = values_ $
--       parameter @1 int2 `as` #col1 :*
--       parameter @2 text `as` #col2 :*
--       parameter @3 bool `as` #col3
--   :}
--   </pre>
--   
--   So long as we can encode the parameters and then decode the result of
--   the query, the input and output should be equal.
--   
--   <pre>
--   &gt;&gt;&gt; let input = Row 2 "hi" (Just True)
--   
--   &gt;&gt;&gt; :{
--   withConnection "host=localhost port=5432 dbname=exampledb" $ do
--     result &lt;- runQueryParams roundTrip input
--     Just output &lt;- firstRow result
--     liftIO . print $ input == output
--   :}
--   True
--   </pre>
--   
--   In addition to being able to encode and decode basic Haskell types
--   like <a>Int16</a> and <a>Text</a>, 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 <a>Vector</a>
--   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.
--   
--   <pre>
--   &gt;&gt;&gt; :{
--   data Row = Row
--     { col1 :: VarArray (Vector Int16)
--     , col2 :: FixArray (Maybe Int16,Maybe Int16)
--     , col3 :: FixArray ((Int16,Int16),(Int16,Int16),(Int16,Int16))
--     } deriving (Eq, GHC.Generic)
--   :}
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; instance Generic Row
--   
--   &gt;&gt;&gt; instance HasDatatypeInfo Row
--   </pre>
--   
--   Once again, we define a simple round trip query.
--   
--   <pre>
--   &gt;&gt;&gt; :{
--   let
--     roundTrip :: Query_ (Public '[]) Row Row
--     roundTrip = values_ $
--       parameter @1 (int2 &amp; vararray) `as` #col1 :*
--       parameter @2 (int2 &amp; fixarray @'[2]) `as` #col2 :*
--       parameter @3 (int2 &amp; fixarray @'[3,2]) `as` #col3
--   :}
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; :set -XOverloadedLists
--   
--   &gt;&gt;&gt; let input = Row (VarArray [1,2]) (FixArray (Just 1,Nothing)) (FixArray ((1,2),(3,4),(5,6)))
--   
--   &gt;&gt;&gt; :{
--   withConnection "host=localhost port=5432 dbname=exampledb" $ do
--     result &lt;- runQueryParams roundTrip input
--     Just output &lt;- firstRow result
--     liftIO . print $ input == output
--   :}
--   True
--   </pre>
--   
--   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.
--   
--   <pre>
--   &gt;&gt;&gt; data Schwarma = Beef | Lamb | Chicken deriving (Eq, Show, GHC.Generic)
--   
--   &gt;&gt;&gt; instance Generic Schwarma
--   
--   &gt;&gt;&gt; instance HasDatatypeInfo Schwarma
--   </pre>
--   
--   A composite type represents the structure of a row or record; it is
--   essentially just a list of field names and their data types.
--   
--   <pre>
--   &gt;&gt;&gt; data Person = Person {name :: Text, age :: Int32} deriving (Eq, Show, GHC.Generic)
--   
--   &gt;&gt;&gt; instance Generic Person
--   
--   &gt;&gt;&gt; instance HasDatatypeInfo Person
--   
--   &gt;&gt;&gt; instance Aeson.FromJSON Person
--   
--   &gt;&gt;&gt; instance Aeson.ToJSON Person
--   </pre>
--   
--   We can create the equivalent Postgres types directly from their
--   Haskell types.
--   
--   <pre>
--   &gt;&gt;&gt; :{
--   type Schema =
--     '[ "schwarma" ::: 'Typedef (PG (Enumerated Schwarma))
--      , "person" ::: 'Typedef (PG (Composite Person))
--      ]
--   :}
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; :{
--   let
--     setup :: Definition (Public '[]) (Public Schema)
--     setup =
--       createTypeEnumFrom @Schwarma #schwarma &gt;&gt;&gt;
--       createTypeCompositeFrom @Person #person
--   :}
--   </pre>
--   
--   Let's demonstrate how to associate our Haskell types <tt>Schwarma</tt>
--   and <tt>Person</tt> with enumerated, composite or json types in
--   Postgres. First create a Haskell <tt>Row</tt> type using the
--   <a>Enumerated</a>, <a>Composite</a> and <a>Json</a> newtypes as
--   fields.
--   
--   <pre>
--   &gt;&gt;&gt; :{
--   data Row = Row
--     { schwarma :: Enumerated Schwarma
--     , person1 :: Composite Person
--     , person2 :: Json Person
--     } deriving (Eq, GHC.Generic)
--   :}
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; instance Generic Row
--   
--   &gt;&gt;&gt; instance HasDatatypeInfo Row
--   
--   &gt;&gt;&gt; :{
--   let
--     input = Row
--       (Enumerated Chicken)
--       (Composite (Person "Faisal" 24))
--       (Json (Person "Ahmad" 48))
--   :}
--   </pre>
--   
--   Once again, define a round trip query.
--   
--   <pre>
--   &gt;&gt;&gt; :{
--   let
--     roundTrip :: Query_ (Public Schema) Row Row
--     roundTrip = values_ $
--       parameter @1 (typedef #schwarma) `as` #schwarma :*
--       parameter @2 (typedef #person)   `as` #person1  :*
--       parameter @3 json                `as` #person2
--   :}
--   </pre>
--   
--   Finally, we can drop our type definitions.
--   
--   <pre>
--   &gt;&gt;&gt; :{
--   let
--     teardown :: Definition (Public Schema) (Public '[])
--     teardown = dropType #schwarma &gt;&gt;&gt; dropType #person
--   :}
--   </pre>
--   
--   Now let's run it.
--   
--   <pre>
--   &gt;&gt;&gt; :{
--   let
--     session = do
--       result &lt;- runQueryParams roundTrip input
--       Just output &lt;- firstRow result
--       liftIO . print $ input == output
--   in
--     withConnection "host=localhost port=5432 dbname=exampledb" $
--       define setup
--       &amp; pqThen session
--       &amp; pqThen (define teardown)
--   :}
--   True
--   </pre>
module Squeal.PostgreSQL.Binary

-- | A <a>ToParam</a> constraint gives an encoding of a Haskell <a>Type</a>
--   into into the binary format of a PostgreSQL <a>PGType</a>.
class ToParam (x :: Type) (pg :: PGType)

-- | <pre>
--   &gt;&gt;&gt; :set -XTypeApplications -XDataKinds
--   
--   &gt;&gt;&gt; toParam @Bool @'PGbool False
--   K "\NUL"
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; toParam @Int16 @'PGint2 0
--   K "\NUL\NUL"
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; toParam @Int32 @'PGint4 0
--   K "\NUL\NUL\NUL\NUL"
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; :set -XMultiParamTypeClasses
--   
--   &gt;&gt;&gt; newtype Id = Id { getId :: Int16 } deriving Show
--   
--   &gt;&gt;&gt; instance ToParam Id 'PGint2 where toParam = toParam . getId
--   
--   &gt;&gt;&gt; toParam @Id @'PGint2 (Id 1)
--   K "\NUL\SOH"
--   </pre>
toParam :: ToParam x pg => x -> K Encoding pg

-- | A <a>ToParams</a> constraint generically sequences the encodings of
--   <a>Type</a>s of the fields of a tuple or record to a row of
--   <a>ColumnType</a>s. You should not define instances of
--   <a>ToParams</a>. Instead define <a>Generic</a> instances which in turn
--   provide <a>ToParams</a> instances.
class SListI tys => ToParams (x :: Type) (tys :: [NullityType])

-- | <pre>
--   &gt;&gt;&gt; type Params = '[ 'NotNull 'PGbool, 'Null 'PGint2]
--   
--   &gt;&gt;&gt; toParams @(Bool, Maybe Int16) @'[ 'NotNull 'PGbool, 'Null 'PGint2] (False, Just 0)
--   K (Just "\NUL") :* K (Just "\NUL\NUL") :* Nil
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; :set -XDeriveGeneric
--   
--   &gt;&gt;&gt; data Tuple = Tuple { p1 :: Bool, p2 :: Maybe Int16} deriving GHC.Generic
--   
--   &gt;&gt;&gt; instance Generic Tuple
--   
--   &gt;&gt;&gt; toParams @Tuple @Params (Tuple False (Just 0))
--   K (Just "\NUL") :* K (Just "\NUL\NUL") :* Nil
--   </pre>
toParams :: ToParams x tys => x -> NP (K (Maybe Encoding)) tys

-- | A <a>ToNullityParam</a> constraint gives an encoding of a Haskell
--   <a>Type</a> into into the binary format of a PostgreSQL
--   <a>NullityType</a>.
class ToNullityParam (x :: Type) (ty :: NullityType)
toNullityParam :: ToNullityParam x ty => x -> K (Maybe Encoding) ty

-- | A <a>ToField</a> constraint lifts the <a>ToParam</a> parser to an
--   encoding of a <tt>(Symbol, Type)</tt> to a <tt>(Symbol,
--   NullityType)</tt>, encoding <a>Null</a>s to <a>Maybe</a>s. You should
--   not define instances for <a>FromField</a>, just use the provided
--   instances.
class ToField (x :: (Symbol, Type)) (field :: (Symbol, NullityType))
toField :: ToField x field => P x -> K (Maybe Encoding) field

-- | A <a>ToFixArray</a> constraint gives an encoding of a Haskell
--   <a>Type</a> into the binary format of a PostgreSQL fixed-length array.
--   You should not define instances for <a>ToFixArray</a>, just use the
--   provided instances.
class ToFixArray (x :: Type) (dims :: [Nat]) (array :: NullityType)
toFixArray :: ToFixArray x dims array => x -> K (K Array dims) array

-- | A <a>FromValue</a> constraint gives a parser from the binary format of
--   a PostgreSQL <a>PGType</a> into a Haskell <a>Type</a>.
class FromValue (pg :: PGType) (y :: Type)

-- | <pre>
--   &gt;&gt;&gt; newtype Id = Id { getId :: Int16 } deriving Show
--   
--   &gt;&gt;&gt; instance FromValue 'PGint2 Id where fromValue = Id &lt;$&gt; fromValue @'PGint2
--   </pre>
fromValue :: FromValue pg y => Value y

-- | A <a>FromRow</a> constraint generically sequences the parsings of the
--   columns of a <a>RowType</a> into the fields of a record <a>Type</a>
--   provided they have the same field names. You should not define
--   instances of <a>FromRow</a>. Instead define <a>Generic</a> and
--   <a>HasDatatypeInfo</a> instances which in turn provide <a>FromRow</a>
--   instances.
class SListI result => FromRow (result :: RowType) y

-- | <pre>
--   &gt;&gt;&gt; :set -XOverloadedStrings
--   
--   &gt;&gt;&gt; import Data.Text
--   
--   &gt;&gt;&gt; newtype UserId = UserId { getUserId :: Int16 } deriving Show
--   
--   &gt;&gt;&gt; instance FromValue 'PGint2 UserId where fromValue = UserId &lt;$&gt; fromValue @'PGint2
--   
--   &gt;&gt;&gt; data UserRow = UserRow { userId :: UserId, userName :: Maybe Text } deriving (Show, GHC.Generic)
--   
--   &gt;&gt;&gt; instance Generic UserRow
--   
--   &gt;&gt;&gt; instance HasDatatypeInfo UserRow
--   
--   &gt;&gt;&gt; type User = '["userId" ::: 'NotNull 'PGint2, "userName" ::: 'Null 'PGtext]
--   
--   &gt;&gt;&gt; fromRow @User @UserRow (K (Just "\NUL\SOH") :* K (Just "bloodninja") :* Nil)
--   Right (UserRow {userId = UserId {getUserId = 1}, userName = Just "bloodninja"})
--   </pre>
fromRow :: FromRow result y => NP (K (Maybe ByteString)) result -> Either Text y

-- | A <a>FromField</a> constraint lifts the <a>FromValue</a> parser to a
--   decoding of a <tt>(Symbol, NullityType)</tt> to a <a>Type</a>,
--   decoding <a>Null</a>s to <a>Maybe</a>s. You should not define
--   instances for <a>FromField</a>, just use the provided instances.
class FromField (pg :: (Symbol, NullityType)) (y :: (Symbol, Type))
fromField :: FromField pg y => K (Maybe ByteString) pg -> (Either Text :.: P) y

-- | A <a>FromFixArray</a> constraint gives a decoding to a Haskell
--   <a>Type</a> from the binary format of a PostgreSQL fixed-length array.
--   You should not define instances for <a>FromFixArray</a>, just use the
--   provided instances.
class FromFixArray (dims :: [Nat]) (ty :: NullityType) (y :: Type)
fromFixArray :: FromFixArray dims ty y => Array y

-- | <a>Only</a> is a 1-tuple type, useful for encoding a single parameter
--   with <a>toParams</a> or decoding a single value with <a>fromRow</a>.
--   
--   <pre>
--   &gt;&gt;&gt; import Data.Text
--   
--   &gt;&gt;&gt; toParams @(Only (Maybe Text)) @'[ 'Null 'PGtext] (Only (Just "foo"))
--   K (Just "foo") :* Nil
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; fromRow @'["fromOnly" ::: 'Null 'PGtext] @(Only (Maybe Text)) (K (Just "bar") :* Nil)
--   Right (Only {fromOnly = Just "bar"})
--   </pre>
newtype Only x
Only :: x -> Only x
[fromOnly] :: Only x -> x

-- | The object identifier of a <a>PGType</a>.
--   
--   <pre>
--   &gt;&gt;&gt; :set -XTypeApplications
--   
--   &gt;&gt;&gt; oid @'PGbool
--   16
--   </pre>
class HasOid (ty :: PGType)
oid :: HasOid ty => Word32

-- | Lifts a <a>HasOid</a> constraint to a field.
class HasAliasedOid (field :: (Symbol, NullityType))
aliasedOid :: HasAliasedOid field => Word32
instance GHC.Generics.Generic (Squeal.PostgreSQL.Binary.Only x)
instance GHC.Show.Show x => GHC.Show.Show (Squeal.PostgreSQL.Binary.Only x)
instance GHC.Read.Read x => GHC.Read.Read (Squeal.PostgreSQL.Binary.Only x)
instance GHC.Classes.Ord x => GHC.Classes.Ord (Squeal.PostgreSQL.Binary.Only x)
instance GHC.Classes.Eq x => GHC.Classes.Eq (Squeal.PostgreSQL.Binary.Only x)
instance Data.Traversable.Traversable Squeal.PostgreSQL.Binary.Only
instance Data.Foldable.Foldable Squeal.PostgreSQL.Binary.Only
instance GHC.Base.Functor Squeal.PostgreSQL.Binary.Only
instance Generics.SOP.Universe.Generic (Squeal.PostgreSQL.Binary.Only x)
instance Generics.SOP.Universe.HasDatatypeInfo (Squeal.PostgreSQL.Binary.Only x)
instance Squeal.PostgreSQL.Binary.FromRow fields y => Squeal.PostgreSQL.Binary.FromValue ('Squeal.PostgreSQL.Schema.PGcomposite fields) (Squeal.PostgreSQL.PG.Composite y)
instance (Data.SOP.Constraint.SListI result, Generics.SOP.Record.IsRecord y ys, Data.SOP.Constraint.AllZip Squeal.PostgreSQL.Binary.FromField result ys) => Squeal.PostgreSQL.Binary.FromRow result y
instance Squeal.PostgreSQL.Binary.FromValue pg y => Squeal.PostgreSQL.Binary.FromValue ('Squeal.PostgreSQL.Schema.PGvararray ('Squeal.PostgreSQL.Schema.NotNull pg)) (Squeal.PostgreSQL.PG.VarArray (Data.Vector.Vector y))
instance Squeal.PostgreSQL.Binary.FromValue pg y => Squeal.PostgreSQL.Binary.FromValue ('Squeal.PostgreSQL.Schema.PGvararray ('Squeal.PostgreSQL.Schema.Null pg)) (Squeal.PostgreSQL.PG.VarArray (Data.Vector.Vector (GHC.Maybe.Maybe y)))
instance Squeal.PostgreSQL.Binary.FromValue pg y => Squeal.PostgreSQL.Binary.FromValue ('Squeal.PostgreSQL.Schema.PGvararray ('Squeal.PostgreSQL.Schema.NotNull pg)) (Squeal.PostgreSQL.PG.VarArray [y])
instance Squeal.PostgreSQL.Binary.FromValue pg y => Squeal.PostgreSQL.Binary.FromValue ('Squeal.PostgreSQL.Schema.PGvararray ('Squeal.PostgreSQL.Schema.Null pg)) (Squeal.PostgreSQL.PG.VarArray [GHC.Maybe.Maybe y])
instance Squeal.PostgreSQL.Binary.FromFixArray dims ty y => Squeal.PostgreSQL.Binary.FromValue ('Squeal.PostgreSQL.Schema.PGfixarray dims ty) (Squeal.PostgreSQL.PG.FixArray y)
instance Squeal.PostgreSQL.Binary.FromValue pg y => Squeal.PostgreSQL.Binary.FromFixArray '[] ('Squeal.PostgreSQL.Schema.NotNull pg) y
instance Squeal.PostgreSQL.Binary.FromValue pg y => Squeal.PostgreSQL.Binary.FromFixArray '[] ('Squeal.PostgreSQL.Schema.Null pg) (GHC.Maybe.Maybe y)
instance (Generics.SOP.Universe.IsProductType product ys, Squeal.PostgreSQL.List.Length ys Data.Type.Equality.~ dim, Data.SOP.Constraint.All ((Data.Type.Equality.~) y) ys, Squeal.PostgreSQL.Binary.FromFixArray dims ty y) => Squeal.PostgreSQL.Binary.FromFixArray (dim : dims) ty product
instance Squeal.PostgreSQL.Binary.FromValue pg y => Squeal.PostgreSQL.Binary.FromField (column Squeal.PostgreSQL.Alias.::: 'Squeal.PostgreSQL.Schema.NotNull pg) (column Squeal.PostgreSQL.Alias.::: y)
instance Squeal.PostgreSQL.Binary.FromValue pg y => Squeal.PostgreSQL.Binary.FromField (column Squeal.PostgreSQL.Alias.::: 'Squeal.PostgreSQL.Schema.Null pg) (column Squeal.PostgreSQL.Alias.::: GHC.Maybe.Maybe y)
instance Squeal.PostgreSQL.Binary.FromValue 'Squeal.PostgreSQL.Schema.PGbool GHC.Types.Bool
instance Squeal.PostgreSQL.Binary.FromValue 'Squeal.PostgreSQL.Schema.PGint2 GHC.Int.Int16
instance Squeal.PostgreSQL.Binary.FromValue 'Squeal.PostgreSQL.Schema.PGint4 GHC.Int.Int32
instance Squeal.PostgreSQL.Binary.FromValue 'Squeal.PostgreSQL.Schema.PGint8 GHC.Int.Int64
instance Squeal.PostgreSQL.Binary.FromValue 'Squeal.PostgreSQL.Schema.PGfloat4 GHC.Types.Float
instance Squeal.PostgreSQL.Binary.FromValue 'Squeal.PostgreSQL.Schema.PGfloat8 GHC.Types.Double
instance Squeal.PostgreSQL.Binary.FromValue 'Squeal.PostgreSQL.Schema.PGnumeric Data.Scientific.Scientific
instance Squeal.PostgreSQL.Binary.FromValue 'Squeal.PostgreSQL.Schema.PGmoney Squeal.PostgreSQL.PG.Money
instance Squeal.PostgreSQL.Binary.FromValue 'Squeal.PostgreSQL.Schema.PGuuid Data.UUID.Types.Internal.UUID
instance Squeal.PostgreSQL.Binary.FromValue 'Squeal.PostgreSQL.Schema.PGinet (Network.IP.Addr.NetAddr Network.IP.Addr.IP)
instance Squeal.PostgreSQL.Binary.FromValue ('Squeal.PostgreSQL.Schema.PGchar 1) GHC.Types.Char
instance Squeal.PostgreSQL.Binary.FromValue 'Squeal.PostgreSQL.Schema.PGtext Data.Text.Internal.Text
instance Squeal.PostgreSQL.Binary.FromValue 'Squeal.PostgreSQL.Schema.PGtext Data.Text.Internal.Lazy.Text
instance Squeal.PostgreSQL.Binary.FromValue 'Squeal.PostgreSQL.Schema.PGtext GHC.Base.String
instance Squeal.PostgreSQL.Binary.FromValue 'Squeal.PostgreSQL.Schema.PGbytea Data.ByteString.Internal.ByteString
instance Squeal.PostgreSQL.Binary.FromValue 'Squeal.PostgreSQL.Schema.PGbytea Data.ByteString.Lazy.Internal.ByteString
instance Squeal.PostgreSQL.Binary.FromValue 'Squeal.PostgreSQL.Schema.PGdate Data.Time.Calendar.Days.Day
instance Squeal.PostgreSQL.Binary.FromValue 'Squeal.PostgreSQL.Schema.PGtime Data.Time.LocalTime.Internal.TimeOfDay.TimeOfDay
instance Squeal.PostgreSQL.Binary.FromValue 'Squeal.PostgreSQL.Schema.PGtimetz (Data.Time.LocalTime.Internal.TimeOfDay.TimeOfDay, Data.Time.LocalTime.Internal.TimeZone.TimeZone)
instance Squeal.PostgreSQL.Binary.FromValue 'Squeal.PostgreSQL.Schema.PGtimestamp Data.Time.LocalTime.Internal.LocalTime.LocalTime
instance Squeal.PostgreSQL.Binary.FromValue 'Squeal.PostgreSQL.Schema.PGtimestamptz Data.Time.Clock.Internal.UTCTime.UTCTime
instance Squeal.PostgreSQL.Binary.FromValue 'Squeal.PostgreSQL.Schema.PGinterval Data.Time.Clock.Internal.DiffTime.DiffTime
instance Squeal.PostgreSQL.Binary.FromValue 'Squeal.PostgreSQL.Schema.PGjson Data.Aeson.Types.Internal.Value
instance Squeal.PostgreSQL.Binary.FromValue 'Squeal.PostgreSQL.Schema.PGjsonb Data.Aeson.Types.Internal.Value
instance Data.Aeson.Types.FromJSON.FromJSON x => Squeal.PostgreSQL.Binary.FromValue 'Squeal.PostgreSQL.Schema.PGjson (Squeal.PostgreSQL.PG.Json x)
instance Data.Aeson.Types.FromJSON.FromJSON x => Squeal.PostgreSQL.Binary.FromValue 'Squeal.PostgreSQL.Schema.PGjsonb (Squeal.PostgreSQL.PG.Jsonb x)
instance (Generics.SOP.Universe.IsEnumType y, Generics.SOP.Universe.HasDatatypeInfo y, Squeal.PostgreSQL.PG.LabelsPG y Data.Type.Equality.~ labels) => Squeal.PostgreSQL.Binary.FromValue ('Squeal.PostgreSQL.Schema.PGenum labels) (Squeal.PostgreSQL.PG.Enumerated y)
instance (Data.SOP.Constraint.SListI tys, Generics.SOP.Universe.IsProductType x xs, Data.SOP.Constraint.AllZip Squeal.PostgreSQL.Binary.ToNullityParam xs tys) => Squeal.PostgreSQL.Binary.ToParams x tys
instance (Squeal.PostgreSQL.Binary.ToFixArray x dims ty, ty Data.Type.Equality.~ nullity pg, Squeal.PostgreSQL.Binary.HasOid pg) => Squeal.PostgreSQL.Binary.ToParam (Squeal.PostgreSQL.PG.FixArray x) ('Squeal.PostgreSQL.Schema.PGfixarray dims ty)
instance Squeal.PostgreSQL.Binary.ToNullityParam x ty => Squeal.PostgreSQL.Binary.ToFixArray x '[] ty
instance (Generics.SOP.Universe.IsProductType product xs, Squeal.PostgreSQL.List.Length xs Data.Type.Equality.~ dim, Data.SOP.Constraint.All ((Data.Type.Equality.~) x) xs, Squeal.PostgreSQL.Binary.ToFixArray x dims ty) => Squeal.PostgreSQL.Binary.ToFixArray product (dim : dims) ty
instance (Data.SOP.Constraint.SListI fields, Generics.SOP.Record.IsRecord x xs, Data.SOP.Constraint.AllZip Squeal.PostgreSQL.Binary.ToField xs fields, Data.SOP.Constraint.All Squeal.PostgreSQL.Binary.HasAliasedOid fields) => Squeal.PostgreSQL.Binary.ToParam (Squeal.PostgreSQL.PG.Composite x) ('Squeal.PostgreSQL.Schema.PGcomposite fields)
instance Squeal.PostgreSQL.Binary.ToNullityParam x ty => Squeal.PostgreSQL.Binary.ToField (alias Squeal.PostgreSQL.Alias.::: x) (alias Squeal.PostgreSQL.Alias.::: ty)
instance (Squeal.PostgreSQL.Binary.ToNullityParam x ty, ty Data.Type.Equality.~ nullity pg, Squeal.PostgreSQL.Binary.HasOid pg) => Squeal.PostgreSQL.Binary.ToParam (Squeal.PostgreSQL.PG.VarArray [x]) ('Squeal.PostgreSQL.Schema.PGvararray ty)
instance Squeal.PostgreSQL.Binary.ToParam x pg => Squeal.PostgreSQL.Binary.ToNullityParam x ('Squeal.PostgreSQL.Schema.NotNull pg)
instance Squeal.PostgreSQL.Binary.ToParam x pg => Squeal.PostgreSQL.Binary.ToNullityParam (GHC.Maybe.Maybe x) ('Squeal.PostgreSQL.Schema.Null pg)
instance Squeal.PostgreSQL.Binary.HasOid ty => Squeal.PostgreSQL.Binary.HasAliasedOid (alias Squeal.PostgreSQL.Alias.::: nullity ty)
instance (Squeal.PostgreSQL.Binary.ToParam x pg, Squeal.PostgreSQL.Binary.HasOid pg) => Squeal.PostgreSQL.Binary.ToParam (Squeal.PostgreSQL.PG.VarArray (Data.Vector.Vector x)) ('Squeal.PostgreSQL.Schema.PGvararray ('Squeal.PostgreSQL.Schema.NotNull pg))
instance (Squeal.PostgreSQL.Binary.ToParam x pg, Squeal.PostgreSQL.Binary.HasOid pg) => Squeal.PostgreSQL.Binary.ToParam (Squeal.PostgreSQL.PG.VarArray (Data.Vector.Vector (GHC.Maybe.Maybe x))) ('Squeal.PostgreSQL.Schema.PGvararray ('Squeal.PostgreSQL.Schema.Null pg))
instance Squeal.PostgreSQL.Binary.HasOid 'Squeal.PostgreSQL.Schema.PGbool
instance Squeal.PostgreSQL.Binary.HasOid 'Squeal.PostgreSQL.Schema.PGint2
instance Squeal.PostgreSQL.Binary.HasOid 'Squeal.PostgreSQL.Schema.PGint4
instance Squeal.PostgreSQL.Binary.HasOid 'Squeal.PostgreSQL.Schema.PGint8
instance Squeal.PostgreSQL.Binary.HasOid 'Squeal.PostgreSQL.Schema.PGnumeric
instance Squeal.PostgreSQL.Binary.HasOid 'Squeal.PostgreSQL.Schema.PGfloat4
instance Squeal.PostgreSQL.Binary.HasOid 'Squeal.PostgreSQL.Schema.PGfloat8
instance Squeal.PostgreSQL.Binary.HasOid ('Squeal.PostgreSQL.Schema.PGchar n)
instance Squeal.PostgreSQL.Binary.HasOid ('Squeal.PostgreSQL.Schema.PGvarchar n)
instance Squeal.PostgreSQL.Binary.HasOid 'Squeal.PostgreSQL.Schema.PGtext
instance Squeal.PostgreSQL.Binary.HasOid 'Squeal.PostgreSQL.Schema.PGbytea
instance Squeal.PostgreSQL.Binary.HasOid 'Squeal.PostgreSQL.Schema.PGtimestamp
instance Squeal.PostgreSQL.Binary.HasOid 'Squeal.PostgreSQL.Schema.PGtimestamptz
instance Squeal.PostgreSQL.Binary.HasOid 'Squeal.PostgreSQL.Schema.PGdate
instance Squeal.PostgreSQL.Binary.HasOid 'Squeal.PostgreSQL.Schema.PGtime
instance Squeal.PostgreSQL.Binary.HasOid 'Squeal.PostgreSQL.Schema.PGtimetz
instance Squeal.PostgreSQL.Binary.HasOid 'Squeal.PostgreSQL.Schema.PGinterval
instance Squeal.PostgreSQL.Binary.HasOid 'Squeal.PostgreSQL.Schema.PGuuid
instance Squeal.PostgreSQL.Binary.HasOid 'Squeal.PostgreSQL.Schema.PGinet
instance Squeal.PostgreSQL.Binary.HasOid 'Squeal.PostgreSQL.Schema.PGjson
instance Squeal.PostgreSQL.Binary.HasOid 'Squeal.PostgreSQL.Schema.PGjsonb
instance Squeal.PostgreSQL.Binary.ToParam GHC.Types.Bool 'Squeal.PostgreSQL.Schema.PGbool
instance Squeal.PostgreSQL.Binary.ToParam GHC.Int.Int16 'Squeal.PostgreSQL.Schema.PGint2
instance Squeal.PostgreSQL.Binary.ToParam GHC.Word.Word16 'Squeal.PostgreSQL.Schema.PGint2
instance Squeal.PostgreSQL.Binary.ToParam GHC.Int.Int32 'Squeal.PostgreSQL.Schema.PGint4
instance Squeal.PostgreSQL.Binary.ToParam GHC.Word.Word32 'Squeal.PostgreSQL.Schema.PGint4
instance Squeal.PostgreSQL.Binary.ToParam GHC.Int.Int64 'Squeal.PostgreSQL.Schema.PGint8
instance Squeal.PostgreSQL.Binary.ToParam GHC.Word.Word64 'Squeal.PostgreSQL.Schema.PGint8
instance Squeal.PostgreSQL.Binary.ToParam GHC.Types.Float 'Squeal.PostgreSQL.Schema.PGfloat4
instance Squeal.PostgreSQL.Binary.ToParam GHC.Types.Double 'Squeal.PostgreSQL.Schema.PGfloat8
instance Squeal.PostgreSQL.Binary.ToParam Data.Scientific.Scientific 'Squeal.PostgreSQL.Schema.PGnumeric
instance Squeal.PostgreSQL.Binary.ToParam Squeal.PostgreSQL.PG.Money 'Squeal.PostgreSQL.Schema.PGmoney
instance Squeal.PostgreSQL.Binary.ToParam Data.UUID.Types.Internal.UUID 'Squeal.PostgreSQL.Schema.PGuuid
instance Squeal.PostgreSQL.Binary.ToParam (Network.IP.Addr.NetAddr Network.IP.Addr.IP) 'Squeal.PostgreSQL.Schema.PGinet
instance Squeal.PostgreSQL.Binary.ToParam GHC.Types.Char ('Squeal.PostgreSQL.Schema.PGchar 1)
instance Squeal.PostgreSQL.Binary.ToParam Data.Text.Internal.Text 'Squeal.PostgreSQL.Schema.PGtext
instance Squeal.PostgreSQL.Binary.ToParam Data.Text.Internal.Lazy.Text 'Squeal.PostgreSQL.Schema.PGtext
instance Squeal.PostgreSQL.Binary.ToParam GHC.Base.String 'Squeal.PostgreSQL.Schema.PGtext
instance Squeal.PostgreSQL.Binary.ToParam Data.ByteString.Internal.ByteString 'Squeal.PostgreSQL.Schema.PGbytea
instance Squeal.PostgreSQL.Binary.ToParam Data.ByteString.Lazy.Internal.ByteString 'Squeal.PostgreSQL.Schema.PGbytea
instance Squeal.PostgreSQL.Binary.ToParam Data.Time.Calendar.Days.Day 'Squeal.PostgreSQL.Schema.PGdate
instance Squeal.PostgreSQL.Binary.ToParam Data.Time.LocalTime.Internal.TimeOfDay.TimeOfDay 'Squeal.PostgreSQL.Schema.PGtime
instance Squeal.PostgreSQL.Binary.ToParam (Data.Time.LocalTime.Internal.TimeOfDay.TimeOfDay, Data.Time.LocalTime.Internal.TimeZone.TimeZone) 'Squeal.PostgreSQL.Schema.PGtimetz
instance Squeal.PostgreSQL.Binary.ToParam Data.Time.LocalTime.Internal.LocalTime.LocalTime 'Squeal.PostgreSQL.Schema.PGtimestamp
instance Squeal.PostgreSQL.Binary.ToParam Data.Time.Clock.Internal.UTCTime.UTCTime 'Squeal.PostgreSQL.Schema.PGtimestamptz
instance Squeal.PostgreSQL.Binary.ToParam Data.Time.Clock.Internal.DiffTime.DiffTime 'Squeal.PostgreSQL.Schema.PGinterval
instance Squeal.PostgreSQL.Binary.ToParam Data.Aeson.Types.Internal.Value 'Squeal.PostgreSQL.Schema.PGjson
instance Squeal.PostgreSQL.Binary.ToParam Data.Aeson.Types.Internal.Value 'Squeal.PostgreSQL.Schema.PGjsonb
instance Data.Aeson.Types.ToJSON.ToJSON x => Squeal.PostgreSQL.Binary.ToParam (Squeal.PostgreSQL.PG.Json x) 'Squeal.PostgreSQL.Schema.PGjson
instance Data.Aeson.Types.ToJSON.ToJSON x => Squeal.PostgreSQL.Binary.ToParam (Squeal.PostgreSQL.PG.Jsonb x) 'Squeal.PostgreSQL.Schema.PGjsonb
instance (Generics.SOP.Universe.IsEnumType x, Generics.SOP.Universe.HasDatatypeInfo x, Squeal.PostgreSQL.PG.LabelsPG x Data.Type.Equality.~ labels) => Squeal.PostgreSQL.Binary.ToParam (Squeal.PostgreSQL.PG.Enumerated x) ('Squeal.PostgreSQL.Schema.PGenum labels)


-- | This module is where Squeal commands actually get executed by
--   <a>LibPQ</a>. It containts two typeclasses, <a>IndexedMonadTransPQ</a>
--   for executing a <a>Definition</a> and <a>MonadPQ</a> for executing a
--   <a>Manipulation</a> or <a>Query</a>, and a <a>PQ</a> type with
--   instances for them.
--   
--   Using Squeal in your application will come down to defining the
--   <tt>schemas</tt> of your database and including <tt>PQ schemas
--   schemas</tt> in your application's monad transformer stack, giving it
--   an instance of <a>MonadPQ</a>.
--   
--   This module also provides functions for retrieving rows from the
--   <a>Result</a> of executing Squeal commands.
module Squeal.PostgreSQL.PQ

-- | <a>Connection</a> encapsulates a connection to the backend.
data Connection

-- | Makes a new connection to the database server.
--   
--   This function opens a new database connection using the parameters
--   taken from the string conninfo.
--   
--   The passed string can be empty to use all default parameters, or it
--   can contain one or more parameter settings separated by whitespace.
--   Each parameter setting is in the form keyword = value. Spaces around
--   the equal sign are optional. To write an empty value or a value
--   containing spaces, surround it with single quotes, e.g., keyword = 'a
--   value'. Single quotes and backslashes within the value must be escaped
--   with a backslash, i.e., ' and .
--   
--   To specify the schema you wish to connect with, use type application.
--   
--   <pre>
--   &gt;&gt;&gt; :set -XDataKinds
--   
--   &gt;&gt;&gt; :set -XPolyKinds
--   
--   &gt;&gt;&gt; :set -XTypeOperators
--   
--   &gt;&gt;&gt; type Schema = '["tab" ::: '[] :=&gt; '["col" ::: 'NoDef :=&gt; 'Null 'PGint2]]
--   
--   &gt;&gt;&gt; :set -XTypeApplications
--   
--   &gt;&gt;&gt; :set -XOverloadedStrings
--   
--   &gt;&gt;&gt; conn &lt;- connectdb @Schema "host=localhost port=5432 dbname=exampledb"
--   </pre>
--   
--   Note that, for now, squeal doesn't offer any protection from
--   connecting with the wrong schema!
connectdb :: forall schemas io. MonadIO io => ByteString -> io (K Connection schemas)

-- | Closes the connection to the server.
finish :: MonadIO io => K Connection schemas -> io ()

-- | Do <a>connectdb</a> and <a>finish</a> before and after a computation.
withConnection :: forall schemas0 schemas1 io x. MonadUnliftIO io => ByteString -> PQ schemas0 schemas1 io x -> io x

-- | Safely <a>lowerConnection</a> to a smaller schema.
lowerConnection :: K Connection (schema : schemas) -> K Connection schemas

-- | We keep track of the schema via an Atkey indexed state monad
--   transformer, <a>PQ</a>.
newtype PQ (schemas0 :: SchemasType) (schemas1 :: SchemasType) (m :: Type -> Type) (x :: Type)
PQ :: (K Connection schemas0 -> m (K x schemas1)) -> PQ
[unPQ] :: PQ -> K Connection schemas0 -> m (K x schemas1)

-- | Run a <a>PQ</a> and keep the result and the <a>Connection</a>.
runPQ :: Functor m => PQ schemas0 schemas1 m x -> K Connection schemas0 -> m (x, K Connection schemas1)

-- | Execute a <a>PQ</a> and discard the result but keep the
--   <a>Connection</a>.
execPQ :: Functor m => PQ schemas0 schemas1 m x -> K Connection schemas0 -> m (K Connection schemas1)

-- | Evaluate a <a>PQ</a> and discard the <a>Connection</a> but keep the
--   result.
evalPQ :: Functor m => PQ schemas0 schemas1 m x -> K Connection schemas0 -> m x

-- | An <a>Atkey indexed monad</a> is a <a>Functor</a> <a>enriched
--   category</a>. An indexed monad transformer transforms a <a>Monad</a>
--   into an indexed monad. And, <a>IndexedMonadTransPQ</a> is a class for
--   indexed monad transformers that support running <a>Definition</a>s
--   using <a>define</a>.
class IndexedMonadTransPQ pq

-- | indexed analog of <a>&lt;*&gt;</a>
pqAp :: (IndexedMonadTransPQ pq, Monad m) => pq schemas0 schemas1 m (x -> y) -> pq schemas1 schemas2 m x -> pq schemas0 schemas2 m y

-- | indexed analog of <a>join</a>
pqJoin :: (IndexedMonadTransPQ pq, Monad m) => pq schemas0 schemas1 m (pq schemas1 schemas2 m y) -> pq schemas0 schemas2 m y

-- | indexed analog of <a>=&lt;&lt;</a>
pqBind :: (IndexedMonadTransPQ pq, Monad m) => (x -> pq schemas1 schemas2 m y) -> pq schemas0 schemas1 m x -> pq schemas0 schemas2 m y

-- | indexed analog of flipped <a>&gt;&gt;</a>
pqThen :: (IndexedMonadTransPQ pq, Monad m) => pq schemas1 schemas2 m y -> pq schemas0 schemas1 m x -> pq schemas0 schemas2 m y

-- | indexed analog of <a>&lt;=&lt;</a>
pqAndThen :: (IndexedMonadTransPQ pq, Monad m) => (y -> pq schemas1 schemas2 m z) -> (x -> pq schemas0 schemas1 m y) -> x -> pq schemas0 schemas2 m z

-- | Run a <a>Definition</a> with <a>exec</a>.
--   
--   It should be functorial in effect.
--   
--   <tt>define id = return ()</tt> <tt>define (statement1 &gt;&gt;&gt;
--   statement2) = define statement1 &amp; pqThen (define statement2)</tt>
define :: (IndexedMonadTransPQ pq, MonadIO io) => Definition schemas0 schemas1 -> pq schemas0 schemas1 io ()

-- | <a>MonadPQ</a> is an <tt>mtl</tt> style constraint, similar to
--   <a>MonadState</a>, for using <a>LibPQ</a> to
--   
--   <ul>
--   <li><a>manipulateParams</a> runs a <a>Manipulation</a> with params
--   from a type with a <a>ToParams</a> constraint. It calls
--   <a>execParams</a> and doesn't afraid of anything.</li>
--   <li><a>manipulateParams_</a> is like <a>manipulateParams</a> for a
--   returning-free statement.</li>
--   <li><a>manipulate</a> is like <a>manipulateParams</a> for a
--   parameter-free statement.</li>
--   <li><a>manipulate_</a> is like <a>manipulate</a> for a returning-free
--   statement.</li>
--   <li><a>runQueryParams</a> is like <a>manipulateParams</a> for query
--   statements.</li>
--   <li><a>runQuery</a> is like <a>runQueryParams</a> for a parameter-free
--   statement.</li>
--   <li><a>traversePrepared</a> has the same type signature as a
--   composition of <a>traverse</a> and <a>manipulateParams</a> but
--   provides an optimization by preparing the statement with
--   <a>prepare</a> and then traversing a <a>Traversable</a> container with
--   <a>execPrepared</a>. The temporary prepared statement is then
--   deallocated.</li>
--   <li><a>forPrepared</a> is a flipped <a>traversePrepared</a></li>
--   <li><a>traversePrepared_</a> is like <a>traversePrepared</a> but works
--   on <a>Foldable</a> containers for a returning-free statement.</li>
--   <li><a>forPrepared_</a> is a flipped <a>traversePrepared_</a>.</li>
--   <li><a>liftPQ</a> lets you lift actions from <a>LibPQ</a> that require
--   a connection into your monad.</li>
--   </ul>
--   
--   To define an instance, you can minimally define only
--   <a>manipulateParams</a>, <a>traversePrepared</a>,
--   <a>traversePrepared_</a> and <a>liftPQ</a>. Monad transformers get a
--   default instance.
class Monad pq => MonadPQ schemas pq | pq -> schemas
manipulateParams :: (MonadPQ schemas pq, ToParams x params) => Manipulation '[] schemas params ys -> x -> pq (K Result ys)
manipulateParams :: (MonadPQ schemas pq, MonadTrans t, MonadPQ schemas pq1, pq ~ t pq1) => ToParams x params => Manipulation '[] schemas params ys -> x -> pq (K Result ys)
manipulateParams_ :: (MonadPQ schemas pq, ToParams x params) => Manipulation '[] schemas params '[] -> x -> pq ()
manipulate :: MonadPQ schemas pq => Manipulation '[] schemas '[] ys -> pq (K Result ys)
manipulate_ :: MonadPQ schemas pq => Manipulation '[] schemas '[] '[] -> pq ()
runQueryParams :: (MonadPQ schemas pq, ToParams x params) => Query '[] '[] schemas params ys -> x -> pq (K Result ys)
runQuery :: MonadPQ schemas pq => Query '[] '[] schemas '[] ys -> pq (K Result ys)
traversePrepared :: (MonadPQ schemas pq, ToParams x params, Traversable list) => Manipulation '[] schemas params ys -> list x -> pq (list (K Result ys))
traversePrepared :: (MonadPQ schemas pq, MonadTrans t, MonadPQ schemas pq1, pq ~ t pq1) => (ToParams x params, Traversable list) => Manipulation '[] schemas params ys -> list x -> pq (list (K Result ys))
forPrepared :: (MonadPQ schemas pq, ToParams x params, Traversable list) => list x -> Manipulation '[] schemas params ys -> pq (list (K Result ys))
traversePrepared_ :: (MonadPQ schemas pq, ToParams x params, Foldable list) => Manipulation '[] schemas params '[] -> list x -> pq ()
traversePrepared_ :: (MonadPQ schemas pq, MonadTrans t, MonadPQ schemas pq1, pq ~ t pq1) => (ToParams x params, Foldable list) => Manipulation '[] schemas params '[] -> list x -> pq ()
forPrepared_ :: (MonadPQ schemas pq, ToParams x params, Foldable list) => list x -> Manipulation '[] schemas params '[] -> pq ()
liftPQ :: MonadPQ schemas pq => (Connection -> IO a) -> pq a
liftPQ :: (MonadPQ schemas pq, MonadTrans t, MonadPQ schemas pq1, pq ~ t pq1) => (Connection -> IO a) -> pq a

-- | <a>Result</a> encapsulates the result of a query (or more precisely,
--   of a single SQL command --- a query string given to <a>sendQuery</a>
--   can contain multiple commands and thus return multiple instances of
--   <a>Result</a>.
data Result
data Row

-- | Returns the number of rows (tuples) in the query result.
ntuples :: MonadIO io => K Result columns -> io Row

-- | Get a row corresponding to a given row number from a <a>Result</a>,
--   throwing an exception if the row number is out of bounds.
getRow :: (FromRow columns y, MonadIO io) => Row -> K Result columns -> io y

-- | Get all rows from a <a>Result</a>.
getRows :: (FromRow columns y, MonadIO io) => K Result columns -> io [y]

-- | Intended to be used for unfolding in streaming libraries,
--   <a>nextRow</a> takes a total number of rows (which can be found with
--   <a>ntuples</a>) and a <a>Result</a> and given a row number if it's too
--   large returns <a>Nothing</a>, otherwise returning the row along with
--   the next row number.
nextRow :: (FromRow columns y, MonadIO io) => Row -> K Result columns -> Row -> io (Maybe (Row, y))

-- | Get the first row if possible from a <a>Result</a>.
firstRow :: (FromRow columns y, MonadIO io) => K Result columns -> io (Maybe y)

-- | Lifts actions on results from <tt>LibPQ</tt>.
liftResult :: MonadIO io => (Result -> IO x) -> K Result results -> io x
data ExecStatus

-- | The string sent to the server was empty.
EmptyQuery :: ExecStatus

-- | Successful completion of a command returning no data.
CommandOk :: ExecStatus

-- | Successful completion of a command returning data (such as a SELECT or
--   SHOW).
TuplesOk :: ExecStatus

-- | Copy Out (from server) data transfer started.
CopyOut :: ExecStatus

-- | Copy In (to server) data transfer started.
CopyIn :: ExecStatus

-- | Copy In/Out data transfer started.
CopyBoth :: ExecStatus

-- | The server's response was not understood.
BadResponse :: ExecStatus

-- | A nonfatal error (a notice or warning) occurred.
NonfatalError :: ExecStatus

-- | A fatal error occurred.
FatalError :: ExecStatus

-- | The PGresult contains a single result tuple from the current command.
--   This status occurs only when single-row mode has been selected for the
--   query.
SingleTuple :: ExecStatus

-- | Returns the result status of the command.
resultStatus :: MonadIO io => K Result results -> io ExecStatus

-- | Returns the error message most recently generated by an operation on
--   the connection.
resultErrorMessage :: MonadIO io => K Result results -> io (Maybe ByteString)

-- | Returns the error code most recently generated by an operation on the
--   connection.
--   
--   
--   <a>https://www.postgresql.org/docs/current/static/errcodes-appendix.html</a>
resultErrorCode :: MonadIO io => K Result results -> io (Maybe ByteString)

-- | <a>Exception</a>s that can be thrown by Squeal.
data SquealException
PQException :: PQState -> SquealException
ResultException :: Text -> SquealException
ParseException :: Text -> SquealException

-- | the state of LibPQ
data PQState
PQState :: ExecStatus -> Maybe ByteString -> Maybe ByteString -> PQState
[sqlExecStatus] :: PQState -> ExecStatus

-- | 
--   <a>https://www.postgresql.org/docs/current/static/errcodes-appendix.html</a>
[sqlStateCode] :: PQState -> Maybe ByteString
[sqlErrorMessage] :: PQState -> Maybe ByteString

-- | Check if a <a>Result</a>'s status is either <a>CommandOk</a> or
--   <a>TuplesOk</a> otherwise <a>throw</a> a <a>PQException</a>.
okResult :: MonadIO io => K Result row -> io ()

-- | Catch <a>SquealException</a>s.
catchSqueal :: MonadUnliftIO io => io a -> (SquealException -> io a) -> io a

-- | Handle <a>SquealException</a>s.
handleSqueal :: MonadUnliftIO io => (SquealException -> io a) -> io a -> io a

-- | <a>Either</a> return a <a>SquealException</a> or a result.
trySqueal :: MonadUnliftIO io => io a -> io (Either SquealException a)
instance GHC.Show.Show Squeal.PostgreSQL.PQ.SquealException
instance GHC.Classes.Eq Squeal.PostgreSQL.PQ.SquealException
instance GHC.Show.Show Squeal.PostgreSQL.PQ.PQState
instance GHC.Classes.Eq Squeal.PostgreSQL.PQ.PQState
instance Squeal.PostgreSQL.PQ.IndexedMonadTransPQ Squeal.PostgreSQL.PQ.PQ
instance (Control.Monad.IO.Class.MonadIO io, schemas0 Data.Type.Equality.~ schemas, schemas1 Data.Type.Equality.~ schemas) => Squeal.PostgreSQL.PQ.MonadPQ schemas (Squeal.PostgreSQL.PQ.PQ schemas0 schemas1 io)
instance GHC.Exception.Type.Exception Squeal.PostgreSQL.PQ.SquealException
instance Squeal.PostgreSQL.PQ.MonadPQ schemas m => Squeal.PostgreSQL.PQ.MonadPQ schemas (Control.Monad.Trans.Identity.IdentityT m)
instance Squeal.PostgreSQL.PQ.MonadPQ schemas m => Squeal.PostgreSQL.PQ.MonadPQ schemas (Control.Monad.Trans.Reader.ReaderT r m)
instance Squeal.PostgreSQL.PQ.MonadPQ schemas m => Squeal.PostgreSQL.PQ.MonadPQ schemas (Control.Monad.Trans.State.Strict.StateT s m)
instance Squeal.PostgreSQL.PQ.MonadPQ schemas m => Squeal.PostgreSQL.PQ.MonadPQ schemas (Control.Monad.Trans.State.Lazy.StateT s m)
instance (GHC.Base.Monoid w, Squeal.PostgreSQL.PQ.MonadPQ schemas m) => Squeal.PostgreSQL.PQ.MonadPQ schemas (Control.Monad.Trans.Writer.Strict.WriterT w m)
instance (GHC.Base.Monoid w, Squeal.PostgreSQL.PQ.MonadPQ schemas m) => Squeal.PostgreSQL.PQ.MonadPQ schemas (Control.Monad.Trans.Writer.Lazy.WriterT w m)
instance Squeal.PostgreSQL.PQ.MonadPQ schemas m => Squeal.PostgreSQL.PQ.MonadPQ schemas (Control.Monad.Trans.Maybe.MaybeT m)
instance Squeal.PostgreSQL.PQ.MonadPQ schemas m => Squeal.PostgreSQL.PQ.MonadPQ schemas (Control.Monad.Trans.Except.ExceptT e m)
instance (GHC.Base.Monoid w, Squeal.PostgreSQL.PQ.MonadPQ schemas m) => Squeal.PostgreSQL.PQ.MonadPQ schemas (Control.Monad.Trans.RWS.Strict.RWST r w s m)
instance (GHC.Base.Monoid w, Squeal.PostgreSQL.PQ.MonadPQ schemas m) => Squeal.PostgreSQL.PQ.MonadPQ schemas (Control.Monad.Trans.RWS.Lazy.RWST r w s m)
instance Squeal.PostgreSQL.PQ.MonadPQ schemas m => Squeal.PostgreSQL.PQ.MonadPQ schemas (Control.Monad.Trans.Cont.ContT r m)
instance (GHC.Base.Monad m, schemas0 Data.Type.Equality.~ schemas1) => GHC.Base.Applicative (Squeal.PostgreSQL.PQ.PQ schemas0 schemas1 m)
instance (GHC.Base.Monad m, schemas0 Data.Type.Equality.~ schemas1) => GHC.Base.Monad (Squeal.PostgreSQL.PQ.PQ schemas0 schemas1 m)
instance GHC.Base.Monad m => GHC.Base.Functor (Squeal.PostgreSQL.PQ.PQ schemas0 schemas1 m)
instance (GHC.Base.Monad m, schemas0 Data.Type.Equality.~ schemas1) => Control.Monad.Fail.MonadFail (Squeal.PostgreSQL.PQ.PQ schemas0 schemas1 m)
instance (schemas0 Data.Type.Equality.~ schemas1) => Control.Monad.Morph.MFunctor (Squeal.PostgreSQL.PQ.PQ schemas0 schemas1)
instance (schemas0 Data.Type.Equality.~ schemas1) => Control.Monad.Trans.Class.MonadTrans (Squeal.PostgreSQL.PQ.PQ schemas0 schemas1)
instance (schemas0 Data.Type.Equality.~ schemas1) => Control.Monad.Morph.MMonad (Squeal.PostgreSQL.PQ.PQ schemas0 schemas1)
instance (Control.Monad.IO.Class.MonadIO m, schema0 Data.Type.Equality.~ schema1) => Control.Monad.IO.Class.MonadIO (Squeal.PostgreSQL.PQ.PQ schema0 schema1 m)
instance (Control.Monad.IO.Unlift.MonadUnliftIO m, schemas0 Data.Type.Equality.~ schemas1) => Control.Monad.IO.Unlift.MonadUnliftIO (Squeal.PostgreSQL.PQ.PQ schemas0 schemas1 m)


-- | A <a>MonadPQ</a> for pooled connections.
module Squeal.PostgreSQL.Pool

-- | <a>PoolPQ</a> <tt>schemas</tt> should be a drop-in replacement for
--   <a>PQ</a> <tt>schemas schemas</tt>.
--   
--   Typical use case would be to create your pool using
--   <a>createConnectionPool</a> and run anything that requires the pool
--   connection with it.
--   
--   Here's a simplified example:
--   
--   <pre>
--   &gt;&gt;&gt; import Squeal.PostgreSQL
--   
--   &gt;&gt;&gt; :{
--   do
--     let
--       query :: Query_ (Public '[]) () (Only Char)
--       query = values_ $ literal 'a' `as` #fromOnly
--       session :: PoolPQ (Public '[]) IO Char
--       session = do
--         result &lt;- runQuery query
--         Just (Only chr) &lt;- firstRow result
--         return chr
--     pool &lt;- createConnectionPool "host=localhost port=5432 dbname=exampledb" 1 0.5 10
--     chr &lt;- runPoolPQ session pool
--     destroyAllResources pool
--     putChar chr
--   :}
--   a
--   </pre>
newtype PoolPQ (schemas :: SchemasType) m x
PoolPQ :: (Pool (K Connection schemas) -> m x) -> PoolPQ m x
[runPoolPQ] :: PoolPQ m x -> Pool (K Connection schemas) -> m x

-- | Create a striped pool of connections. Although the garbage collector
--   will destroy all idle connections when the pool is garbage collected
--   it's recommended to manually <a>destroyAllResources</a> when you're
--   done with the pool so that the connections are freed up as soon as
--   possible.
createConnectionPool :: MonadUnliftIO io => ByteString -> Int -> NominalDiffTime -> Int -> io (Pool (K Connection schemas))
type Pool = Pool
destroyAllResources :: MonadUnliftIO m => Pool a -> m ()
instance GHC.Base.Functor m => GHC.Base.Functor (Squeal.PostgreSQL.Pool.PoolPQ schemas m)
instance GHC.Base.Monad m => GHC.Base.Applicative (Squeal.PostgreSQL.Pool.PoolPQ schemas m)
instance GHC.Base.Monad m => GHC.Base.Monad (Squeal.PostgreSQL.Pool.PoolPQ schemas m)
instance GHC.Base.Monad m => Control.Monad.Fail.MonadFail (Squeal.PostgreSQL.Pool.PoolPQ schemas m)
instance Control.Monad.Trans.Class.MonadTrans (Squeal.PostgreSQL.Pool.PoolPQ schemas)
instance Control.Monad.IO.Unlift.MonadUnliftIO io => Squeal.PostgreSQL.PQ.MonadPQ schemas (Squeal.PostgreSQL.Pool.PoolPQ schemas io)
instance Control.Monad.IO.Class.MonadIO m => Control.Monad.IO.Class.MonadIO (Squeal.PostgreSQL.Pool.PoolPQ schemas m)
instance Control.Monad.IO.Unlift.MonadUnliftIO m => Control.Monad.IO.Unlift.MonadUnliftIO (Squeal.PostgreSQL.Pool.PoolPQ schemas m)


-- | Literal expressions
module Squeal.PostgreSQL.Expression.Literal

-- | The <a>Literal</a> class allows embedding a Haskell value directly as
--   an <a>Expression</a> using <a>literal</a>.
--   
--   <pre>
--   &gt;&gt;&gt; printSQL (literal 'a')
--   E'a'
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; printSQL (literal (1 :: Double))
--   1.0
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; printSQL (literal (Json [1 :: Double, 2]))
--   ('[1.0,2.0]' :: json)
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; printSQL (literal (Enumerated GT))
--   'GT'
--   </pre>
class Literal hask
literal :: Literal hask => hask -> Expr (null (PG hask))
instance Squeal.PostgreSQL.Expression.Literal.Literal GHC.Types.Bool
instance Data.Aeson.Types.ToJSON.ToJSON hask => Squeal.PostgreSQL.Expression.Literal.Literal (Squeal.PostgreSQL.PG.Json hask)
instance Data.Aeson.Types.ToJSON.ToJSON hask => Squeal.PostgreSQL.Expression.Literal.Literal (Squeal.PostgreSQL.PG.Jsonb hask)
instance Squeal.PostgreSQL.Expression.Literal.Literal GHC.Types.Char
instance Squeal.PostgreSQL.Expression.Literal.Literal GHC.Base.String
instance Squeal.PostgreSQL.Expression.Literal.Literal GHC.Int.Int16
instance Squeal.PostgreSQL.Expression.Literal.Literal GHC.Int.Int32
instance Squeal.PostgreSQL.Expression.Literal.Literal GHC.Int.Int64
instance Squeal.PostgreSQL.Expression.Literal.Literal GHC.Types.Float
instance Squeal.PostgreSQL.Expression.Literal.Literal GHC.Types.Double
instance Squeal.PostgreSQL.Expression.Literal.Literal Data.Text.Internal.Text
instance Squeal.PostgreSQL.Expression.Literal.Literal Data.Text.Internal.Lazy.Text
instance Squeal.PostgreSQL.Binary.ToParam (Squeal.PostgreSQL.PG.Enumerated enum) (Squeal.PostgreSQL.PG.PG (Squeal.PostgreSQL.PG.Enumerated enum)) => Squeal.PostgreSQL.Expression.Literal.Literal (Squeal.PostgreSQL.PG.Enumerated enum)


-- | Squeal transaction control language.
module Squeal.PostgreSQL.Transaction

-- | Run a computation <a>transactionally</a>; first <a>begin</a>, then run
--   the computation, <a>onException</a> <a>rollback</a> and rethrow the
--   exception, otherwise <a>commit</a> and <a>return</a> the result.
transactionally :: (MonadUnliftIO tx, MonadPQ schemas tx) => TransactionMode -> tx x -> tx x

-- | Run a computation <a>transactionally_</a>, in <a>defaultMode</a>.
transactionally_ :: (MonadUnliftIO tx, MonadPQ schemas tx) => tx x -> tx x

-- | <a>transactionallyRetry</a> a computation;
--   
--   <ul>
--   <li>first <a>begin</a>,</li>
--   <li>then <a>try</a> the computation,</li>
--   <li>if it raises a serialization failure then <a>rollback</a> and
--   restart the transaction,</li>
--   <li>if it raises any other exception then <a>rollback</a> and rethrow
--   the exception,</li>
--   <li>otherwise <a>commit</a> and <a>return</a> the result.</li>
--   </ul>
transactionallyRetry :: (MonadUnliftIO tx, MonadPQ schemas tx) => TransactionMode -> tx x -> tx x

-- | Run a computation <a>ephemerally</a>; Like <a>transactionally</a> but
--   always <a>rollback</a>, useful in testing.
ephemerally :: (MonadUnliftIO tx, MonadPQ schemas tx) => TransactionMode -> tx x -> tx x

-- | Run a computation <a>ephemerally</a> in <a>defaultMode</a>.
ephemerally_ :: (MonadUnliftIO tx, MonadPQ schemas tx) => tx x -> tx x

-- | <tt>BEGIN</tt> a transaction.
begin :: TransactionMode -> Manipulation_ schemas () ()

-- | <tt>COMMIT</tt> a transaction.
commit :: Manipulation_ schemas () ()

-- | <tt>ROLLBACK</tt> a transaction.
rollback :: Manipulation_ schemas () ()

-- | The available transaction characteristics are the transaction
--   <a>IsolationLevel</a>, the transaction <a>AccessMode</a>
--   (<a>ReadWrite</a> or <a>ReadOnly</a>), and the <a>DeferrableMode</a>.
data TransactionMode
TransactionMode :: IsolationLevel -> AccessMode -> DeferrableMode -> TransactionMode
[isolationLevel] :: TransactionMode -> IsolationLevel
[accessMode] :: TransactionMode -> AccessMode
[deferrableMode] :: TransactionMode -> DeferrableMode

-- | <a>TransactionMode</a> with a <a>Serializable</a>
--   <a>IsolationLevel</a>, <a>ReadWrite</a> <a>AccessMode</a> and
--   <a>NotDeferrable</a> <a>DeferrableMode</a>.
defaultMode :: TransactionMode

-- | <a>TransactionMode</a> with a <a>Serializable</a>
--   <a>IsolationLevel</a>, <a>ReadOnly</a> <a>AccessMode</a> and
--   <a>Deferrable</a> <a>DeferrableMode</a>. This mode is well suited for
--   long-running reports or backups.
longRunningMode :: TransactionMode

-- | The SQL standard defines four levels of transaction isolation. The
--   most strict is <a>Serializable</a>, which is defined by the standard
--   in a paragraph which says that any concurrent execution of a set of
--   <a>Serializable</a> transactions is guaranteed to produce the same
--   effect as running them one at a time in some order. The other three
--   levels are defined in terms of phenomena, resulting from interaction
--   between concurrent transactions, which must not occur at each level.
--   The phenomena which are prohibited at various levels are:
--   
--   <b>Dirty read</b>: A transaction reads data written by a concurrent
--   uncommitted transaction.
--   
--   <b>Nonrepeatable read</b>: A transaction re-reads data it has
--   previously read and finds that data has been modified by another
--   transaction (that committed since the initial read).
--   
--   <b>Phantom read</b>: A transaction re-executes a query returning a set
--   of rows that satisfy a search condition and finds that the set of rows
--   satisfying the condition has changed due to another recently-committed
--   transaction.
--   
--   <b>Serialization anomaly</b>: The result of successfully committing a
--   group of transactions is inconsistent with all possible orderings of
--   running those transactions one at a time.
--   
--   In PostgreSQL, you can request any of the four standard transaction
--   isolation levels, but internally only three distinct isolation levels
--   are implemented, i.e. PostgreSQL's <a>ReadUncommitted</a> mode behaves
--   like <a>ReadCommitted</a>. This is because it is the only sensible way
--   to map the standard isolation levels to PostgreSQL's multiversion
--   concurrency control architecture.
data IsolationLevel

-- | Dirty read is not possible. Nonrepeatable read is not possible.
--   Phantom read is not possible. Serialization anomaly is not possible.
Serializable :: IsolationLevel

-- | Dirty read is not possible. Nonrepeatable read is not possible.
--   Phantom read is not possible. Serialization anomaly is possible.
RepeatableRead :: IsolationLevel

-- | Dirty read is not possible. Nonrepeatable read is possible. Phantom
--   read is possible. Serialization anomaly is possible.
ReadCommitted :: IsolationLevel

-- | Dirty read is not possible. Nonrepeatable read is possible. Phantom
--   read is possible. Serialization anomaly is possible.
ReadUncommitted :: IsolationLevel

-- | The transaction access mode determines whether the transaction is
--   <a>ReadWrite</a> or <a>ReadOnly</a>. <a>ReadWrite</a> is the default.
--   When a transaction is <a>ReadOnly</a>, the following SQL commands are
--   disallowed: <tt>INSERT</tt>, <tt>UPDATE</tt>, <tt>DELETE</tt>, and
--   <tt>COPY FROM</tt> if the table they would write to is not a temporary
--   table; all <tt>CREATE</tt>, <tt>ALTER</tt>, and <tt>DROP</tt>
--   commands; <tt>COMMENT</tt>, <tt>GRANT</tt>, <tt>REVOKE</tt>,
--   <tt>TRUNCATE</tt>; and <tt>EXPLAIN ANALYZE</tt> and <tt>EXECUTE</tt>
--   if the command they would execute is among those listed. This is a
--   high-level notion of <a>ReadOnly</a> that does not prevent all writes
--   to disk.
data AccessMode
ReadWrite :: AccessMode
ReadOnly :: AccessMode

-- | The <a>Deferrable</a> transaction property has no effect unless the
--   transaction is also <a>Serializable</a> and <a>ReadOnly</a>. When all
--   three of these properties are selected for a transaction, the
--   transaction may block when first acquiring its snapshot, after which
--   it is able to run without the normal overhead of a <a>Serializable</a>
--   transaction and without any risk of contributing to or being canceled
--   by a serialization failure. This <a>longRunningMode</a> is well suited
--   for long-running reports or backups.
data DeferrableMode
Deferrable :: DeferrableMode
NotDeferrable :: DeferrableMode
instance GHC.Classes.Eq Squeal.PostgreSQL.Transaction.TransactionMode
instance GHC.Show.Show Squeal.PostgreSQL.Transaction.TransactionMode
instance GHC.Classes.Eq Squeal.PostgreSQL.Transaction.DeferrableMode
instance GHC.Show.Show Squeal.PostgreSQL.Transaction.DeferrableMode
instance GHC.Classes.Eq Squeal.PostgreSQL.Transaction.AccessMode
instance GHC.Show.Show Squeal.PostgreSQL.Transaction.AccessMode
instance GHC.Classes.Eq Squeal.PostgreSQL.Transaction.IsolationLevel
instance GHC.Show.Show Squeal.PostgreSQL.Transaction.IsolationLevel
instance Squeal.PostgreSQL.Render.RenderSQL Squeal.PostgreSQL.Transaction.TransactionMode
instance Squeal.PostgreSQL.Render.RenderSQL Squeal.PostgreSQL.Transaction.DeferrableMode
instance Squeal.PostgreSQL.Render.RenderSQL Squeal.PostgreSQL.Transaction.AccessMode
instance Squeal.PostgreSQL.Render.RenderSQL Squeal.PostgreSQL.Transaction.IsolationLevel


-- | This module defines a <a>Migration</a> type to safely change the
--   schema of your database over time. Let's see an example!
--   
--   First turn on some extensions.
--   
--   <pre>
--   &gt;&gt;&gt; :set -XDataKinds -XOverloadedLabels
--   
--   &gt;&gt;&gt; :set -XOverloadedStrings -XFlexibleContexts -XTypeOperators
--   </pre>
--   
--   Next, let's define our <a>TableType</a>s.
--   
--   <pre>
--   &gt;&gt;&gt; :{
--   type UsersTable =
--     '[ "pk_users" ::: 'PrimaryKey '["id"] ] :=&gt;
--     '[ "id" ::: 'Def :=&gt; 'NotNull 'PGint4
--      , "name" ::: 'NoDef :=&gt; 'NotNull 'PGtext
--      ]
--   :}
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; :{
--   type EmailsTable =
--     '[ "pk_emails" ::: 'PrimaryKey '["id"]
--      , "fk_user_id" ::: 'ForeignKey '["user_id"] "users" '["id"]
--      ] :=&gt;
--     '[ "id" ::: 'Def :=&gt; 'NotNull 'PGint4
--      , "user_id" ::: 'NoDef :=&gt; 'NotNull 'PGint4
--      , "email" ::: 'NoDef :=&gt; 'Null 'PGtext
--      ]
--   :}
--   </pre>
--   
--   Now we can define some <a>Migration</a>s to make our tables.
--   
--   <pre>
--   &gt;&gt;&gt; :{
--   let
--     makeUsers :: Migration Definition (Public '[]) '["public" ::: '["users" ::: 'Table UsersTable]]
--     makeUsers = Migration
--       { name = "make users table"
--       , up = createTable #users
--           ( serial `as` #id :*
--             notNullable text `as` #name )
--           ( primaryKey #id `as` #pk_users )
--       , down = dropTable #users
--       }
--   :}
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; :{
--   let
--     makeEmails :: Migration Definition '["public" ::: '["users" ::: 'Table UsersTable]]
--       '["public" ::: '["users" ::: 'Table UsersTable, "emails" ::: 'Table EmailsTable]]
--     makeEmails = Migration
--       { name = "make emails table"
--       , up = createTable #emails
--             ( serial `as` #id :*
--               notNullable int `as` #user_id :*
--               nullable text `as` #email )
--             ( primaryKey #id `as` #pk_emails :*
--               foreignKey #user_id #users #id
--                 OnDeleteCascade OnUpdateCascade `as` #fk_user_id )
--       , down = dropTable #emails
--       }
--   :}
--   </pre>
--   
--   Now that we have a couple migrations we can chain them together into
--   an <a>AlignedList</a>.
--   
--   <pre>
--   &gt;&gt;&gt; let migrations = makeUsers :&gt;&gt; makeEmails :&gt;&gt; Done
--   </pre>
--   
--   Now run the migrations.
--   
--   <pre>
--   &gt;&gt;&gt; import Control.Monad.IO.Class
--   
--   &gt;&gt;&gt; :{
--   withConnection "host=localhost port=5432 dbname=exampledb" $
--     manipulate (UnsafeManipulation "SET client_min_messages TO WARNING;")
--       -- suppress notices
--     &amp; pqThen (liftIO (putStrLn "Migrate"))
--     &amp; pqThen (migrateUp migrations)
--     &amp; pqThen (liftIO (putStrLn "Rollback"))
--     &amp; pqThen (migrateDown migrations)
--   :}
--   Migrate
--   Rollback
--   </pre>
--   
--   We can also create a simple executable using <a>defaultMain</a>.
--   
--   <pre>
--   &gt;&gt;&gt; let main = defaultMain "host=localhost port=5432 dbname=exampledb" migrations
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; withArgs [] main
--   Invalid command: "". Use:
--   migrate    to run all available migrations
--   rollback   to rollback all available migrations
--   status     to display migrations run and migrations left to run
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; withArgs ["status"] main
--   Migrations already run:
--     None
--   Migrations left to run:
--     - make users table
--     - make emails table
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; withArgs ["migrate"] main
--   Migrations already run:
--     - make users table
--     - make emails table
--   Migrations left to run:
--     None
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; withArgs ["rollback"] main
--   Migrations already run:
--     None
--   Migrations left to run:
--     - make users table
--     - make emails table
--   </pre>
--   
--   In addition to enabling <a>Migration</a>s using pure SQL
--   <a>Definition</a>s for the <a>up</a> and <a>down</a> instructions, you
--   can also perform impure <a>IO</a> actions by using a <a>Migration</a>s
--   over the <a>Terminally</a> <a>PQ</a> <a>IO</a> category.
module Squeal.PostgreSQL.Migration

-- | A <a>Migration</a> is a named "isomorphism" over a given category. It
--   should contain an inverse pair of <a>up</a> and <a>down</a>
--   instructions and a unique <a>name</a>.
data Migration p schemas0 schemas1
Migration :: Text -> p schemas0 schemas1 -> p schemas1 schemas0 -> Migration p schemas0 schemas1

-- | The <a>name</a> of a <a>Migration</a>. Each <a>name</a> in a
--   <a>Migration</a> should be unique.
[name] :: Migration p schemas0 schemas1 -> Text

-- | The <a>up</a> instruction of a <a>Migration</a>.
[up] :: Migration p schemas0 schemas1 -> p schemas0 schemas1

-- | The <a>down</a> instruction of a <a>Migration</a>.
[down] :: Migration p schemas0 schemas1 -> p schemas1 schemas0

-- | A <a>Migratory</a> <tt>p</tt> is a <a>Category</a> for which one can
--   execute or rewind an <a>AlignedList</a> of <a>Migration</a>s over
--   <tt>p</tt>. This includes the category of pure SQL <a>Definition</a>s
--   and the category of impure <a>Terminally</a> <a>PQ</a> <a>IO</a>
--   actions.
class Category p => Migratory p

-- | Run an <a>AlignedList</a> of <a>Migration</a>s. Create the
--   <a>MigrationsTable</a> as <tt>public.schema_migrations</tt> if it does
--   not already exist. In one transaction, for each each <a>Migration</a>
--   query to see if the <a>Migration</a> has been executed; if not,
--   <a>up</a> the <a>Migration</a> and insert its <a>name</a> in the
--   <a>MigrationsTable</a>.
migrateUp :: Migratory p => AlignedList (Migration p) schemas0 schemas1 -> PQ schemas0 schemas1 IO ()

-- | Rewind an <a>AlignedList</a> of <a>Migration</a>s. Create the
--   <a>MigrationsTable</a> as <tt>public.schema_migrations</tt> if it does
--   not already exist. In one transaction, for each each <a>Migration</a>
--   query to see if the <a>Migration</a> has been executed; if so,
--   <a>down</a> the <a>Migration</a> and delete its <a>name</a> in the
--   <a>MigrationsTable</a>.
migrateDown :: Migratory p => AlignedList (Migration p) schemas0 schemas1 -> PQ schemas1 schemas0 IO ()

-- | <a>Terminally</a> turns an indexed monad transformer and the monad it
--   transforms into a category by restricting the return type to
--   <tt>()</tt> and permuting the type variables. This is similar to how
--   applying a monad to <tt>()</tt> yields a monoid. Since a
--   <a>Terminally</a> action has a trivial return value, the only reason
--   to run one is for the side effects, in particular database and other
--   IO effects.
newtype Terminally trans monad x0 x1
Terminally :: trans x0 x1 monad () -> Terminally trans monad x0 x1
[runTerminally] :: Terminally trans monad x0 x1 -> trans x0 x1 monad ()

-- | <a>terminally</a> ignores the output of a computation, returning
--   <tt>()</tt> and wrapping it up into a <a>Terminally</a>. You can lift
--   an action in the base monad by using <tt>terminally . lift</tt>.
terminally :: Functor (trans x0 x1 monad) => trans x0 x1 monad ignore -> Terminally trans monad x0 x1

-- | A <a>pureMigration</a> turns a <a>Migration</a> involving only pure
--   SQL <a>Definition</a>s into a <a>Migration</a> that may be combined
--   with arbitrary <a>IO</a>.
pureMigration :: Migration Definition schemas0 schemas1 -> Migration (Terminally PQ IO) schemas0 schemas1

-- | The <a>TableType</a> for a Squeal migration.
type MigrationsTable = '["migrations_unique_name" :::  'Unique '["name"]] :=> '["name" :::  'NoDef :=>  'NotNull  'PGtext, "executed_at" :::  'Def :=>  'NotNull  'PGtimestamptz]

-- | <a>defaultMain</a> creates a simple executable from a connection
--   string and a list of <a>Migration</a>s.
defaultMain :: Migratory p => ByteString -> AlignedList (Migration p) db0 db1 -> IO ()
instance GHC.Show.Show Squeal.PostgreSQL.Migration.MigrateCommand
instance GHC.Generics.Generic Squeal.PostgreSQL.Migration.MigrateCommand
instance GHC.Show.Show Squeal.PostgreSQL.Migration.MigrationRow
instance GHC.Generics.Generic Squeal.PostgreSQL.Migration.MigrationRow
instance forall k1 k2 k3 (trans :: k2 -> k3 -> k1 -> * -> *) (monad :: k1) (x0 :: k2) (x1 :: k3). GHC.Generics.Generic (Squeal.PostgreSQL.Migration.Terminally trans monad x0 x1)
instance forall k (p :: k -> k -> *) (schemas0 :: k) (schemas1 :: k). GHC.Generics.Generic (Squeal.PostgreSQL.Migration.Migration p schemas0 schemas1)
instance Squeal.PostgreSQL.Migration.Migratory (Squeal.PostgreSQL.Migration.Terminally Squeal.PostgreSQL.PQ.PQ GHC.Types.IO)
instance Generics.SOP.Universe.Generic Squeal.PostgreSQL.Migration.MigrationRow
instance Generics.SOP.Universe.HasDatatypeInfo Squeal.PostgreSQL.Migration.MigrationRow
instance (Squeal.PostgreSQL.PQ.IndexedMonadTransPQ trans, GHC.Base.Monad monad, forall (x0 :: Squeal.PostgreSQL.Schema.SchemasType) (x1 :: Squeal.PostgreSQL.Schema.SchemasType). (x0 Data.Type.Equality.~ x1) => GHC.Base.Monad (trans x0 x1 monad)) => Control.Category.Category (Squeal.PostgreSQL.Migration.Terminally trans monad)
instance Squeal.PostgreSQL.Migration.Migratory Squeal.PostgreSQL.Definition.Definition


-- | Squeal is a deep embedding of <a>PostgreSQL</a> in Haskell. Let's see
--   an example!
--   
--   First, we need some language extensions because Squeal uses modern GHC
--   features.
--   
--   <pre>
--   &gt;&gt;&gt; :set -XDataKinds -XDeriveGeneric -XOverloadedLabels -XFlexibleContexts
--   
--   &gt;&gt;&gt; :set -XOverloadedStrings -XTypeApplications -XTypeOperators -XGADTs
--   </pre>
--   
--   We'll need some imports.
--   
--   <pre>
--   &gt;&gt;&gt; import Control.Monad.IO.Class (liftIO)
--   
--   &gt;&gt;&gt; import Data.Int (Int32)
--   
--   &gt;&gt;&gt; import Data.Text (Text)
--   
--   &gt;&gt;&gt; import Squeal.PostgreSQL
--   </pre>
--   
--   We'll use generics to easily convert between Haskell and PostgreSQL
--   values.
--   
--   <pre>
--   &gt;&gt;&gt; import qualified Generics.SOP as SOP
--   
--   &gt;&gt;&gt; import qualified GHC.Generics as GHC
--   </pre>
--   
--   The first step is to define the schema of our database. This is where
--   we use <tt>DataKinds</tt> and <tt>TypeOperators</tt>.
--   
--   <pre>
--   &gt;&gt;&gt; :{
--   type UsersColumns =
--     '[ "id"   :::   'Def :=&gt; 'NotNull 'PGint4
--      , "name" ::: 'NoDef :=&gt; 'NotNull 'PGtext ]
--   type UsersConstraints = '[ "pk_users" ::: 'PrimaryKey '["id"] ]
--   type EmailsColumns =
--     '[ "id" ::: 'Def :=&gt; 'NotNull 'PGint4
--      , "user_id" ::: 'NoDef :=&gt; 'NotNull 'PGint4
--      , "email" ::: 'NoDef :=&gt; 'Null 'PGtext ]
--   type EmailsConstraints =
--     '[ "pk_emails"  ::: 'PrimaryKey '["id"]
--      , "fk_user_id" ::: 'ForeignKey '["user_id"] "users" '["id"] ]
--   type Schema =
--     '[ "users" ::: 'Table (UsersConstraints :=&gt; UsersColumns)
--      , "emails" ::: 'Table (EmailsConstraints :=&gt; EmailsColumns) ]
--   type Schemas = Public Schema
--   :}
--   </pre>
--   
--   Notice the use of type operators.
--   
--   <a>:::</a> is used to pair an alias <a>Symbol</a> with a
--   <a>SchemasType</a>, a <a>SchemumType</a>, a <a>TableConstraint</a> or
--   a <a>ColumnType</a>. It is intended to connote Haskell's <tt>::</tt>
--   operator.
--   
--   <a>:=&gt;</a> is used to pair <a>TableConstraints</a> with a
--   <a>ColumnsType</a>, yielding a <a>TableType</a>, or to pair a
--   <a>ColumnConstraint</a> with a <a>NullityType</a>, yielding a
--   <a>ColumnType</a>. It is intended to connote Haskell's <tt>=&gt;</tt>
--   operator
--   
--   Next, we'll write <a>Definition</a>s to set up and tear down the
--   schema. In Squeal, a <a>Definition</a> like <a>createTable</a>,
--   <a>alterTable</a> or <a>dropTable</a> has two type parameters,
--   corresponding to the schema before being run and the schema after. We
--   can compose definitions using <a>&gt;&gt;&gt;</a>. Here and in the
--   rest of our commands we make use of overloaded labels to refer to
--   named tables and columns in our schema.
--   
--   <pre>
--   &gt;&gt;&gt; :{
--   let
--     setup :: Definition (Public '[]) Schemas
--     setup =
--       createTable #users
--         ( serial `as` #id :*
--           (text &amp; notNullable) `as` #name )
--         ( primaryKey #id `as` #pk_users ) &gt;&gt;&gt;
--       createTable #emails
--         ( serial `as` #id :*
--           (int &amp; notNullable) `as` #user_id :*
--           (text &amp; nullable) `as` #email )
--         ( primaryKey #id `as` #pk_emails :*
--           foreignKey #user_id #users #id
--             OnDeleteCascade OnUpdateCascade `as` #fk_user_id )
--   :}
--   </pre>
--   
--   We can easily see the generated SQL is unsurprising looking.
--   
--   <pre>
--   &gt;&gt;&gt; printSQL setup
--   CREATE TABLE "users" ("id" serial, "name" text NOT NULL, CONSTRAINT "pk_users" PRIMARY KEY ("id"));
--   CREATE TABLE "emails" ("id" serial, "user_id" int NOT NULL, "email" text NULL, CONSTRAINT "pk_emails" PRIMARY KEY ("id"), CONSTRAINT "fk_user_id" FOREIGN KEY ("user_id") REFERENCES "users" ("id") ON DELETE CASCADE ON UPDATE CASCADE);
--   </pre>
--   
--   Notice that <tt>setup</tt> starts with an empty public schema
--   <tt>(Public '[])</tt> and produces <tt>Schemas</tt>. In our
--   <a>createTable</a> commands we included <a>TableConstraint</a>s to
--   define primary and foreign keys, making them somewhat complex. Our
--   <tt>teardown</tt> <a>Definition</a> is simpler.
--   
--   <pre>
--   &gt;&gt;&gt; :{
--   let
--     teardown :: Definition Schemas (Public '[])
--     teardown = dropTable #emails &gt;&gt;&gt; dropTable #users
--   :}
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; printSQL teardown
--   DROP TABLE "emails";
--   DROP TABLE "users";
--   </pre>
--   
--   We'll need a Haskell type for <tt>User</tt>s. We give the type
--   <a>Generic</a> and <a>HasDatatypeInfo</a> instances so that we can
--   encode and decode <tt>User</tt>s.
--   
--   <pre>
--   &gt;&gt;&gt; data User = User { userName :: Text, userEmail :: Maybe Text } deriving (Show, GHC.Generic)
--   
--   &gt;&gt;&gt; instance SOP.Generic User
--   
--   &gt;&gt;&gt; instance SOP.HasDatatypeInfo User
--   </pre>
--   
--   Next, we'll write <a>Manipulation_</a>s to insert <tt>User</tt>s into
--   our two tables. A <a>Manipulation_</a> like <a>insertInto</a>,
--   <a>update</a> or <a>deleteFrom</a> has three type parameters, the
--   schemas it refers to, input parameters and an output row. When we
--   insert into the users table, we will need a parameter for the
--   <tt>name</tt> field but not for the <tt>id</tt> field. Since it's
--   serial, we can use a default value. However, since the emails table
--   refers to the users table, we will need to retrieve the user id that
--   the insert generates and insert it into the emails table. We can do
--   this in a single <a>Manipulation_</a> by using a <a>with</a>
--   statement.
--   
--   <pre>
--   &gt;&gt;&gt; :{
--   let
--     insertUser :: Manipulation_ Schemas User ()
--     insertUser = with (u `as` #u) e
--       where
--         u = insertInto #users
--           (Values_ (Default `as` #id :* Set (param @1) `as` #name))
--           OnConflictDoRaise (Returning_ (#id :* param @2 `as` #email))
--         e = insertInto_ #emails $ Select
--           (Default `as` #id :* Set (#u ! #id) `as` #user_id :* Set (#u ! #email) `as` #email)
--           (from (common #u))
--   :}
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; printSQL insertUser
--   WITH "u" AS (INSERT INTO "users" ("id", "name") VALUES (DEFAULT, ($1 :: text)) RETURNING "id" AS "id", ($2 :: text) AS "email") INSERT INTO "emails" ("user_id", "email") SELECT "u"."id", "u"."email" FROM "u" AS "u"
--   </pre>
--   
--   Next we write a <a>Query_</a> to retrieve users from the database.
--   We're not interested in the ids here, just the usernames and email
--   addresses. We need to use an <a>innerJoin</a> to get the right result.
--   A <a>Query_</a> is like a <a>Manipulation_</a> with the same kind of
--   type parameters.
--   
--   <pre>
--   &gt;&gt;&gt; :{
--   let
--     getUsers :: Query_ Schemas () User
--     getUsers = select_
--       (#u ! #name `as` #userName :* #e ! #email `as` #userEmail)
--       ( from (table (#users `as` #u)
--         &amp; innerJoin (table (#emails `as` #e))
--           (#u ! #id .== #e ! #user_id)) )
--   :}
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; printSQL getUsers
--   SELECT "u"."name" AS "userName", "e"."email" AS "userEmail" FROM "users" AS "u" INNER JOIN "emails" AS "e" ON ("u"."id" = "e"."user_id")
--   </pre>
--   
--   Let's create some users to add to the database.
--   
--   <pre>
--   &gt;&gt;&gt; :{
--   let
--     users :: [User]
--     users =
--       [ User "Alice" (Just "alice@gmail.com")
--       , User "Bob" Nothing
--       , User "Carole" (Just "carole@hotmail.com")
--       ]
--   :}
--   </pre>
--   
--   Now we can put together all the pieces into a program. The program
--   connects to the database, sets up the schema, inserts the user data
--   (using prepared statements as an optimization), queries the user data
--   and prints it out and finally closes the connection. We can thread the
--   changing schema information through by using the indexed <a>PQ</a>
--   monad transformer and when the schema doesn't change we can use
--   <a>Monad</a> and <a>MonadPQ</a> functionality.
--   
--   <pre>
--   &gt;&gt;&gt; :{
--   let
--     session :: PQ Schemas Schemas IO ()
--     session = do
--       _ &lt;- traversePrepared_ insertUser users
--       usersResult &lt;- runQuery getUsers
--       usersRows &lt;- getRows usersResult
--       liftIO $ print (usersRows :: [User])
--   in
--     withConnection "host=localhost port=5432 dbname=exampledb" $
--       define setup
--       &amp; pqThen session
--       &amp; pqThen (define teardown)
--   :}
--   [User {userName = "Alice", userEmail = Just "alice@gmail.com"},User {userName = "Bob", userEmail = Nothing},User {userName = "Carole", userEmail = Just "carole@hotmail.com"}]
--   </pre>
module Squeal.PostgreSQL

-- | A class for rendering SQL
class RenderSQL sql
renderSQL :: RenderSQL sql => sql -> ByteString

-- | Print SQL.
printSQL :: (RenderSQL sql, MonadIO io) => sql -> io ()