git.iko.soy/squeal
on dev help sign in
swap
ddc9847241 ahead, 0 behind
.circleci/config.yml+1−1
since splitsnapshots
unifiedsplit
@@ -2,7 +2,7 @@ version: 2
2jobs:
2jobs:
3 build:
3 build:
4 docker:
4 docker:
5− - image: haskell:8.6.3
5+ - image: haskell:8.6.5
6 - image: circleci/postgres:latest
6 - image: circleci/postgres:latest
7 environment:
7 environment:
8 POSTGRES_USER: root
8 POSTGRES_USER: root
README.md+64−75
@@ -46,7 +46,11 @@ composable and cover a large portion of SQL.
46* transactions
46* transactions
47* views
47* views
48* array, composite and enumerated types
48* array, composite and enumerated types
49−* json operations
49+* json functions and operations
50+* multischema support
51+* correlated subqueries
52+* window functions
53+* text search
50
54
51## installation
55## installation
52
56
@@ -72,19 +76,17 @@ First, we need some language extensions because Squeal uses modern GHC
72features.
76features.
73
77
74```Haskell
78```Haskell
75−>>> :set -XDataKinds -XDeriveGeneric -XOverloadedLabels
79+>>> :set -XDataKinds -XDeriveGeneric -XOverloadedLabels -XFlexibleContexts
76−>>> :set -XOverloadedStrings -XTypeApplications -XTypeOperators
80+>>> :set -XOverloadedStrings -XTypeApplications -XTypeOperators -XGADTs
77```
81```
78
82
79We'll need some imports.
83We'll need some imports.
80
84
81```Haskell
85```Haskell
82−>>> import Control.Monad (void)
86+>>> import Control.Monad.IO.Class (liftIO)
83−>>> import Control.Monad.Base (liftBase)
84>>> import Data.Int (Int32)
87>>> import Data.Int (Int32)
85>>> import Data.Text (Text)
88>>> import Data.Text (Text)
86>>> import Squeal.PostgreSQL
89>>> import Squeal.PostgreSQL
87−>>> import Squeal.PostgreSQL.Render
88```
90```
89
91
90We'll use generics to easily convert between Haskell and PostgreSQL values.
92We'll use generics to easily convert between Haskell and PostgreSQL values.
@@ -99,27 +101,27 @@ we use `DataKinds` and `TypeOperators`.
99
101
100```Haskell
102```Haskell
101>>> :{
103>>> :{
104+type UsersColumns =
105+ '[ "id" ::: 'Def :=> 'NotNull 'PGint4
106+ , "name" ::: 'NoDef :=> 'NotNull 'PGtext ]
107+type UsersConstraints = '[ "pk_users" ::: 'PrimaryKey '["id"] ]
108+type EmailsColumns =
109+ '[ "id" ::: 'Def :=> 'NotNull 'PGint4
110+ , "user_id" ::: 'NoDef :=> 'NotNull 'PGint4
111+ , "email" ::: 'NoDef :=> 'Null 'PGtext ]
112+type EmailsConstraints =
113+ '[ "pk_emails" ::: 'PrimaryKey '["id"]
114+ , "fk_user_id" ::: 'ForeignKey '["user_id"] "users" '["id"] ]
102type Schema =
115type Schema =
103− '[ "users" ::: 'Table (
116+ '[ "users" ::: 'Table (UsersConstraints :=> UsersColumns)
104− '[ "pk_users" ::: 'PrimaryKey '["id"] ] :=>
105− '[ "id" ::: 'Def :=> 'NotNull 'PGint4
106− , "name" ::: 'NoDef :=> 'NotNull 'PGtext
107− ])
108− , "emails" ::: 'Table (
117+ , "emails" ::: 'Table (EmailsConstraints :=> EmailsColumns) ]
109− '[ "pk_emails" ::: 'PrimaryKey '["id"]
118+type Schemas = Public Schema
110− , "fk_user_id" ::: 'ForeignKey '["user_id"] "users" '["id"]
111− ] :=>
112− '[ "id" ::: 'Def :=> 'NotNull 'PGint4
113− , "user_id" ::: 'NoDef :=> 'NotNull 'PGint4
114− , "email" ::: 'NoDef :=> 'Null 'PGtext
115− ])
116− ]
117:}
119:}
118```
120```
119
121
120Notice the use of type operators.
122Notice the use of type operators.
121
123
122−`:::` is used to pair an alias `GHC.TypeLits.Symbol` with a `SchemumType`,
124+`:::` is used to pair an alias `Symbol` with a `SchemumType`,
123a `TableConstraint` or a `ColumnType`. It is intended to connote Haskell's `::`
125a `TableConstraint` or a `ColumnType`. It is intended to connote Haskell's `::`
124operator.
126operator.
125
127
@@ -128,7 +130,7 @@ yielding a `TableType`, or to pair a `ColumnConstraint` with a `NullityType`,
128yielding a `ColumnType`. It is intended to connote Haskell's `=>` operator
130yielding a `ColumnType`. It is intended to connote Haskell's `=>` operator
129
131
130Next, we'll write `Definition`s to set up and tear down the schema. In
132Next, we'll write `Definition`s to set up and tear down the schema. In
131−Squeal, a `Definition` like `createTable`, `alterTable` or `dropTable`
133+Squeal, a `Definition` like `createTable`, `alterTable` or `dropTable`
132has two type parameters, corresponding to the schema
134has two type parameters, corresponding to the schema
133before being run and the schema after. We can compose definitions using `>>>`.
135before being run and the schema after. We can compose definitions using `>>>`.
134Here and in the rest of our commands we make use of overloaded
136Here and in the rest of our commands we make use of overloaded
@@ -137,8 +139,8 @@ labels to refer to named tables and columns in our schema.
137```Haskell
139```Haskell
138>>> :{
140>>> :{
139let
141let
140− setup :: Definition '[] Schema
142+ setup :: Definition (Public '[]) Schemas
141− setup =
143+ setup =
142 createTable #users
144 createTable #users
143 ( serial `as` #id :*
145 ( serial `as` #id :*
144 (text & notNullable) `as` #name )
146 (text & notNullable) `as` #name )
@@ -169,7 +171,7 @@ primary and foreign keys, making them somewhat complex. Our `teardown`
169```Haskell
171```Haskell
170>>> :{
172>>> :{
171let
173let
172− teardown :: Definition Schema '[]
174+ teardown :: Definition Schemas (Public '[])
173 teardown = dropTable #emails >>> dropTable #users
175 teardown = dropTable #emails >>> dropTable #users
174:}
176:}
175
177
@@ -178,54 +180,54 @@ DROP TABLE "emails";
178DROP TABLE "users";
180DROP TABLE "users";
179```
181```
180
182
183+We'll need a Haskell type for `User`s. We give the type `SOP.Generic` and
184+`SOP.HasDatatypeInfo` instances so that we can encode and decode `User`s.
185+
186+```Haskell
187+>>> data User = User { userName :: Text, userEmail :: Maybe Text } deriving (Show, GHC.Generic)
188+>>> instance SOP.Generic User
189+>>> instance SOP.HasDatatypeInfo User
190+```
191+
181−Next, we'll write `Manipulation`s to insert data into our two tables.
192+Next, we'll write `Manipulation_`s to insert `User`s into our two tables.
182−A `Manipulation` like `insertRow`, `update` or `deleteFrom`
193+A `Manipulation_` like `insertInto`, `update` or `deleteFrom`
183−has three type parameters, the schema it refers to, a list of parameters
194+has three type parameters, the schemas it refers to, input parameters
184−it can take as input, and a list of columns it produces as output. When
195+and an output row. When
185we insert into the users table, we will need a parameter for the `name`
196we insert into the users table, we will need a parameter for the `name`
186field but not for the `id` field. Since it's serial, we can use a default
197field but not for the `id` field. Since it's serial, we can use a default
187value. However, since the emails table refers to the users table, we will
198value. However, since the emails table refers to the users table, we will
188need to retrieve the user id that the insert generates and insert it into
199need to retrieve the user id that the insert generates and insert it into
189−the emails table. Take a careful look at the type and definition of both
200+the emails table. We can do this in a single `Manipulation_` by using a
190−of our inserts.
201+`with` statement.
191
202
192```Haskell
203```Haskell
193>>> :{
204>>> :{
194let
205let
195− insertUser :: Manipulation Schema '[ 'NotNull 'PGtext ] '[ "fromOnly" ::: 'NotNull 'PGint4 ]
206+ insertUser :: Manipulation_ Schemas User ()
196− insertUser = insertRow #users
207+ insertUser = with (u `as` #u) e
208+ where
209+ u = insertInto #users
197− (Default `as` #id :* Set (param @1) `as` #name)
210+ (Values_ (Default `as` #id :* Set (param @1) `as` #name))
198− OnConflictDoNothing (Returning (#id `as` #fromOnly))
211+ OnConflictDoRaise (Returning_ (#id :* param @2 `as` #email))
199−:}
212+ e = insertInto_ #emails $ Select
200−
201−>>> :{
202−let
203− insertEmail :: Manipulation Schema '[ 'NotNull 'PGint4, 'Null 'PGtext] '[]
204− insertEmail = insertRow #emails
205− ( Default `as` #id :*
213+ (Default `as` #id :* Set (#u ! #id) `as` #user_id :* Set (#u ! #email) `as` #email)
206− Set (param @1) `as` #user_id :*
214+ (from (common #u))
207− Set (param @2) `as` #email )
208− OnConflictDoNothing (Returning Nil)
209:}
215:}
210
216
211>>> printSQL insertUser
217>>> printSQL insertUser
212−INSERT INTO "users" ("id", "name") VALUES (DEFAULT, ($1 :: text)) ON CONFLICT DO NOTHING RETURNING "id" AS "fromOnly"
218+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"
213−>>> printSQL insertEmail
214−INSERT INTO "emails" ("id", "user_id", "email") VALUES (DEFAULT, ($1 :: int4), ($2 :: text)) ON CONFLICT DO NOTHING
215```
219```
216
220
217−Next we write a `Query` to retrieve users from the database. We're not
221+Next we write a `Query_` to retrieve users from the database. We're not
218interested in the ids here, just the usernames and email addresses. We
222interested in the ids here, just the usernames and email addresses. We
219−need to use an inner join to get the right result. A `Query` is like a
223+need to use an `innerJoin` to get the right result. A `Query_` is like a
220−`Manipulation` with the same kind of type parameters.
224+`Manipulation_` with the same kind of type parameters.
221
225
222```Haskell
226```Haskell
223>>> :{
227>>> :{
224let
228let
225− getUsers :: Query Schema '[]
229+ getUsers :: Query_ Schemas () User
226− '[ "userName" ::: 'NotNull 'PGtext
227− , "userEmail" ::: 'Null 'PGtext ]
228− getUsers = select
230+ getUsers = select_
229 (#u ! #name `as` #userName :* #e ! #email `as` #userEmail)
231 (#u ! #name `as` #userName :* #e ! #email `as` #userEmail)
230 ( from (table (#users `as` #u)
232 ( from (table (#users `as` #u)
231 & innerJoin (table (#emails `as` #e))
233 & innerJoin (table (#emails `as` #e))
@@ -236,25 +238,13 @@ let
236SELECT "u"."name" AS "userName", "e"."email" AS "userEmail" FROM "users" AS "u" INNER JOIN "emails" AS "e" ON ("u"."id" = "e"."user_id")
238SELECT "u"."name" AS "userName", "e"."email" AS "userEmail" FROM "users" AS "u" INNER JOIN "emails" AS "e" ON ("u"."id" = "e"."user_id")
237```
239```
238
240
239−Now that we've defined the SQL side of things, we'll need a Haskell type
240−for users. We give the type `Generics.SOP.Generic` and
241−`Generics.SOP.HasDatatypeInfo` instances so that we can decode the rows
242−we receive when we run `getUsers`. Notice that the record fields of the
243−`User` type match the column names of `getUsers`.
244−
245−```Haskell
246−>>> data User = User { userName :: Text, userEmail :: Maybe Text } deriving (Show, GHC.Generic)
247−>>> instance SOP.Generic User
248−>>> instance SOP.HasDatatypeInfo User
249−```
250−
251−Let's also create some users to add to the database.
241+Let's create some users to add to the database.
252
242
253```Haskell
243```Haskell
254>>> :{
244>>> :{
255let
245let
256 users :: [User]
246 users :: [User]
257− users =
247+ users =
258 [ User "Alice" (Just "alice@gmail.com")
248 [ User "Alice" (Just "alice@gmail.com")
259 , User "Bob" Nothing
249 , User "Bob" Nothing
260 , User "Carole" (Just "carole@hotmail.com")
250 , User "Carole" (Just "carole@hotmail.com")
@@ -273,19 +263,18 @@ transformer and when the schema doesn't change we can use `Monad` and
273```Haskell
263```Haskell
274>>> :{
264>>> :{
275let
265let
276− session :: PQ Schema Schema IO ()
266+ session :: PQ Schemas Schemas IO ()
277 session = do
267 session = do
278− idResults <- traversePrepared insertUser (Only . userName <$> users)
279− ids <- traverse (fmap fromOnly . getRow 0) idResults
280− traversePrepared_ insertEmail (zip (ids :: [Int32]) (userEmail <$> users))
268+ _ <- traversePrepared_ insertUser users
281 usersResult <- runQuery getUsers
269 usersResult <- runQuery getUsers
282 usersRows <- getRows usersResult
270 usersRows <- getRows usersResult
283− liftBase $ print (usersRows :: [User])
271+ liftIO $ print (usersRows :: [User])
284in
272in
285− void . withConnection "host=localhost port=5432 dbname=exampledb" $
273+ withConnection "host=localhost port=5432 dbname=exampledb" $
286 define setup
274 define setup
287 & pqThen session
275 & pqThen session
288 & pqThen (define teardown)
276 & pqThen (define teardown)
289:}
277:}
290[User {userName = "Alice", userEmail = Just "alice@gmail.com"},User {userName = "Bob", userEmail = Nothing},User {userName = "Carole", userEmail = Just "carole@hotmail.com"}]
278[User {userName = "Alice", userEmail = Just "alice@gmail.com"},User {userName = "Bob", userEmail = Nothing},User {userName = "Carole", userEmail = Just "carole@hotmail.com"}]
279+-}
291```
280```
RELEASE NOTES.md+400
@@ -1,5 +1,405 @@
1## RELEASE NOTES
1## RELEASE NOTES
2
2
3+### Version 0.5
4+
5+Version 0.5 makes a number of large changes and additions to Squeal.
6+I want to thank folks who contributed issues and pull requests;
7+Raveline, rimmington, ilyakooo0, chshersh, reygoch, and more.
8+
9+**Multi-schema support**
10+
11+Previous versions of Squeal only supported definitions in the "public"
12+schema. Squeal 0.5 adds support for multiple schemas with the new kind
13+
14+```Haskell
15+type SchemasType = [(Symbol,SchemaType)]
16+```
17+
18+In order to upgrade your queries, manipulations and definitions from
19+Squeal 0.4, you will have to apply the `Public` type family, which indicates
20+that your only schema is the "public" schema.
21+
22+```Haskell
23+-- Squeal 0.4
24+setup :: Definition '[] Schema
25+
26+-- Squeal 0.5
27+setup :: Definition (Public '[]) (Public Schema)
28+```
29+
30+You can create non-public schemas using `createSchema` and inversely
31+remove them using `dropSchema`. There is also an idempotent
32+`createSchemaIfNotExists`.
33+
34+In order to handle aliases which may refer to non-public schemas, Squeal 0.5
35+introduces `QualifiedAlias`es. A `QualifiedAlias` can be referred to using
36+the `(!)` operator from the `IsQualified` typeclass; but if you want to refer
37+to an alias from the "public" schema, you can continue to use a single
38+overloaded label, no need to write `#public ! #tab`, just write `#tab`.
39+
40+**Top-level statements**
41+
42+As a consequence of multi-schema support, common table expressions that
43+a `Query` or `Manipulation` may refer to had to be broken into a new parameter.
44+Additionally, `Query` gained another new parameter for its outer scope which
45+will be discussed in the next section.
46+
47+To simplify type signatures that you have to write for top-level queries
48+and manipulations, Squeal 0.5 introduces the `Query_` and `Manipulation_`
49+type families.
50+
51+```
52+type family Query_
53+ (schemas :: SchemasType)
54+ (parameters :: Type)
55+ (row :: Type) where
56+ Query_ schemas params row =
57+ Query '[] '[] schemas (TuplePG params) (RowPG row)
58+```
59+
60+As you see, a top-level `Query_` has no outer scope and no common
61+table expressions in scope, they are empty `'[]`. Moreover,
62+its parameters and row parameters are now `Type`s, which are
63+converted to corresponding Postgres types using the `TuplePG`
64+and `RowPG` type families. This means you can write the type signatures
65+for your top-level statements using the Haskell types that you
66+intend to input and retrieve when running the statements. Similar
67+to `Query_`, there is a `Manipulation_` type, the only difference
68+being that a general `Manipulation` doesn't have an outer scope,
69+only a scope for common table expressions.
70+
71+**Subquery expressions**
72+
73+Previous versions of Squeal offered subquery expression support
74+but there were issues. The common use case of using the `IN` operator
75+from SQL was overly complex. There was a proliferation of subquery
76+functions to handle different comparison operators, each with two versions
77+for comparing `ALL` or `ANY` of the query rows. And, most confoundedly,
78+there was no way to support the `EXISTS` subquery because the "outer scope"
79+for a query was not available.
80+
81+Squeal adds an outer scope to the `Query` type.
82+
83+```Haskell
84+newtype Query
85+ (outer :: FromType)
86+ (commons :: FromType)
87+ (schemas :: SchemasType)
88+ (params :: [NullityType])
89+ (row :: RowType)
90+ = UnsafeQuery { renderQuery :: ByteString }
91+```
92+
93+This enables a well-typed `exists` function.
94+
95+```Haskell
96+exists
97+ :: Query (Join outer from) commons schemas params row
98+ -> Condition outer commons grp schemas params from
99+```
100+
101+The `in_` and `notIn` functions were simplified to handle the most
102+common use case of comparing to a list of values.
103+
104+```Haskell
105+in_
106+ :: Expression outer commons grp schemas params from ty -- ^ expression
107+ -> [Expression outer commons grp schemas params from ty]
108+ -> Condition outer commons grp schemas params from
109+```
110+
111+Finally, general subquery comparisons were abstracted to work with
112+any comparison operators, using the `Operator` type which will be discussed in
113+the next section.
114+
115+```Haskell
116+subAll
117+ :: Expression outer commons grp schemas params from ty1
118+ -> Operator ty1 ty2 ('Null 'PGbool)
119+ -> Query (Join outer from) commons schemas params '[col ::: ty2]
120+ -> Condition outer commons grp schemas params from
121+
122+subAny
123+ :: Expression outer commons grp schemas params from ty1
124+ -> Operator ty1 ty2 ('Null 'PGbool)
125+ -> Query (Join outer from) commons schemas params '[col ::: ty2]
126+ -> Condition outer commons grp schemas params from
127+```
128+
129+**Expression RankNTypes**
130+
131+Squeal 0.5 introduces RankNType type synonyms for common expression patterns.
132+The simplest example is the `Expr` type, a type for "closed" expressions
133+that cannot reference any aliases or parameters.
134+
135+```Haskell
136+type Expr x
137+ = forall outer commons grp schemas params from
138+ . Expression outer commons grp schemas params from x
139+```
140+
141+There is also a function type `(-->)`, which is a subtype of the usual Haskell function
142+type `(->)`.
143+
144+```Haskell
145+type (-->) x y
146+ = forall outer commons grp schemas params from
147+ . Expression outer commons grp schemas params from x
148+ -> Expression outer commons grp schemas params from y
149+```
150+
151+We saw in the subquery section that there is an `Operator` type.
152+
153+```Haskell
154+type Operator x1 x2 y
155+ = forall outer commons grp schemas params from
156+ . Expression outer commons grp schemas params from x1
157+ -> Expression outer commons grp schemas params from x2
158+ -> Expression outer commons grp schemas params from y
159+```
160+
161+There are also types `FunctionN` and `FunctionVar` for n-ary functions
162+and variadic functions.
163+
164+```
165+type FunctionN xs y
166+ = forall outer commons grp schemas params from
167+ . NP (Expression outer commons grp schemas params from) xs
168+ -> Expression outer commons grp schemas params from y
169+```
170+
171+An n-ary function takes an `NP` list of `Expression`s as its argument.
172+Squeal 0.5 adds a helpful operator `(*:)`, to help scrap your `Nil`s.
173+You can construct an `NP` list now by using the operator `(:*)`,
174+until your last element, using `(*:)` there. For instance, the function
175+`atan2_` takes two arguments, `atan2_ (pi *: 2)`.
176+
177+**Selections**
178+
179+Previously, Squeal provided a couple versions of `SELECT` depending
180+on whether you wanted to select all columns of a unique table
181+in the from clause, i.e. `*`, all columns of a particular table
182+in the from clause, i.e. `.*`, or a list of columns from the from clause.
183+
184+Squeal 0.5 refactors this pattern into a `Selection` GADT type, allowing
185+for abstraction and combinations that were not possible before.
186+
187+```Haskell
188+data Selection outer commons grp schemas params from row where
189+ Star
190+ :: HasUnique tab from row
191+ => Selection outer commons 'Ungrouped schemas params from row
192+ DotStar
193+ :: Has tab from row
194+ => Alias tab
195+ -> Selection outer commons 'Ungrouped schemas params from row
196+ List
197+ :: SListI row
198+ => NP (Aliased (Expression outer commons grp schemas params from)) row
199+ -> Selection outer commons grp schemas params from row
200+ Over
201+ :: SListI row
202+ => NP (Aliased (WindowFunction outer commons grp schemas params from)) row
203+ -> WindowDefinition outer commons grp schemas params from
204+ -> Selection outer commons grp schemas params from row
205+ Also
206+ :: Selection outer commons grp schemas params from right
207+ -> Selection outer commons grp schemas params from left
208+ -> Selection outer commons grp schemas params from (Join left right)
209+```
210+
211+In addition to the `Star`, `DotStar` and `List` constructors, there is an
212+`Also` constructor combinator, which enables users to combine `Selection`s.
213+Additionally, there is an `Over` constructor that is used to enable
214+window functions, described in the next section.
215+
216+To upgrade from Squeal 0.4, you will replace `selectStar` with `select Star`,
217+replace `selectDotStar #tab` with `select (DotStar #tab)`. The `List`
218+selection is such a common use case that there is a function `select_` which
219+automatically applies it, so to upgrade from Squeal 0.4, replace `select`
220+with `select_`. There are also independent `selectDistinct` and `selectDistinct_`
221+functions to filter out duplicate rows.
222+
223+**Query clauses**
224+
225+Previously, Squeal provided a couple versions of `INSERT` depending
226+on whether you wanted to insert `VALUES` or a query.
227+
228+Squeal 0.5 refactors this pattern into a `QueryClause` GADT.
229+
230+```
231+-- Squeal 0.4
232+insertRow_ #tab (Set 2 `as` #col1 :* Default `as` #col2)
233+insertQuery_ #tab (selectStar (from (table #other_tab)))
234+
235+-- Squeal 0.5
236+insertInto_ #tab (Values_ (Set 2 `as` #col1 :* Default `as` #col2))
237+insertInto_ #tab (Subquery (select Star (from (table #other_tab))))
238+```
239+
240+**Window functions and aggregation**
241+
242+Previous versions of Squeal provided no support for window functions.
243+Squeal 0.5 adds support for window functions. We saw `Over` in the
244+previous section.
245+
246+```Haskell
247+Over
248+ :: SListI row
249+ => NP (Aliased (WindowFunction outer commons grp schemas params from)) row
250+ -> WindowDefinition outer commons grp schemas params from
251+ -> Selection outer commons grp schemas params from row
252+```
253+
254+`Over` combines window functions with window definitions. A `WindowDefinition`
255+is constructed using the `partitionBy` function, optionally with an `orderBy`
256+clause. For example,
257+
258+```Haskell
259+query :: Query_ (Public Schema) () (Row Int32 Int32)
260+query = select
261+ (#col1 & Also (rank `as` #col2 `Over` (partitionBy #col1 & orderBy [#col2 & Asc])))
262+ (from (table #tab))
263+```
264+
265+Here the `rank` function is a `WindowFunction`
266+
267+```Haskell
268+rank :: WinFun0 ('NotNull 'PGint8)
269+rank = UnsafeWindowFunction "rank()"
270+```
271+
272+`WinFun0` is a RankNType, like `Expr` was, used for no argument window functions.
273+Similarly, there are also `WinFun1` and `WinFunN` types for
274+window functions and n-ary window functions.
275+
276+In order to use the same syntax for certain window functions and aggregate functions,
277+a new typeclass `Aggregate` was introduced. So for instance, `sum_` can be
278+either a `Distinction` `Expression` or a `WindowFunction`, used either with
279+a `groupBy` or with a `partitionBy` in the appropriate way.
280+
281+```
282+data Distinction (expr :: kind -> Type) (ty :: kind)
283+ = All (expr ty)
284+ | Distinct (expr ty)
285+```
286+
287+Aggregate functions can be run over all rows or only over distinct rows,
288+while window functions bear no such distinction.
289+
290+**Migrations**
291+
292+Thanks to [https://github.com/Raveline](Raveline) Squeal 0.5 introduces
293+a function `defaultMain` to easily create a command line program to
294+run or rewind your migrations.
295+
296+Previously, Squeal's migrations were impure, allowing in addition to
297+running `Definition`s to run arbitrary `IO` operations, such as inserting
298+data into the database or printing out status messages. In order to
299+provide compatibility with other migration systems, Squeal 0.5 introduces
300+pure migrations, that is migrations that are only `Definition`s.
301+
302+```Haskell
303+data Migration p schemas0 schemas1 = Migration
304+ { name :: Text -- ^ The `name` of a `Migration`.
305+ -- Each `name` in a `Migration` should be unique.
306+ , up :: p schemas0 schemas1 -- ^ The `up` instruction of a `Migration`.
307+ , down :: p schemas1 schemas0 -- ^ The `down` instruction of a `Migration`.
308+ } deriving (GHC.Generic)
309+```
310+
311+A pure migration is a `Migration Definition`, a pair of inverse
312+`Definition`s with a unique name. To recover impure migrations, Squeal 0.5
313+introduces the `Terminally` type.
314+
315+```Haskell
316+newtype Terminally trans monad x0 x1 = Terminally
317+ { runTerminally :: trans x0 x1 monad () }
318+```
319+
320+`Terminally` applies the indexed monad transformer and the monad it transforms
321+to the unit type `()`, thereby turning an indexed monad into a `Category`. An
322+impure migration is a `Migration (Terminally PQ IO)`. You can always cast
323+a pure migration into an impure migration with the functor, `pureMigration`.
324+
325+```Haskell
326+pureMigration
327+ :: Migration Definition schemas0 schemas1
328+ -> Migration (Terminally PQ IO) schemas0 schemas1
329+```
330+
331+To run either pure or impure migrations, Squeal 0.5 introduces
332+a typeclass, `Migratory`.
333+
334+```
335+class Category p => Migratory p where
336+
337+ migrateUp
338+ :: AlignedList (Migration p) schemas0 schemas1
339+ -> PQ schemas0 schemas1 IO ()
340+
341+ migrateDown
342+ :: AlignedList (Migration p) schemas0 schemas1
343+ -> PQ schemas1 schemas0 IO ()
344+```
345+
346+The signatures of `migrateUp` and `migrateDown` have been changed
347+to make them easier to compose with other `PQ` actions.
348+
349+**Transactions**
350+
351+You can now run transactions `ephemerally`, guaranteed to roll back,
352+but return the result or throw the exception that the transaction
353+would have generated. This is useful for testing. You can also
354+`transactionallyRetry` computations, retrying the transaction if
355+a [serialization failure](https://www.postgresql.org/docs/11/transaction-iso.html#XACT-REPEATABLE-READ) occurs.
356+
357+**Types**
358+
359+Squeal now supports money via a `Money` Haskell `Type` and a `'PGmoney`
360+`PGType`. Squeal 0.5 also adds support for creating domain types
361+with `createDomain`.
362+
363+**Time**
364+
365+Squeal 0.5 adds support for new functions; `now`, `makeDate`, `makeTime`,
366+, `makeTimestamp`, and `makeTimestamptz`, a function `interval_` for
367+constructing time intervals out multiples of `TimeUnit`s, and a new
368+`TimeOp` class, defining affine space operators for time types and their
369+differences.
370+
371+**Literals**
372+
373+Squeal allows you to include Haskell values in your statements using
374+out of line `parameter`s, but often you want to include them inline,
375+as a SQL `literal`. Squeal 0.5 enables this using the `Literal` class.
376+
377+**Set returning functions**
378+
379+Squeal 0.5 adds support for set returning functions such as `unnest`,
380+with the `RankNType` `SetOfFunction`, which can be used as as a `FromClause`.
381+
382+**Text search**
383+
384+Squeal 0.5 adds extensive support for text search types, functions and operators.
385+
386+**Much more**
387+
388+Lots more changes went into and under the hood of the new version.
389+The `Expression` module was split into coherent submodules since it
390+had grown to immense proportions. New modules `Alias`, `PG` and `List`
391+were added to relieve some of the burden that the `Schema` module
392+had been carrying. Rendering has been better unified with a new
393+`RenderSQL` typeclass. Type level list concatenation with the `Additional`
394+typeclass has been added. `Manipulation`s `update` and `delete`
395+were upgraded, so you can leave out fields you don't want to update and
396+use `USING` clauses in deletes. Upserts which were previously broken
397+now work. The `IO` typeclass hierarchy was changed from `MonadBase`
398+and `MonadBaseControl` to `MonadIO` and `MonadUnliftIO`. A new
399+`withRecursive` `Manipulation` was added. `SquealException`s were
400+refactored and a `trySqueal` function added. Arrays were refactored.
401+And there was probably more I've forgotten.
402+
3### Version 0.4
403### Version 0.4
4
404
5Version 0.4 strengthens Squeal's type system, adds
405Version 0.4 strengthens Squeal's type system, adds
squeal-postgresql/exe/Example.hs+15−13
@@ -11,8 +11,7 @@
11
11
12module Main (main, main2) where
12module Main (main, main2) where
13
13
14−import Control.Monad (void)
14+import Control.Monad.IO.Class (MonadIO (..))
15−import Control.Monad.Base (liftBase, MonadBase)
16import Data.Int (Int16, Int32)
15import Data.Int (Int16, Int32)
17import Data.Monoid ((<>))
16import Data.Monoid ((<>))
18import Data.Text (Text)
17import Data.Text (Text)
@@ -39,6 +38,7 @@ type Schema =
39 , "user_id" ::: 'NoDef :=> 'NotNull 'PGint4
38 , "user_id" ::: 'NoDef :=> 'NotNull 'PGint4
40 , "email" ::: 'NoDef :=> 'Null 'PGtext
39 , "email" ::: 'NoDef :=> 'Null 'PGtext
41 ])
40 ])
41+ , "positive" ::: 'Typedef 'PGfloat4
42 ]
42 ]
43
43
44type Schemas = Public Schema
44type Schemas = Public Schema
@@ -53,23 +53,25 @@ setup =
53 >>>
53 >>>
54 createTable #emails
54 createTable #emails
55 ( serial `as` #id :*
55 ( serial `as` #id :*
56− (int & notNullable) `as` #user_id :*
56+ hask @Int32 `as` #user_id :*
57− (text & nullable) `as` #email )
57+ hask @(Maybe Text) `as` #email )
58 ( primaryKey #id `as` #pk_emails :*
58 ( primaryKey #id `as` #pk_emails :*
59 foreignKey #user_id #users #id
59 foreignKey #user_id #users #id
60 OnDeleteCascade OnUpdateCascade `as` #fk_user_id )
60 OnDeleteCascade OnUpdateCascade `as` #fk_user_id )
61+ >>>
62+ createDomain #positive real (#value .> 0 .&& (#value & isNotNull))
61
63
62teardown :: Definition Schemas (Public '[])
64teardown :: Definition Schemas (Public '[])
63−teardown = dropTable #emails >>> dropTable #users
65+teardown = dropType #positive >>> dropTable #emails >>> dropTable #users
64
66
65insertUser :: Manipulation_ Schemas (Text, VarArray (Vector (Maybe Int16))) (Only Int32)
67insertUser :: Manipulation_ Schemas (Text, VarArray (Vector (Maybe Int16))) (Only Int32)
66insertUser = insertInto #users
68insertUser = insertInto #users
67− (Values_ (defaultAs #id :* param @1 `as` #name :* param @2 `as` #vec))
69+ (Values_ (Default `as` #id :* Set (param @1) `as` #name :* Set (param @2) `as` #vec))
68 (OnConflict (OnConstraint #pk_users) DoNothing) (Returning_ (#id `as` #fromOnly))
70 (OnConflict (OnConstraint #pk_users) DoNothing) (Returning_ (#id `as` #fromOnly))
69
71
70insertEmail :: Manipulation_ Schemas (Int32, Maybe Text) ()
72insertEmail :: Manipulation_ Schemas (Int32, Maybe Text) ()
71insertEmail = insertInto_ #emails
73insertEmail = insertInto_ #emails
72− (Values_ (defaultAs #id :* param @1 `as` #user_id :* param @2 `as` #email))
74+ (Values_ (Default `as` #id :* Set (param @1) `as` #user_id :* Set (param @2) `as` #email))
73
75
74getUsers :: Query_ Schemas () User
76getUsers :: Query_ Schemas () User
75getUsers = select_
77getUsers = select_
@@ -84,22 +86,22 @@ instance SOP.Generic User
84instance SOP.HasDatatypeInfo User
86instance SOP.HasDatatypeInfo User
85
87
86users :: [User]
88users :: [User]
87−users =
89+users =
88 [ User "Alice" (Just "alice@gmail.com") (VarArray [Nothing, Just 1])
90 [ User "Alice" (Just "alice@gmail.com") (VarArray [Nothing, Just 1])
89 , User "Bob" Nothing (VarArray [Just 2, Nothing])
91 , User "Bob" Nothing (VarArray [Just 2, Nothing])
90 , User "Carole" (Just "carole@hotmail.com") (VarArray [Just 3])
92 , User "Carole" (Just "carole@hotmail.com") (VarArray [Just 3])
91 ]
93 ]
92
94
93−session :: (MonadBase IO pq, MonadPQ Schemas pq) => pq ()
95+session :: (MonadIO pq, MonadPQ Schemas pq) => pq ()
94session = do
96session = do
95− liftBase $ Char8.putStrLn "manipulating"
97+ liftIO $ Char8.putStrLn "manipulating"
96 idResults <- traversePrepared insertUser ([(userName user, userVec user) | user <- users])
98 idResults <- traversePrepared insertUser ([(userName user, userVec user) | user <- users])
97 ids <- traverse (fmap fromOnly . getRow 0) idResults
99 ids <- traverse (fmap fromOnly . getRow 0) idResults
98 traversePrepared_ insertEmail (zip (ids :: [Int32]) (userEmail <$> users))
100 traversePrepared_ insertEmail (zip (ids :: [Int32]) (userEmail <$> users))
99− liftBase $ Char8.putStrLn "querying"
101+ liftIO $ Char8.putStrLn "querying"
100 usersResult <- runQuery getUsers
102 usersResult <- runQuery getUsers
101 usersRows <- getRows usersResult
103 usersRows <- getRows usersResult
102− liftBase $ print (usersRows :: [User])
104+ liftIO $ print (usersRows :: [User])
103
105
104main :: IO ()
106main :: IO ()
105main = do
107main = do
@@ -117,7 +119,7 @@ main = do
117
119
118main2 :: IO ()
120main2 :: IO ()
119main2 =
121main2 =
120− void . withConnection "host=localhost port=5432 dbname=exampledb" $
122+ withConnection "host=localhost port=5432 dbname=exampledb" $
121 define setup
123 define setup
122 & pqThen session
124 & pqThen session
123 & pqThen (define teardown)
125 & pqThen (define teardown)
squeal-postgresql/squeal-postgresql.cabal+58−16
@@ -1,5 +1,5 @@
1name: squeal-postgresql
1name: squeal-postgresql
2−version: 0.4.9.0
2+version: 0.5.1.0
3synopsis: Squeal PostgreSQL Library
3synopsis: Squeal PostgreSQL Library
4description: Squeal is a type-safe embedding of PostgreSQL in Haskell
4description: Squeal is a type-safe embedding of PostgreSQL in Haskell
5homepage: https://github.com/morphismtech/squeal
5homepage: https://github.com/morphismtech/squeal
@@ -22,12 +22,40 @@ library
22 hs-source-dirs: src
22 hs-source-dirs: src
23 exposed-modules:
23 exposed-modules:
24 Squeal.PostgreSQL
24 Squeal.PostgreSQL
25+ Squeal.PostgreSQL.Alias
25 Squeal.PostgreSQL.Binary
26 Squeal.PostgreSQL.Binary
26 Squeal.PostgreSQL.Definition
27 Squeal.PostgreSQL.Definition
28+ Squeal.PostgreSQL.Definition.Function
29+ Squeal.PostgreSQL.Definition.Index
30+ Squeal.PostgreSQL.Definition.Table
31+ Squeal.PostgreSQL.Definition.Table.Constraint
32+ Squeal.PostgreSQL.Definition.Type
33+ Squeal.PostgreSQL.Definition.Schema
34+ Squeal.PostgreSQL.Definition.View
27 Squeal.PostgreSQL.Expression
35 Squeal.PostgreSQL.Expression
36+ Squeal.PostgreSQL.Expression.Aggregate
37+ Squeal.PostgreSQL.Expression.Collection
38+ Squeal.PostgreSQL.Expression.Comparison
39+ Squeal.PostgreSQL.Expression.Json
40+ Squeal.PostgreSQL.Expression.Literal
41+ Squeal.PostgreSQL.Expression.Logic
42+ Squeal.PostgreSQL.Expression.Math
43+ Squeal.PostgreSQL.Expression.Null
44+ Squeal.PostgreSQL.Expression.Parameter
45+ Squeal.PostgreSQL.Expression.Range
46+ Squeal.PostgreSQL.Expression.Set
47+ Squeal.PostgreSQL.Expression.Sort
48+ Squeal.PostgreSQL.Expression.Subquery
49+ Squeal.PostgreSQL.Expression.Text
50+ Squeal.PostgreSQL.Expression.TextSearch
51+ Squeal.PostgreSQL.Expression.Time
52+ Squeal.PostgreSQL.Expression.Type
53+ Squeal.PostgreSQL.Expression.Window
54+ Squeal.PostgreSQL.List
28 Squeal.PostgreSQL.Manipulation
55 Squeal.PostgreSQL.Manipulation
29 Squeal.PostgreSQL.Migration
56 Squeal.PostgreSQL.Migration
30 Squeal.PostgreSQL.Pool
57 Squeal.PostgreSQL.Pool
58+ Squeal.PostgreSQL.PG
31 Squeal.PostgreSQL.PQ
59 Squeal.PostgreSQL.PQ
32 Squeal.PostgreSQL.Render
60 Squeal.PostgreSQL.Render
33 Squeal.PostgreSQL.Query
61 Squeal.PostgreSQL.Query
@@ -42,10 +70,9 @@ library
42 , bytestring >= 0.10.8.2
70 , bytestring >= 0.10.8.2
43 , bytestring-strict-builder >= 0.4.5
71 , bytestring-strict-builder >= 0.4.5
44 , deepseq >= 1.4.3.0
72 , deepseq >= 1.4.3.0
73+ , free-categories >= 0.1.0.0
45− , generics-sop >= 0.3.2.0
74+ , generics-sop >= 0.3.2.0 && < 0.5.0.0
46− , lifted-base >= 0.2.3.12
47 , mmorph >= 1.1.1
75 , mmorph >= 1.1.1
48− , monad-control >= 1.0.2.3
49 , mtl >= 2.2.2
76 , mtl >= 2.2.2
50 , network-ip >= 0.3.0.2
77 , network-ip >= 0.3.0.2
51 , postgresql-binary >= 0.12.1
78 , postgresql-binary >= 0.12.1
@@ -56,39 +83,55 @@ library
56 , text >= 1.2.3.0
83 , text >= 1.2.3.0
57 , time >= 1.8.0.2
84 , time >= 1.8.0.2
58 , transformers >= 0.5.2.0
85 , transformers >= 0.5.2.0
59− , transformers-base >= 0.4.4
86+ , unliftio >= 0.2.10
87+ , unliftio-pool >= 0.2.1.0
60 , uuid-types >= 1.0.3
88 , uuid-types >= 1.0.3
61 , vector >= 0.12.0.1
89 , vector >= 0.12.0.1
62
90
63−test-suite squeal-postgresql-doctest
91+test-suite doctest
64 default-language: Haskell2010
92 default-language: Haskell2010
65 type: exitcode-stdio-1.0
93 type: exitcode-stdio-1.0
66 hs-source-dirs: test
94 hs-source-dirs: test
67 ghc-options: -Wall
95 ghc-options: -Wall
68− main-is: DocTest.hs
96+ main-is: Doc.hs
69 build-depends:
97 build-depends:
70 base >= 4.10.0.0
98 base >= 4.10.0.0
71 , doctest >= 0.11.4
99 , doctest >= 0.11.4
100+ , squeal-postgresql
72
101
73−test-suite squeal-postgresql-specs
102+test-suite properties
74 default-language: Haskell2010
103 default-language: Haskell2010
75 type: exitcode-stdio-1.0
104 type: exitcode-stdio-1.0
76− hs-source-dirs: test/Specs
105+ hs-source-dirs: test
77− ghc-options: -Wall -main-is Specs
106+ ghc-options: -Wall
78− main-is: Specs.hs
107+ main-is: Property.hs
79− other-modules: ExceptionHandling
80 build-depends:
108 build-depends:
81 base >= 4.10.0.0
109 base >= 4.10.0.0
82 , bytestring >= 0.10.8.2
110 , bytestring >= 0.10.8.2
111+ , hedgehog >= 1.0
112+ , mtl >= 2.2.2
113+ , scientific >= 0.3.5.3
114+ , squeal-postgresql
115+ , time >= 1.8.0.2
116+
117+test-suite spec
118+ default-language: Haskell2010
119+ type: exitcode-stdio-1.0
120+ hs-source-dirs: test
121+ ghc-options: -Wall
122+ main-is: Spec.hs
123+ build-depends:
124+ base >= 4.10.0.0
125+ , async >= 2.2.2
126+ , bytestring >= 0.10.8.2
83 , generics-sop >= 0.3.1.0
127 , generics-sop >= 0.3.1.0
84 , hspec >= 2.4.8
128 , hspec >= 2.4.8
129+ , mtl >= 2.2.2
85 , squeal-postgresql
130 , squeal-postgresql
86 , text >= 1.2.2.2
131 , text >= 1.2.2.2
87− , transformers >= 0.5.2.0
88− , transformers-base >= 0.4.4
89 , vector >= 0.12.0.1
132 , vector >= 0.12.0.1
90
133
91−executable squeal-postgresql-example
134+executable example
92 default-language: Haskell2010
135 default-language: Haskell2010
93 hs-source-dirs: exe
136 hs-source-dirs: exe
94 ghc-options: -Wall
137 ghc-options: -Wall
@@ -101,5 +144,4 @@ executable squeal-postgresql-example
101 , squeal-postgresql
144 , squeal-postgresql
102 , text >= 1.2.2.2
145 , text >= 1.2.2.2
103 , transformers >= 0.5.2.0
146 , transformers >= 0.5.2.0
104− , transformers-base >= 0.4.4
105 , vector >= 0.12.0.1
147 , vector >= 0.12.0.1
squeal-postgresql/src/Squeal/PostgreSQL.hs+70−51
@@ -1,7 +1,7 @@
1{-|
1{-|
2Module: Squeal.PostgreSQL
2Module: Squeal.PostgreSQL
3−Description: Squeel export module
3+Description: Squeal export module
4−Copyright: (c) Eitan Chatav, 2017
4+Copyright: (c) Eitan Chatav, 2019
5Maintainer: eitan@morphism.tech
5Maintainer: eitan@morphism.tech
6Stability: experimental
6Stability: experimental
7
7
@@ -11,17 +11,15 @@ Let's see an example!
11First, we need some language extensions because Squeal uses modern GHC
11First, we need some language extensions because Squeal uses modern GHC
12features.
12features.
13
13
14−>>> :set -XDataKinds -XDeriveGeneric -XOverloadedLabels
14+>>> :set -XDataKinds -XDeriveGeneric -XOverloadedLabels -XFlexibleContexts
15>>> :set -XOverloadedStrings -XTypeApplications -XTypeOperators -XGADTs
15>>> :set -XOverloadedStrings -XTypeApplications -XTypeOperators -XGADTs
16
16
17We'll need some imports.
17We'll need some imports.
18
18
19−>>> import Control.Monad (void)
19+>>> import Control.Monad.IO.Class (liftIO)
20−>>> import Control.Monad.Base (liftBase)
21>>> import Data.Int (Int32)
20>>> import Data.Int (Int32)
22>>> import Data.Text (Text)
21>>> import Data.Text (Text)
23>>> import Squeal.PostgreSQL
22>>> import Squeal.PostgreSQL
24−>>> import Squeal.PostgreSQL.Render
25
23
26We'll use generics to easily convert between Haskell and PostgreSQL values.
24We'll use generics to easily convert between Haskell and PostgreSQL values.
27
25
@@ -60,7 +58,7 @@ yielding a `TableType`, or to pair a `ColumnConstraint` with a `NullityType`,
60yielding a `ColumnType`. It is intended to connote Haskell's @=>@ operator
58yielding a `ColumnType`. It is intended to connote Haskell's @=>@ operator
61
59
62Next, we'll write `Definition`s to set up and tear down the schema. In
60Next, we'll write `Definition`s to set up and tear down the schema. In
63−Squeal, a `Definition` like `createTable`, `alterTable` or `dropTable`
61+Squeal, a `Definition` like `createTable`, `alterTable` or `dropTable`
64has two type parameters, corresponding to the schema
62has two type parameters, corresponding to the schema
65before being run and the schema after. We can compose definitions using `>>>`.
63before being run and the schema after. We can compose definitions using `>>>`.
66Here and in the rest of our commands we make use of overloaded
64Here and in the rest of our commands we make use of overloaded
@@ -69,7 +67,7 @@ labels to refer to named tables and columns in our schema.
69>>> :{
67>>> :{
70let
68let
71 setup :: Definition (Public '[]) Schemas
69 setup :: Definition (Public '[]) Schemas
72− setup =
70+ setup =
73 createTable #users
71 createTable #users
74 ( serial `as` #id :*
72 ( serial `as` #id :*
75 (text & notNullable) `as` #name )
73 (text & notNullable) `as` #name )
@@ -104,25 +102,23 @@ let
104DROP TABLE "emails";
102DROP TABLE "emails";
105DROP TABLE "users";
103DROP TABLE "users";
106
104
105+We'll need a Haskell type for @User@s. We give the type `Generics.SOP.Generic` and
106+`Generics.SOP.HasDatatypeInfo` instances so that we can encode and decode @User@s.
107+
108+>>> data User = User { userName :: Text, userEmail :: Maybe Text } deriving (Show, GHC.Generic)
109+>>> instance SOP.Generic User
110+>>> instance SOP.HasDatatypeInfo User
111+
107−Next, we'll write `Manipulation`s to insert data into our two tables.
112+Next, we'll write `Manipulation_`s to insert @User@s into our two tables.
108−A `Manipulation` like `insertInto`, `update` or `deleteFrom`
113+A `Manipulation_` like `insertInto`, `update` or `deleteFrom`
109−has three type parameters, the schema it refers to, a list of parameters
114+has three type parameters, the schemas it refers to, input parameters
110−it can take as input, and a list of columns it produces as output. When
115+and an output row. When
111we insert into the users table, we will need a parameter for the @name@
116we insert into the users table, we will need a parameter for the @name@
112field but not for the @id@ field. Since it's serial, we can use a default
117field but not for the @id@ field. Since it's serial, we can use a default
113value. However, since the emails table refers to the users table, we will
118value. However, since the emails table refers to the users table, we will
114need to retrieve the user id that the insert generates and insert it into
119need to retrieve the user id that the insert generates and insert it into
115−the emails table. Take a careful look at the type and definition of both
120+the emails table. We can do this in a single `Manipulation_` by using a
116−of our inserts.
121+`with` statement.
117−
118−We'll need a Haskell type for users. We give the type `Generics.SOP.Generic` and
119−`Generics.SOP.HasDatatypeInfo` instances so that we can decode the rows
120−we receive when we run @getUsers@. Notice that the record fields of the
121−@User@ type match the column names of @getUsers@.
122−
123−>>> data User = User { userName :: Text, userEmail :: Maybe Text } deriving (Show, GHC.Generic)
124−>>> instance SOP.Generic User
125−>>> instance SOP.HasDatatypeInfo User
126
122
127>>> :{
123>>> :{
128let
124let
@@ -130,19 +126,20 @@ let
130 insertUser = with (u `as` #u) e
126 insertUser = with (u `as` #u) e
131 where
127 where
132 u = insertInto #users
128 u = insertInto #users
133− (Values_ (defaultAs #id :* param @1 `as` #name))
129+ (Values_ (Default `as` #id :* Set (param @1) `as` #name))
134 OnConflictDoRaise (Returning_ (#id :* param @2 `as` #email))
130 OnConflictDoRaise (Returning_ (#id :* param @2 `as` #email))
135− e = insertInto_ #emails
131+ e = insertInto_ #emails $ Select
136− (Select (defaultAs #id :* #u ! #id `as` #user_id :* #u ! #email) (from (common #u)))
132+ (Default `as` #id :* Set (#u ! #id) `as` #user_id :* Set (#u ! #email) `as` #email)
133+ (from (common #u))
137:}
134:}
138
135
139>>> printSQL insertUser
136>>> printSQL insertUser
140WITH "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"
137WITH "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"
141
138
142−Next we write a `Query` to retrieve users from the database. We're not
139+Next we write a `Query_` to retrieve users from the database. We're not
143interested in the ids here, just the usernames and email addresses. We
140interested in the ids here, just the usernames and email addresses. We
144−need to use an inner join to get the right result. A `Query` is like a
141+need to use an `innerJoin` to get the right result. A `Query_` is like a
145−`Manipulation` with the same kind of type parameters.
142+`Manipulation_` with the same kind of type parameters.
146
143
147>>> :{
144>>> :{
148let
145let
@@ -162,7 +159,7 @@ Let's create some users to add to the database.
162>>> :{
159>>> :{
163let
160let
164 users :: [User]
161 users :: [User]
165− users =
162+ users =
166 [ User "Alice" (Just "alice@gmail.com")
163 [ User "Alice" (Just "alice@gmail.com")
167 , User "Bob" Nothing
164 , User "Bob" Nothing
168 , User "Carole" (Just "carole@hotmail.com")
165 , User "Carole" (Just "carole@hotmail.com")
@@ -184,31 +181,53 @@ let
184 _ <- traversePrepared_ insertUser users
181 _ <- traversePrepared_ insertUser users
185 usersResult <- runQuery getUsers
182 usersResult <- runQuery getUsers
186 usersRows <- getRows usersResult
183 usersRows <- getRows usersResult
187− liftBase $ print (usersRows :: [User])
184+ liftIO $ print (usersRows :: [User])
188in
185in
189− void . withConnection "host=localhost port=5432 dbname=exampledb" $
186+ withConnection "host=localhost port=5432 dbname=exampledb" $
190 define setup
187 define setup
191 & pqThen session
188 & pqThen session
192 & pqThen (define teardown)
189 & pqThen (define teardown)
193:}
190:}
194[User {userName = "Alice", userEmail = Just "alice@gmail.com"},User {userName = "Bob", userEmail = Nothing},User {userName = "Carole", userEmail = Just "carole@hotmail.com"}]
191[User {userName = "Alice", userEmail = Just "alice@gmail.com"},User {userName = "Bob", userEmail = Nothing},User {userName = "Carole", userEmail = Just "carole@hotmail.com"}]
195-}
192-}
196−module Squeal.PostgreSQL
193+module Squeal.PostgreSQL (module X, RenderSQL(..), printSQL) where
197− ( module Squeal.PostgreSQL.Binary
194+
198− , module Squeal.PostgreSQL.Definition
199− , module Squeal.PostgreSQL.Expression
200− , module Squeal.PostgreSQL.Manipulation
201− , module Squeal.PostgreSQL.PQ
202− , module Squeal.PostgreSQL.Query
203− , module Squeal.PostgreSQL.Schema
204− , module Squeal.PostgreSQL.Transaction
205− ) where
206−
207−import Squeal.PostgreSQL.Binary
195+import Squeal.PostgreSQL.Alias as X
196+import Squeal.PostgreSQL.Binary as X
208−import Squeal.PostgreSQL.Definition
197+import Squeal.PostgreSQL.Definition as X
198+import Squeal.PostgreSQL.Definition.Function as X
199+import Squeal.PostgreSQL.Definition.Index as X
200+import Squeal.PostgreSQL.Definition.Schema as X
201+import Squeal.PostgreSQL.Definition.Table as X
202+import Squeal.PostgreSQL.Definition.Table.Constraint as X
203+import Squeal.PostgreSQL.Definition.Type as X
204+import Squeal.PostgreSQL.Definition.View as X
209−import Squeal.PostgreSQL.Expression
205+import Squeal.PostgreSQL.Expression as X
206+import Squeal.PostgreSQL.Expression.Aggregate as X
207+import Squeal.PostgreSQL.Expression.Collection as X
208+import Squeal.PostgreSQL.Expression.Comparison as X
209+import Squeal.PostgreSQL.Expression.Json as X
210+import Squeal.PostgreSQL.Expression.Literal as X
211+import Squeal.PostgreSQL.Expression.Logic as X
212+import Squeal.PostgreSQL.Expression.Math as X
213+import Squeal.PostgreSQL.Expression.Null as X
214+import Squeal.PostgreSQL.Expression.Parameter as X
215+import Squeal.PostgreSQL.Expression.Range as X
216+import Squeal.PostgreSQL.Expression.Set as X
217+import Squeal.PostgreSQL.Expression.Sort as X
218+import Squeal.PostgreSQL.Expression.Subquery as X
219+import Squeal.PostgreSQL.Expression.Text as X
220+import Squeal.PostgreSQL.Expression.TextSearch as X
221+import Squeal.PostgreSQL.Expression.Time as X
222+import Squeal.PostgreSQL.Expression.Type as X
223+import Squeal.PostgreSQL.Expression.Window as X
224+import Squeal.PostgreSQL.List as X
210−import Squeal.PostgreSQL.Manipulation
225+import Squeal.PostgreSQL.Manipulation as X
226+import Squeal.PostgreSQL.Migration as X
227+import Squeal.PostgreSQL.PG as X
228+import Squeal.PostgreSQL.Pool as X
211−import Squeal.PostgreSQL.PQ
229+import Squeal.PostgreSQL.PQ as X
212−import Squeal.PostgreSQL.Query
230+import Squeal.PostgreSQL.Query as X
231+import Squeal.PostgreSQL.Render (RenderSQL(..), printSQL)
213−import Squeal.PostgreSQL.Schema
232+import Squeal.PostgreSQL.Schema as X
214−import Squeal.PostgreSQL.Transaction
233+import Squeal.PostgreSQL.Transaction as X
squeal-postgresql/src/Squeal/PostgreSQL/Alias.hsnew file+249
@@ -0,0 +1,249 @@
1+{-|
2+Module: Squeal.PostgreSQL.Alias
3+Description: Aliases
4+Copyright: (c) Eitan Chatav, 2019
5+Maintainer: eitan@morphism.tech
6+Stability: experimental
7+
8+This module embeds Postgres's alias system in Haskell in
9+a typesafe fashion. Thanks to GHC's @OverloadedLabels@ extension,
10+Squeal can reference aliases by prepending with a @#@.
11+-}
12+
13+{-# LANGUAGE
14+ AllowAmbiguousTypes
15+ , ConstraintKinds
16+ , DeriveAnyClass
17+ , DeriveGeneric
18+ , FlexibleContexts
19+ , FlexibleInstances
20+ , FunctionalDependencies
21+ , GADTs
22+ , LambdaCase
23+ , OverloadedStrings
24+ , QuantifiedConstraints
25+ , RankNTypes
26+ , ScopedTypeVariables
27+ , StandaloneDeriving
28+ , TypeApplications
29+ , TypeFamilyDependencies
30+ , TypeInType
31+ , TypeOperators
32+ , UndecidableInstances
33+ , UndecidableSuperClasses
34+#-}
35+
36+module Squeal.PostgreSQL.Alias
37+ ( (:::)
38+ , Alias (..)
39+ , IsLabel (..)
40+ , Aliased (As)
41+ , Aliasable (as)
42+ , renderAliased
43+ , Has
44+ , HasUnique
45+ , HasAll
46+ , HasIn
47+ , QualifiedAlias (..)
48+ , IsQualified (..)
49+ -- * Grouping
50+ , Grouping (..)
51+ , GroupedBy
52+ ) where
53+
54+import Control.DeepSeq
55+import Data.ByteString (ByteString)
56+import Data.String (fromString)
57+import GHC.OverloadedLabels
58+import GHC.TypeLits
59+
60+import qualified Generics.SOP as SOP
61+import qualified GHC.Generics as GHC
62+
63+import Squeal.PostgreSQL.List
64+import Squeal.PostgreSQL.Render
65+
66+-- $setup
67+-- >>> import Squeal.PostgreSQL
68+
69+-- | The alias operator `:::` is like a promoted version of `As`,
70+-- a type level pair between an alias and some type.
71+type (:::) (alias :: Symbol) ty = '(alias,ty)
72+infixr 6 :::
73+
74+
75+-- | `Grouping` is an auxiliary namespace, created by
76+-- @GROUP BY@ clauses (`Squeal.PostgreSQL.Query.group`), and used
77+-- for typesafe aggregation
78+data Grouping
79+ = Ungrouped -- ^ no aggregation permitted
80+ | Grouped [(Symbol,Symbol)] -- ^ aggregation required for any column which is not grouped
81+
82+{- | A `GroupedBy` constraint indicates that a table qualified column is
83+a member of the auxiliary namespace created by @GROUP BY@ clauses and thus,
84+may be called in an output `Squeal.PostgreSQL.Expression.Expression` without aggregating.
85+-}
86+class (KnownSymbol table, KnownSymbol column)
87+ => GroupedBy table column bys where
88+instance {-# OVERLAPPING #-} (KnownSymbol table, KnownSymbol column)
89+ => GroupedBy table column ('(table,column) ': bys)
90+instance {-# OVERLAPPABLE #-}
91+ ( KnownSymbol table
92+ , KnownSymbol column
93+ , GroupedBy table column bys
94+ ) => GroupedBy table column (tabcol ': bys)
95+
96+-- | `Alias`es are proxies for a type level string or `Symbol`
97+-- and have an `IsLabel` instance so that with @-XOverloadedLabels@
98+--
99+-- >>> :set -XOverloadedLabels
100+-- >>> #foobar :: Alias "foobar"
101+-- Alias
102+data Alias (alias :: Symbol) = Alias
103+ deriving (Eq,GHC.Generic,Ord,Show,NFData)
104+instance alias1 ~ alias2 => IsLabel alias1 (Alias alias2) where
105+ fromLabel = Alias
106+instance aliases ~ '[alias] => IsLabel alias (NP Alias aliases) where
107+ fromLabel = fromLabel SOP.:* Nil
108+-- | >>> printSQL (#jimbob :: Alias "jimbob")
109+-- "jimbob"
110+instance KnownSymbol alias => RenderSQL (Alias alias) where
111+ renderSQL = doubleQuoted . fromString . symbolVal
112+
113+-- >>> printSQL (#jimbob :* #kandi :: NP Alias '["jimbob", "kandi"])
114+-- "jimbob", "kandi"
115+instance SOP.All KnownSymbol aliases => RenderSQL (NP Alias aliases) where
116+ renderSQL
117+ = commaSeparated
118+ . SOP.hcollapse
119+ . SOP.hcmap (SOP.Proxy @KnownSymbol) (SOP.K . renderSQL)
120+
121+-- | The `As` operator is used to name an expression. `As` is like a demoted
122+-- version of `:::`.
123+--
124+-- >>> Just "hello" `As` #hi :: Aliased Maybe ("hi" ::: String)
125+-- As (Just "hello") Alias
126+data Aliased expression aliased where
127+ As
128+ :: KnownSymbol alias
129+ => expression ty
130+ -> Alias alias
131+ -> Aliased expression (alias ::: ty)
132+deriving instance Show (expression ty)
133+ => Show (Aliased expression (alias ::: ty))
134+deriving instance Eq (expression ty)
135+ => Eq (Aliased expression (alias ::: ty))
136+deriving instance Ord (expression ty)
137+ => Ord (Aliased expression (alias ::: ty))
138+instance (alias0 ~ alias1, alias0 ~ alias2, KnownSymbol alias2)
139+ => IsLabel alias0 (Aliased Alias (alias1 ::: alias2)) where
140+ fromLabel = fromLabel @alias2 `As` fromLabel @alias1
141+
142+-- | The `Aliasable` class provides a way to scrap your `Nil`s
143+-- in an `NP` list of `Aliased` expressions.
144+class KnownSymbol alias => Aliasable alias expression aliased
145+ | aliased -> expression
146+ , aliased -> alias
147+ where as :: expression -> Alias alias -> aliased
148+instance (KnownSymbol alias, aliased ~ (alias ::: ty)) => Aliasable alias
149+ (expression ty)
150+ (Aliased expression aliased)
151+ where
152+ as = As
153+instance (KnownSymbol alias, tys ~ '[alias ::: ty]) => Aliasable alias
154+ (expression ty)
155+ (NP (Aliased expression) tys)
156+ where
157+ expression `as` alias = expression `As` alias SOP.:* Nil
158+
159+-- | >>> let renderMaybe = fromString . maybe "Nothing" (const "Just")
160+-- >>> renderAliased renderMaybe (Just (3::Int) `As` #an_int)
161+-- "Just AS \"an_int\""
162+renderAliased
163+ :: (forall ty. expression ty -> ByteString)
164+ -> Aliased expression aliased
165+ -> ByteString
166+renderAliased render (expression `As` alias) =
167+ render expression <> " AS " <> renderSQL alias
168+
169+-- | @HasUnique alias fields field@ is a constraint that proves that
170+-- @fields@ is a singleton of @alias ::: field@.
171+type HasUnique alias fields field = fields ~ '[alias ::: field]
172+
173+-- | @Has alias fields field@ is a constraint that proves that
174+-- @fields@ has a field of @alias ::: field@, inferring @field@
175+-- from @alias@ and @fields@.
176+class KnownSymbol alias =>
177+ Has (alias :: Symbol) (fields :: [(Symbol,kind)]) (field :: kind)
178+ | alias fields -> field where
179+instance {-# OVERLAPPING #-} KnownSymbol alias
180+ => Has alias (alias ::: field ': fields) field
181+instance {-# OVERLAPPABLE #-} (KnownSymbol alias, Has alias fields field)
182+ => Has alias (field' ': fields) field
183+
184+{-| @HasIn fields (alias ::: field)@ is a constraint that proves that
185+@fields@ has a field of @alias ::: field@. It is used in @UPDATE@s to
186+choose which subfields to update.
187+-}
188+class HasIn fields field where
189+instance (Has alias fields field) => HasIn fields (alias ::: field) where
190+
191+-- | `HasAll` extends `Has` to take lists of @aliases@ and @fields@ and infer
192+-- a list of @subfields@.
193+class
194+ ( SOP.All KnownSymbol aliases
195+ ) => HasAll
196+ (aliases :: [Symbol])
197+ (fields :: [(Symbol,kind)])
198+ (subfields :: [(Symbol,kind)])
199+ | aliases fields -> subfields where
200+instance {-# OVERLAPPING #-} HasAll '[] fields '[]
201+instance {-# OVERLAPPABLE #-}
202+ (Has alias fields field, HasAll aliases fields subfields)
203+ => HasAll (alias ': aliases) fields (alias ::: field ': subfields)
204+
205+-- | Analagous to `IsLabel`, the constraint
206+-- `IsQualified` defines `!` for a column alias qualified
207+-- by a table alias.
208+class IsQualified table column expression where
209+ (!) :: Alias table -> Alias column -> expression
210+ infixl 9 !
211+instance IsQualified table column (Alias table, Alias column) where (!) = (,)
212+
213+{-| `QualifiedAlias`es enables multi-schema support by allowing a reference
214+to a `Squeal.PostgreSQL.Schema.Table`, `Squeal.PostgreSQL.Schema.Typedef`
215+or `Squeal.PostgreSQL.Schema.View` to be qualified by their schemas. By default,
216+a qualifier of @public@ is provided.
217+
218+>>> :{
219+let
220+ alias1 :: QualifiedAlias "sch" "tab"
221+ alias1 = #sch ! #tab
222+ alias2 :: QualifiedAlias "public" "vw"
223+ alias2 = #vw
224+in printSQL alias1 >> printSQL alias2
225+:}
226+"sch"."tab"
227+"vw"
228+-}
229+data QualifiedAlias (qualifier :: Symbol) (alias :: Symbol) = QualifiedAlias
230+ deriving (Eq,GHC.Generic,Ord,Show,NFData)
231+instance (q ~ q', a ~ a') => IsQualified q a (QualifiedAlias q' a') where
232+ _!_ = QualifiedAlias
233+instance (q' ~ "public", a ~ a') => IsLabel a (QualifiedAlias q' a') where
234+ fromLabel = QualifiedAlias
235+instance (q0 ~ q1, a0 ~ a1, a1 ~ a2, KnownSymbol a2) =>
236+ IsQualified q0 a0 (Aliased (QualifiedAlias q1) (a1 ::: a2)) where
237+ _!_ = QualifiedAlias `As` Alias
238+instance (q ~ "public", a0 ~ a1, a1 ~ a2, KnownSymbol a2) =>
239+ IsLabel a0 (Aliased (QualifiedAlias q) (a1 ::: a2)) where
240+ fromLabel = QualifiedAlias `As` Alias
241+
242+instance (KnownSymbol q, KnownSymbol a)
243+ => RenderSQL (QualifiedAlias q a) where
244+ renderSQL _ =
245+ let
246+ qualifier = renderSQL (Alias @q)
247+ alias = renderSQL (Alias @a)
248+ in
249+ if qualifier == "\"public\"" then alias else qualifier <> "." <> alias
squeal-postgresql/src/Squeal/PostgreSQL/Binary.hs+221−345
@@ -16,7 +16,7 @@ Let's see some examples. We'll need some imports
16>>> import Data.Int (Int16)
16>>> import Data.Int (Int16)
17>>> import Data.Text (Text)
17>>> import Data.Text (Text)
18>>> import Control.Monad (void)
18>>> import Control.Monad (void)
19−>>> import Control.Monad.Base (liftBase)
19+>>> import Control.Monad.IO.Class (liftIO)
20>>> import Squeal.PostgreSQL
20>>> import Squeal.PostgreSQL
21
21
22Define a Haskell datatype @Row@ that will serve as both the input and output of a simple
22Define a Haskell datatype @Row@ that will serve as both the input and output of a simple
@@ -39,10 +39,10 @@ the input and output should be equal.
39
39
40>>> let input = Row 2 "hi" (Just True)
40>>> let input = Row 2 "hi" (Just True)
41>>> :{
41>>> :{
42−void . withConnection "host=localhost port=5432 dbname=exampledb" $ do
42+withConnection "host=localhost port=5432 dbname=exampledb" $ do
43 result <- runQueryParams roundTrip input
43 result <- runQueryParams roundTrip input
44 Just output <- firstRow result
44 Just output <- firstRow result
45− liftBase . print $ input == output
45+ liftIO . print $ input == output
46:}
46:}
47True
47True
48
48
@@ -78,10 +78,10 @@ let
78>>> :set -XOverloadedLists
78>>> :set -XOverloadedLists
79>>> let input = Row (VarArray [1,2]) (FixArray (Just 1,Nothing)) (FixArray ((1,2),(3,4),(5,6)))
79>>> let input = Row (VarArray [1,2]) (FixArray (Just 1,Nothing)) (FixArray ((1,2),(3,4),(5,6)))
80>>> :{
80>>> :{
81−void . withConnection "host=localhost port=5432 dbname=exampledb" $ do
81+withConnection "host=localhost port=5432 dbname=exampledb" $ do
82 result <- runQueryParams roundTrip input
82 result <- runQueryParams roundTrip input
83 Just output <- firstRow result
83 Just output <- firstRow result
84− liftBase . print $ input == output
84+ liftIO . print $ input == output
85:}
85:}
86True
86True
87
87
@@ -168,9 +168,9 @@ let
168 session = do
168 session = do
169 result <- runQueryParams roundTrip input
169 result <- runQueryParams roundTrip input
170 Just output <- firstRow result
170 Just output <- firstRow result
171− liftBase . print $ input == output
171+ liftIO . print $ input == output
172in
172in
173− void . withConnection "host=localhost port=5432 dbname=exampledb" $
173+ withConnection "host=localhost port=5432 dbname=exampledb" $
174 define setup
174 define setup
175 & pqThen session
175 & pqThen session
176 & pqThen (define teardown)
176 & pqThen (define teardown)
@@ -202,46 +202,37 @@ True
202#-}
202#-}
203
203
204module Squeal.PostgreSQL.Binary
204module Squeal.PostgreSQL.Binary
205− ( -- * PG type families
206− PG
207− , NullPG
208− , TuplePG
209− , RowPG
210− , LabelsPG
211− , FromPG
212− -- * Storage newtypes
213− , Money (..)
214− , Json (..)
215− , Jsonb (..)
216− , Composite (..)
217− , Enumerated (..)
218− , VarArray (..)
219− , FixArray (..)
220− -- * Encoding
205+ ( -- * Encoding
221− , ToParam (..)
206+ ToParam (..)
222 , ToParams (..)
207 , ToParams (..)
208+ , ToNullityParam (..)
209+ , ToField (..)
210+ , ToFixArray (..)
223 -- * Decoding
211 -- * Decoding
224 , FromValue (..)
212 , FromValue (..)
225 , FromRow (..)
213 , FromRow (..)
214+ , FromField (..)
215+ , FromFixArray (..)
226 -- * Only
216 -- * Only
227 , Only (..)
217 , Only (..)
228− , P (..)
218+ -- * Oid
219+ , OidOf (..)
220+ , OidOfParam (..)
221+ , OidOfField (..)
229 ) where
222 ) where
230
223
231import BinaryParser
224import BinaryParser
232import ByteString.StrictBuilder (builderLength, int32BE, int64BE, word32BE)
225import ByteString.StrictBuilder (builderLength, int32BE, int64BE, word32BE)
233import Control.Arrow (left)
226import Control.Arrow (left)
234import Control.Monad
227import Control.Monad
235−import Data.Aeson (Value)
236−import Data.ByteString (ByteString)
237import Data.Int
228import Data.Int
238import Data.Kind
229import Data.Kind
239import Data.Scientific
230import Data.Scientific
240−import Data.Text (Text)
241import Data.Time
231import Data.Time
242import Data.UUID.Types
232import Data.UUID.Types
243import Data.Vector (Vector)
233import Data.Vector (Vector)
244import Data.Word
234import Data.Word
235+import Foreign.C.Types (CUInt(CUInt))
245import Generics.SOP
236import Generics.SOP
246import Generics.SOP.Record
237import Generics.SOP.Record
247import GHC.TypeLits
238import GHC.TypeLits
@@ -255,11 +246,14 @@ import qualified Data.Text.Lazy as Lazy (Text)
255import qualified Data.Text as Strict (Text)
246import qualified Data.Text as Strict (Text)
256import qualified Data.Text as Strict.Text
247import qualified Data.Text as Strict.Text
257import qualified Data.Vector as Vector
248import qualified Data.Vector as Vector
258−import qualified Generics.SOP.Type.Metadata as Type
249+import qualified Database.PostgreSQL.LibPQ as LibPQ
259import qualified GHC.Generics as GHC
250import qualified GHC.Generics as GHC
260import qualified PostgreSQL.Binary.Decoding as Decoding
251import qualified PostgreSQL.Binary.Decoding as Decoding
261import qualified PostgreSQL.Binary.Encoding as Encoding
252import qualified PostgreSQL.Binary.Encoding as Encoding
262
253
254+import Squeal.PostgreSQL.Alias
255+import Squeal.PostgreSQL.List
256+import Squeal.PostgreSQL.PG
263import Squeal.PostgreSQL.Schema
257import Squeal.PostgreSQL.Schema
264
258
265-- | A `ToParam` constraint gives an encoding of a Haskell `Type` into
259-- | A `ToParam` constraint gives an encoding of a Haskell `Type` into
@@ -283,11 +277,9 @@ class ToParam (x :: Type) (pg :: PGType) where
283 toParam :: x -> K Encoding.Encoding pg
277 toParam :: x -> K Encoding.Encoding pg
284instance ToParam Bool 'PGbool where toParam = K . Encoding.bool
278instance ToParam Bool 'PGbool where toParam = K . Encoding.bool
285instance ToParam Int16 'PGint2 where toParam = K . Encoding.int2_int16
279instance ToParam Int16 'PGint2 where toParam = K . Encoding.int2_int16
286−instance ToParam Word16 'PGint2 where toParam = K . Encoding.int2_word16
287instance ToParam Int32 'PGint4 where toParam = K . Encoding.int4_int32
280instance ToParam Int32 'PGint4 where toParam = K . Encoding.int4_int32
288−instance ToParam Word32 'PGint4 where toParam = K . Encoding.int4_word32
289instance ToParam Int64 'PGint8 where toParam = K . Encoding.int8_int64
281instance ToParam Int64 'PGint8 where toParam = K . Encoding.int8_int64
290−instance ToParam Word64 'PGint8 where toParam = K . Encoding.int8_word64
282+instance ToParam Oid 'PGoid where toParam = K . Encoding.int4_word32 . getOid
291instance ToParam Float 'PGfloat4 where toParam = K . Encoding.float4
283instance ToParam Float 'PGfloat4 where toParam = K . Encoding.float4
292instance ToParam Double 'PGfloat8 where toParam = K . Encoding.float8
284instance ToParam Double 'PGfloat8 where toParam = K . Encoding.float8
293instance ToParam Scientific 'PGnumeric where toParam = K . Encoding.numeric
285instance ToParam Scientific 'PGnumeric where toParam = K . Encoding.numeric
@@ -320,24 +312,26 @@ instance Aeson.ToJSON x => ToParam (Json x) 'PGjson where
320instance Aeson.ToJSON x => ToParam (Jsonb x) 'PGjsonb where
312instance Aeson.ToJSON x => ToParam (Jsonb x) 'PGjsonb where
321 toParam = K . Encoding.jsonb_bytes
313 toParam = K . Encoding.jsonb_bytes
322 . Lazy.ByteString.toStrict . Aeson.encode . getJsonb
314 . Lazy.ByteString.toStrict . Aeson.encode . getJsonb
323−instance (ToNullityParam x ty, ty ~ nullity pg, HasOid pg)
315+instance (ToNullityParam x ty, ty ~ nullity pg, OidOf pg)
324 => ToParam (VarArray [x]) ('PGvararray ty) where
316 => ToParam (VarArray [x]) ('PGvararray ty) where
325 toParam = K
317 toParam = K
326− . Encoding.array_foldable (oid @pg) (unK . toNullityParam @x @ty)
318+ . Encoding.array_foldable
319+ (getOid (oidOf @pg)) (unK . toNullityParam @x @ty)
327 . getVarArray
320 . getVarArray
328−instance (ToParam x pg, HasOid pg)
321+instance (ToParam x pg, OidOf pg)
329 => ToParam (VarArray (Vector x)) ('PGvararray ('NotNull pg)) where
322 => ToParam (VarArray (Vector x)) ('PGvararray ('NotNull pg)) where
330 toParam = K
323 toParam = K
331− . Encoding.array_vector (oid @pg) (unK . toParam @x @pg)
324+ . Encoding.array_vector (getOid (oidOf @pg)) (unK . toParam @x @pg)
332 . getVarArray
325 . getVarArray
333−instance (ToParam x pg, HasOid pg)
326+instance (ToParam x pg, OidOf pg)
334 => ToParam (VarArray (Vector (Maybe x))) ('PGvararray ('Null pg)) where
327 => ToParam (VarArray (Vector (Maybe x))) ('PGvararray ('Null pg)) where
335 toParam = K
328 toParam = K
336− . Encoding.nullableArray_vector (oid @pg) (unK . toParam @x @pg)
329+ . Encoding.nullableArray_vector
330+ (getOid (oidOf @pg)) (unK . toParam @x @pg)
337 . getVarArray
331 . getVarArray
338−instance (ToFixArray x dims ty, ty ~ nullity pg, HasOid pg)
332+instance (ToFixArray x dims ty, ty ~ nullity pg, OidOf pg)
339 => ToParam (FixArray x) ('PGfixarray dims ty) where
333 => ToParam (FixArray x) ('PGfixarray dims ty) where
340− toParam = K . Encoding.array (oid @pg)
334+ toParam = K . Encoding.array (getOid (oidOf @pg))
341 . unK . unK . toFixArray @x @dims @ty . getFixArray
335 . unK . unK . toFixArray @x @dims @ty . getFixArray
342instance
336instance
343 ( IsEnumType x
337 ( IsEnumType x
@@ -362,7 +356,7 @@ instance
362 ( SListI fields
356 ( SListI fields
363 , IsRecord x xs
357 , IsRecord x xs
364 , AllZip ToField xs fields
358 , AllZip ToField xs fields
365− , All HasAliasedOid fields
359+ , All OidOfField fields
366 ) => ToParam (Composite x) ('PGcomposite fields) where
360 ) => ToParam (Composite x) ('PGcomposite fields) where
367 toParam =
361 toParam =
368 let
362 let
@@ -370,7 +364,7 @@ instance
370 encoders = htrans (Proxy @ToField) toField
364 encoders = htrans (Proxy @ToField) toField
371
365
372 composite
366 composite
373− :: All HasAliasedOid row
367+ :: All OidOfField row
374 => NP (K (Maybe Encoding.Encoding)) row
368 => NP (K (Maybe Encoding.Encoding)) row
375 -> K Encoding.Encoding ('PGcomposite row)
369 -> K Encoding.Encoding ('PGcomposite row)
376 composite fields = K $
370 composite fields = K $
@@ -387,27 +381,142 @@ instance
387 int32BE (fromIntegral (lengthSList (Proxy @xs))) <>
381 int32BE (fromIntegral (lengthSList (Proxy @xs))) <>
388 let
382 let
389 each
383 each
390− :: HasAliasedOid field
384+ :: OidOfField field
391 => K (Maybe Encoding.Encoding) field
385 => K (Maybe Encoding.Encoding) field
392 -> Encoding.Encoding
386 -> Encoding.Encoding
393 each (K field :: K (Maybe Encoding.Encoding) field) =
387 each (K field :: K (Maybe Encoding.Encoding) field) =
394− word32BE (aliasedOid @field)
388+ word32BE (getOid (oidOfField @field))
395 <> case field of
389 <> case field of
396 Nothing -> int64BE (-1)
390 Nothing -> int64BE (-1)
397 Just value ->
391 Just value ->
398 int32BE (fromIntegral (builderLength value))
392 int32BE (fromIntegral (builderLength value))
399 <> value
393 <> value
400 in
394 in
401− hcfoldMap (Proxy @HasAliasedOid) each fields
395+ hcfoldMap (Proxy @OidOfField) each fields
402
396
403 in
397 in
404 composite . encoders . toRecord . getComposite
398 composite . encoders . toRecord . getComposite
405
399
400+-- | The object identifier of a `PGType`.
401+--
402+-- >>> :set -XTypeApplications
403+-- >>> oidOf @'PGbool
404+-- Oid 16
405+class OidOf (ty :: PGType) where oidOf :: LibPQ.Oid
406+instance OidOf 'PGbool where oidOf = LibPQ.Oid 16
407+instance OidOf ('PGfixarray ns (null 'PGbool)) where oidOf = LibPQ.Oid 1000
408+instance OidOf ('PGvararray (null 'PGbool)) where oidOf = LibPQ.Oid 1000
409+instance OidOf 'PGint2 where oidOf = LibPQ.Oid 21
410+instance OidOf ('PGfixarray ns (null 'PGint2)) where oidOf = LibPQ.Oid 1005
411+instance OidOf ('PGvararray (null 'PGint2)) where oidOf = LibPQ.Oid 1005
412+instance OidOf 'PGint4 where oidOf = LibPQ.Oid 23
413+instance OidOf ('PGfixarray ns (null 'PGint4)) where oidOf = LibPQ.Oid 1007
414+instance OidOf ('PGvararray (null 'PGint4)) where oidOf = LibPQ.Oid 1007
415+instance OidOf 'PGint8 where oidOf = LibPQ.Oid 20
416+instance OidOf ('PGfixarray ns (null 'PGint8)) where oidOf = LibPQ.Oid 1016
417+instance OidOf ('PGvararray (null 'PGint8)) where oidOf = LibPQ.Oid 1016
418+instance OidOf 'PGnumeric where oidOf = LibPQ.Oid 1700
419+instance OidOf ('PGfixarray ns (null 'PGnumeric)) where oidOf = LibPQ.Oid 1231
420+instance OidOf ('PGvararray (null 'PGnumeric)) where oidOf = LibPQ.Oid 1231
421+instance OidOf 'PGfloat4 where oidOf = LibPQ.Oid 700
422+instance OidOf ('PGfixarray ns (null 'PGfloat4)) where oidOf = LibPQ.Oid 1021
423+instance OidOf ('PGvararray (null 'PGfloat4)) where oidOf = LibPQ.Oid 1021
424+instance OidOf 'PGfloat8 where oidOf = LibPQ.Oid 701
425+instance OidOf ('PGfixarray ns (null 'PGfloat8)) where oidOf = LibPQ.Oid 1022
426+instance OidOf ('PGvararray (null 'PGfloat8)) where oidOf = LibPQ.Oid 1022
427+instance OidOf 'PGmoney where oidOf = LibPQ.Oid 790
428+instance OidOf ('PGfixarray ns (null 'PGmoney)) where oidOf = LibPQ.Oid 791
429+instance OidOf ('PGvararray (null 'PGmoney)) where oidOf = LibPQ.Oid 791
430+instance OidOf ('PGchar n) where oidOf = LibPQ.Oid 18
431+instance OidOf ('PGfixarray ns (null ('PGchar n))) where oidOf = LibPQ.Oid 1002
432+instance OidOf ('PGvararray (null ('PGchar n))) where oidOf = LibPQ.Oid 1002
433+instance OidOf ('PGvarchar n) where oidOf = LibPQ.Oid 1043
434+instance OidOf ('PGfixarray ns (null ('PGvarchar n))) where oidOf = LibPQ.Oid 1015
435+instance OidOf ('PGvararray (null ('PGvarchar n))) where oidOf = LibPQ.Oid 1015
436+instance OidOf 'PGtext where oidOf = LibPQ.Oid 25
437+instance OidOf ('PGfixarray ns (null 'PGtext)) where oidOf = LibPQ.Oid 1009
438+instance OidOf ('PGvararray (null 'PGtext)) where oidOf = LibPQ.Oid 1009
439+instance OidOf 'PGbytea where oidOf = LibPQ.Oid 17
440+instance OidOf ('PGfixarray ns (null 'PGbytea)) where oidOf = LibPQ.Oid 1001
441+instance OidOf ('PGvararray (null 'PGbytea)) where oidOf = LibPQ.Oid 1001
442+instance OidOf 'PGtimestamp where oidOf = LibPQ.Oid 1114
443+instance OidOf ('PGfixarray ns (null 'PGtimestamp)) where oidOf = LibPQ.Oid 1115
444+instance OidOf ('PGvararray (null 'PGtimestamp)) where oidOf = LibPQ.Oid 1115
445+instance OidOf 'PGtimestamptz where oidOf = LibPQ.Oid 1184
446+instance OidOf ('PGfixarray ns (null 'PGtimestamptz)) where oidOf = LibPQ.Oid 1185
447+instance OidOf ('PGvararray (null 'PGtimestamptz)) where oidOf = LibPQ.Oid 1185
448+instance OidOf 'PGdate where oidOf = LibPQ.Oid 1082
449+instance OidOf ('PGfixarray ns (null 'PGdate)) where oidOf = LibPQ.Oid 1182
450+instance OidOf ('PGvararray (null 'PGdate)) where oidOf = LibPQ.Oid 1182
451+instance OidOf 'PGtime where oidOf = LibPQ.Oid 1083
452+instance OidOf ('PGfixarray ns (null 'PGtime)) where oidOf = LibPQ.Oid 1183
453+instance OidOf ('PGvararray (null 'PGtime)) where oidOf = LibPQ.Oid 1183
454+instance OidOf 'PGtimetz where oidOf = LibPQ.Oid 1266
455+instance OidOf ('PGfixarray ns (null 'PGtimetz)) where oidOf = LibPQ.Oid 1270
456+instance OidOf ('PGvararray (null 'PGtimetz)) where oidOf = LibPQ.Oid 1270
457+instance OidOf 'PGinterval where oidOf = LibPQ.Oid 1186
458+instance OidOf ('PGfixarray ns (null 'PGinterval)) where oidOf = LibPQ.Oid 1187
459+instance OidOf ('PGvararray (null 'PGinterval)) where oidOf = LibPQ.Oid 1187
460+instance OidOf 'PGuuid where oidOf = LibPQ.Oid 2950
461+instance OidOf ('PGfixarray ns (null 'PGuuid)) where oidOf = LibPQ.Oid 2951
462+instance OidOf ('PGvararray (null 'PGuuid)) where oidOf = LibPQ.Oid 2951
463+instance OidOf 'PGinet where oidOf = LibPQ.Oid 869
464+instance OidOf ('PGfixarray ns (null 'PGinet)) where oidOf = LibPQ.Oid 1041
465+instance OidOf ('PGvararray (null 'PGinet)) where oidOf = LibPQ.Oid 1041
466+instance OidOf 'PGjson where oidOf = LibPQ.Oid 114
467+instance OidOf ('PGfixarray ns (null 'PGjson)) where oidOf = LibPQ.Oid 199
468+instance OidOf ('PGvararray (null 'PGjson)) where oidOf = LibPQ.Oid 199
469+instance OidOf 'PGjsonb where oidOf = LibPQ.Oid 3802
470+instance OidOf ('PGfixarray ns (null 'PGjsonb)) where oidOf = LibPQ.Oid 3807
471+instance OidOf ('PGvararray (null 'PGjsonb)) where oidOf = LibPQ.Oid 3807
472+instance OidOf 'PGtsvector where oidOf = LibPQ.Oid 3614
473+instance OidOf ('PGfixarray ns (null 'PGtsvector)) where oidOf = LibPQ.Oid 3643
474+instance OidOf ('PGvararray (null 'PGtsvector)) where oidOf = LibPQ.Oid 3643
475+instance OidOf 'PGtsquery where oidOf = LibPQ.Oid 3615
476+instance OidOf ('PGfixarray ns (null 'PGtsquery)) where oidOf = LibPQ.Oid 3645
477+instance OidOf ('PGvararray (null 'PGtsquery)) where oidOf = LibPQ.Oid 3645
478+instance OidOf 'PGoid where oidOf = LibPQ.Oid 26
479+instance OidOf ('PGfixarray ns (null 'PGoid)) where oidOf = LibPQ.Oid 1028
480+instance OidOf ('PGvararray (null 'PGoid)) where oidOf = LibPQ.Oid 1028
481+instance OidOf ('PGrange 'PGint4) where oidOf = LibPQ.Oid 3904
482+instance OidOf ('PGfixarray ns (null ('PGrange 'PGint4))) where oidOf = LibPQ.Oid 3905
483+instance OidOf ('PGvararray (null ('PGrange 'PGint4))) where oidOf = LibPQ.Oid 3905
484+instance OidOf ('PGrange 'PGint8) where oidOf = LibPQ.Oid 3926
485+instance OidOf ('PGfixarray ns (null ('PGrange 'PGint8))) where oidOf = LibPQ.Oid 3927
486+instance OidOf ('PGvararray (null ('PGrange 'PGint8))) where oidOf = LibPQ.Oid 3927
487+instance OidOf ('PGrange 'PGnumeric) where oidOf = LibPQ.Oid 3906
488+instance OidOf ('PGfixarray ns (null ('PGrange 'PGnumeric))) where oidOf = LibPQ.Oid 3907
489+instance OidOf ('PGvararray (null ('PGrange 'PGnumeric))) where oidOf = LibPQ.Oid 3907
490+instance OidOf ('PGrange 'PGtimestamp) where oidOf = LibPQ.Oid 3908
491+instance OidOf ('PGfixarray ns (null ('PGrange 'PGtimestamp))) where oidOf = LibPQ.Oid 3909
492+instance OidOf ('PGvararray (null ('PGrange 'PGtimestamp))) where oidOf = LibPQ.Oid 3909
493+instance OidOf ('PGrange 'PGtimestamptz) where oidOf = LibPQ.Oid 3910
494+instance OidOf ('PGfixarray ns (null ('PGrange 'PGtimestamptz))) where oidOf = LibPQ.Oid 3911
495+instance OidOf ('PGvararray (null ('PGrange 'PGtimestamptz))) where oidOf = LibPQ.Oid 3911
496+instance OidOf ('PGrange 'PGdate) where oidOf = LibPQ.Oid 3912
497+instance OidOf ('PGfixarray ns (null ('PGrange 'PGdate))) where oidOf = LibPQ.Oid 3913
498+instance OidOf ('PGvararray (null ('PGrange 'PGdate))) where oidOf = LibPQ.Oid 3913
499+instance {-# OVERLAPPABLE #-} OidOf ('PGrange ty) where oidOf = LibPQ.invalidOid
500+instance {-# OVERLAPPABLE #-} OidOf ('PGfixarray ns (null ('PGrange ty))) where oidOf = LibPQ.invalidOid
501+instance {-# OVERLAPPABLE #-} OidOf ('PGvararray (null ('PGrange ty))) where oidOf = LibPQ.invalidOid
502+instance {-# OVERLAPPABLE #-} OidOf ('PGcomposite row) where oidOf = LibPQ.invalidOid
503+instance {-# OVERLAPPABLE #-} OidOf ('PGfixarray ns (null ('PGcomposite row))) where oidOf = LibPQ.invalidOid
504+instance {-# OVERLAPPABLE #-} OidOf ('PGvararray (null ('PGcomposite row))) where oidOf = LibPQ.invalidOid
505+instance {-# OVERLAPPABLE #-} OidOf ('PGenum labels) where oidOf = LibPQ.invalidOid
506+instance {-# OVERLAPPABLE #-} OidOf ('PGfixarray ns (null ('PGenum labels))) where oidOf = LibPQ.invalidOid
507+instance {-# OVERLAPPABLE #-} OidOf ('PGvararray (null ('PGenum labels))) where oidOf = LibPQ.invalidOid
508+
509+class OidOfParam (ty :: NullityType) where oidOfParam :: Oid
510+instance OidOf ty => OidOfParam (null ty) where oidOfParam = oidOf @ty
511+
512+-- | Lifts a `OidOf` constraint to a field.
406−class HasAliasedOid (field :: (Symbol, NullityType)) where
513+class OidOfField (field :: (Symbol, NullityType)) where
407− aliasedOid :: Word32
514+ oidOfField :: Oid
408−instance HasOid ty => HasAliasedOid (alias ::: nullity ty) where
515+instance OidOf ty => OidOfField (alias ::: nullity ty) where
409− aliasedOid = oid @ty
516+ oidOfField = oidOf @ty
410−
517+
518+-- | A `ToNullityParam` constraint gives an encoding of a Haskell `Type` into
519+-- into the binary format of a PostgreSQL `NullityType`.
411class ToNullityParam (x :: Type) (ty :: NullityType) where
520class ToNullityParam (x :: Type) (ty :: NullityType) where
412 toNullityParam :: x -> K (Maybe Encoding.Encoding) ty
521 toNullityParam :: x -> K (Maybe Encoding.Encoding) ty
413instance ToParam x pg => ToNullityParam x ('NotNull pg) where
522instance ToParam x pg => ToNullityParam x ('NotNull pg) where
@@ -415,11 +524,19 @@ instance ToParam x pg => ToNullityParam x ('NotNull pg) where
415instance ToParam x pg => ToNullityParam (Maybe x) ('Null pg) where
524instance ToParam x pg => ToNullityParam (Maybe x) ('Null pg) where
416 toNullityParam = K . fmap (unK . toParam @x @pg)
525 toNullityParam = K . fmap (unK . toParam @x @pg)
417
526
527+-- | A `ToField` constraint lifts the `ToParam` parser
528+-- to an encoding of a @(Symbol, Type)@ to a @(Symbol, NullityType)@,
529+-- encoding `Null`s to `Maybe`s. You should not define instances for
530+-- `FromField`, just use the provided instances.
418class ToField (x :: (Symbol, Type)) (field :: (Symbol, NullityType)) where
531class ToField (x :: (Symbol, Type)) (field :: (Symbol, NullityType)) where
419 toField :: P x -> K (Maybe Encoding.Encoding) field
532 toField :: P x -> K (Maybe Encoding.Encoding) field
420instance ToNullityParam x ty => ToField (alias ::: x) (alias ::: ty) where
533instance ToNullityParam x ty => ToField (alias ::: x) (alias ::: ty) where
421 toField (P x) = K . unK $ toNullityParam @x @ty x
534 toField (P x) = K . unK $ toNullityParam @x @ty x
422
535
536+-- | A `ToFixArray` constraint gives an encoding of a Haskell `Type`
537+-- into the binary format of a PostgreSQL fixed-length array.
538+-- You should not define instances for
539+-- `ToFixArray`, just use the provided instances.
423class ToFixArray (x :: Type) (dims :: [Nat]) (array :: NullityType) where
540class ToFixArray (x :: Type) (dims :: [Nat]) (array :: NullityType) where
424 toFixArray :: x -> K (K Encoding.Array dims) array
541 toFixArray :: x -> K (K Encoding.Array dims) array
425instance ToNullityParam x ty => ToFixArray x '[] ty where
542instance ToNullityParam x ty => ToFixArray x '[] ty where
@@ -465,6 +582,7 @@ instance FromValue 'PGbool Bool where fromValue = Decoding.bool
465instance FromValue 'PGint2 Int16 where fromValue = Decoding.int
582instance FromValue 'PGint2 Int16 where fromValue = Decoding.int
466instance FromValue 'PGint4 Int32 where fromValue = Decoding.int
583instance FromValue 'PGint4 Int32 where fromValue = Decoding.int
467instance FromValue 'PGint8 Int64 where fromValue = Decoding.int
584instance FromValue 'PGint8 Int64 where fromValue = Decoding.int
585+instance FromValue 'PGoid Word32 where fromValue = Decoding.int
468instance FromValue 'PGfloat4 Float where fromValue = Decoding.float4
586instance FromValue 'PGfloat4 Float where fromValue = Decoding.float4
469instance FromValue 'PGfloat8 Double where fromValue = Decoding.float8
587instance FromValue 'PGfloat8 Double where fromValue = Decoding.float8
470instance FromValue 'PGnumeric Scientific where fromValue = Decoding.numeric
588instance FromValue 'PGnumeric Scientific where fromValue = Decoding.numeric
@@ -603,6 +721,10 @@ instance FromValue pg y
603 K (Just bytestring) -> P . Just <$>
721 K (Just bytestring) -> P . Just <$>
604 Decoding.valueParser (fromValue @pg) bytestring
722 Decoding.valueParser (fromValue @pg) bytestring
605
723
724+-- | A `FromFixArray` constraint gives a decoding to a Haskell `Type`
725+-- from the binary format of a PostgreSQL fixed-length array.
726+-- You should not define instances for
727+-- `FromFixArray`, just use the provided instances.
606class FromFixArray (dims :: [Nat]) (ty :: NullityType) (y :: Type) where
728class FromFixArray (dims :: [Nat]) (ty :: NullityType) (y :: Type) where
607 fromFixArray :: Decoding.Array y
729 fromFixArray :: Decoding.Array y
608instance FromValue pg y => FromFixArray '[] ('NotNull pg) y where
730instance FromValue pg y => FromFixArray '[] ('NotNull pg) y where
@@ -647,50 +769,53 @@ instance
647 = fmap fromRecord
769 = fmap fromRecord
648 . hsequence'
770 . hsequence'
649 . htrans (Proxy @FromField) fromField
771 . htrans (Proxy @FromField) fromField
772+------------------------------------------------------
773+-- P records
774+------------------------------------------------------
650−instance (FromField (col ::: pg) (col ::: hask))
775+-- instance (FromField (col ::: pg) (col ::: hask))
651− => FromRow '[col ::: pg] (P (col ::: hask)) where
776+-- => FromRow '[col ::: pg] (P (col ::: hask)) where
652− fromRow (pg :* Nil) = (unComp . fromField) pg
777+-- fromRow (pg :* Nil) = (unComp . fromField) pg
653−instance
778+-- instance
654− ( row ~ Join row1 row2
779+-- ( row ~ Join row1 row2
655− , FromRow row1 hask1
780+-- , FromRow row1 hask1
656− , FromRow row2 hask2
781+-- , FromRow row2 hask2
657− , SListI row
782+-- , SListI row
658− ) => FromRow row (hask1, hask2) where
783+-- ) => FromRow row (hask1, hask2) where
659− fromRow row = case disjoin @row1 @row2 row of
784+-- fromRow row = case disjoin @row1 @row2 row of
660− (row1, row2) -> (,) <$> fromRow row1 <*> fromRow row2
785+-- (row1, row2) -> (,) <$> fromRow row1 <*> fromRow row2
661−instance
786+-- instance
662− ( row ~ Join row1 row23
787+-- ( row ~ Join row1 row23
663− , FromRow row1 hask1
788+-- , FromRow row1 hask1
664− , FromRow row23 (hask2, hask3)
789+-- , FromRow row23 (hask2, hask3)
665− , SListI row
790+-- , SListI row
666− ) => FromRow row (hask1, hask2, hask3) where
791+-- ) => FromRow row (hask1, hask2, hask3) where
667− fromRow row = case disjoin @row1 @row23 row of
792+-- fromRow row = case disjoin @row1 @row23 row of
668− (row1, row23) -> do
793+-- (row1, row23) -> do
669− hask1 <- fromRow row1
794+-- hask1 <- fromRow row1
670− (hask2, hask3) <- fromRow row23
795+-- (hask2, hask3) <- fromRow row23
671− return (hask1, hask2, hask3)
796+-- return (hask1, hask2, hask3)
672−instance
797+-- instance
673− ( row ~ Join row1 row234
798+-- ( row ~ Join row1 row234
674− , FromRow row1 hask1
799+-- , FromRow row1 hask1
675− , FromRow row234 (hask2, hask3, hask4)
800+-- , FromRow row234 (hask2, hask3, hask4)
676− , SListI row
801+-- , SListI row
677− ) => FromRow row (hask1, hask2, hask3, hask4) where
802+-- ) => FromRow row (hask1, hask2, hask3, hask4) where
678− fromRow row = case disjoin @row1 @row234 row of
803+-- fromRow row = case disjoin @row1 @row234 row of
679− (row1, row234) -> do
804+-- (row1, row234) -> do
680− hask1 <- fromRow row1
805+-- hask1 <- fromRow row1
681− (hask2, hask3, hask4) <- fromRow row234
806+-- (hask2, hask3, hask4) <- fromRow row234
682− return (hask1, hask2, hask3, hask4)
807+-- return (hask1, hask2, hask3, hask4)
683−instance
808+-- instance
684− ( row ~ Join row1 row2345
809+-- ( row ~ Join row1 row2345
685− , FromRow row1 hask1
810+-- , FromRow row1 hask1
686− , FromRow row2345 (hask2, hask3, hask4, hask5)
811+-- , FromRow row2345 (hask2, hask3, hask4, hask5)
687− , SListI row
812+-- , SListI row
688− ) => FromRow row (hask1, hask2, hask3, hask4, hask5) where
813+-- ) => FromRow row (hask1, hask2, hask3, hask4, hask5) where
689− fromRow row = case disjoin @row1 @row2345 row of
814+-- fromRow row = case disjoin @row1 @row2345 row of
690− (row1, row2345) -> do
815+-- (row1, row2345) -> do
691− hask1 <- fromRow row1
816+-- hask1 <- fromRow row1
692− (hask2, hask3, hask4, hask5) <- fromRow row2345
817+-- (hask2, hask3, hask4, hask5) <- fromRow row2345
693− return (hask1, hask2, hask3, hask4, hask5)
818+-- return (hask1, hask2, hask3, hask4, hask5)
694
819
695-- | `Only` is a 1-tuple type, useful for encoding a single parameter with
820-- | `Only` is a 1-tuple type, useful for encoding a single parameter with
696-- `toParams` or decoding a single value with `fromRow`.
821-- `toParams` or decoding a single value with `fromRow`.
@@ -719,254 +844,5 @@ replicateMN
719replicateMN mx = hsequence' $
844replicateMN mx = hsequence' $
720 hcpure (Proxy :: Proxy ((~) x)) (Comp (I <$> mx))
845 hcpure (Proxy :: Proxy ((~) x)) (Comp (I <$> mx))
721
846
722−{- | The `Money` newtype stores a monetary value in terms
847+getOid :: LibPQ.Oid -> Word32
723−of the number of cents, i.e. @$2,000.20@ would be expressed as
848+getOid (LibPQ.Oid (CUInt oid)) = oid
724−@Money { cents = 200020 }@.
725−
726−>>> import Control.Monad (void)
727−>>> import Control.Monad.Base (liftBase)
728−>>> import Squeal.PostgreSQL
729−>>> :{
730−let
731− roundTrip :: Query_ (Public '[]) (Only Money) (Only Money)
732− roundTrip = values_ $ parameter @1 money `as` #fromOnly
733−:}
734−
735−>>> let input = Only (Money 20020)
736−
737−>>> :{
738−void . withConnection "host=localhost port=5432 dbname=exampledb" $ do
739− result <- runQueryParams roundTrip input
740− Just output <- firstRow result
741− liftBase . print $ input == output
742−:}
743−True
744−-}
745−newtype Money = Money { cents :: Int64 }
746− deriving (Eq, Ord, Show, Read, GHC.Generic)
747−type instance PG Money = 'PGmoney
748−
749−{- | The `Json` newtype is an indication that the Haskell
750−type it's applied to should be stored as a `PGjson`.
751−-}
752−newtype Json hask = Json {getJson :: hask}
753− deriving (Eq, Ord, Show, Read, GHC.Generic)
754−type instance PG (Json hask) = 'PGjson
755−
756−{- | The `Jsonb` newtype is an indication that the Haskell
757−type it's applied to should be stored as a `PGjsonb`.
758−-}
759−newtype Jsonb hask = Jsonb {getJsonb :: hask}
760− deriving (Eq, Ord, Show, Read, GHC.Generic)
761−type instance PG (Jsonb hask) = 'PGjsonb
762−
763−{- | The `Composite` newtype is an indication that the Haskell
764−type it's applied to should be stored as a `PGcomposite`.
765−-}
766−newtype Composite record = Composite {getComposite :: record}
767− deriving (Eq, Ord, Show, Read, GHC.Generic)
768−type instance PG (Composite hask) = 'PGcomposite (RowPG hask)
769−
770−{- | The `Enumerated` newtype is an indication that the Haskell
771−type it's applied to should be stored as a `PGenum`.
772−-}
773−newtype Enumerated enum = Enumerated {getEnumerated :: enum}
774− deriving (Eq, Ord, Show, Read, GHC.Generic)
775−type instance PG (Enumerated hask) = 'PGenum (LabelsPG hask)
776−
777−{- | The `VarArray` newtype is an indication that the Haskell
778−type it's applied to should be stored as a `PGvararray`.
779−-}
780−newtype VarArray arr = VarArray {getVarArray :: arr}
781− deriving (Eq, Ord, Show, Read, GHC.Generic)
782−type instance PG (VarArray (Vector hask)) = 'PGvararray (NullPG hask)
783−
784−{- | The `FixArray` newtype is an indication that the Haskell
785−type it's applied to should be stored as a `PGfixarray`.
786−-}
787−newtype FixArray arr = FixArray {getFixArray :: arr}
788− deriving (Eq, Ord, Show, Read, GHC.Generic)
789−type instance PG (FixArray x) = 'PGfixarray (DimPG x) (FixPG x)
790−
791−type family DimPG (hask :: Type) :: [Nat] where
792− DimPG (x,x) = 2 ': DimPG x
793− DimPG (x,x,x) = 3 ': DimPG x
794− DimPG (x,x,x,x) = 4 ': DimPG x
795− DimPG (x,x,x,x,x) = 5 ': DimPG x
796− DimPG (x,x,x,x,x,x) = 6 ': DimPG x
797− DimPG (x,x,x,x,x,x,x) = 7 ': DimPG x
798− DimPG (x,x,x,x,x,x,x,x) = 8 ': DimPG x
799− DimPG (x,x,x,x,x,x,x,x,x) = 9 ': DimPG x
800− DimPG (x,x,x,x,x,x,x,x,x,x) = 10 ': DimPG x
801− DimPG x = '[]
802−
803−type family FixPG (hask :: Type) :: NullityType where
804− FixPG (x,x) = FixPG x
805− FixPG (x,x,x) = FixPG x
806− FixPG (x,x,x,x) = FixPG x
807− FixPG (x,x,x,x,x) = FixPG x
808− FixPG (x,x,x,x,x,x) = FixPG x
809− FixPG (x,x,x,x,x,x,x) = FixPG x
810− FixPG (x,x,x,x,x,x,x,x) = FixPG x
811− FixPG (x,x,x,x,x,x,x,x,x) = FixPG x
812− FixPG (x,x,x,x,x,x,x,x,x,x) = FixPG x
813− FixPG (x,x,x,x,x,x,x,x,x,x,x) = FixPG x
814− FixPG x = NullPG x
815−
816−{- | The `PG` type family embeds a subset of Haskell types
817−as Postgres types. As an open type family, `PG` is extensible.
818−
819−>>> :kind! PG LocalTime
820−PG LocalTime :: PGType
821−= 'PGtimestamp
822−
823−>>> newtype MyDouble = My Double
824−>>> :set -XTypeFamilies
825−>>> type instance PG MyDouble = 'PGfloat8
826−-}
827−type family PG (hask :: Type) :: PGType
828−type instance PG Bool = 'PGbool
829−type instance PG Int16 = 'PGint2
830−type instance PG Int32 = 'PGint4
831−type instance PG Int64 = 'PGint8
832−type instance PG Word16 = 'PGint2
833−type instance PG Word32 = 'PGint4
834−type instance PG Word64 = 'PGint8
835−type instance PG Scientific = 'PGnumeric
836−type instance PG Float = 'PGfloat4
837−type instance PG Double = 'PGfloat8
838−type instance PG Char = 'PGchar 1
839−type instance PG Text = 'PGtext
840−type instance PG Lazy.Text = 'PGtext
841−type instance PG String = 'PGtext
842−type instance PG ByteString = 'PGbytea
843−type instance PG Lazy.ByteString = 'PGbytea
844−type instance PG LocalTime = 'PGtimestamp
845−type instance PG UTCTime = 'PGtimestamptz
846−type instance PG Day = 'PGdate
847−type instance PG TimeOfDay = 'PGtime
848−type instance PG (TimeOfDay, TimeZone) = 'PGtimetz
849−type instance PG DiffTime = 'PGinterval
850−type instance PG UUID = 'PGuuid
851−type instance PG (NetAddr IP) = 'PGinet
852−type instance PG Value = 'PGjson
853−
854−{-| The `LabelsPG` type family calculates the constructors of a
855−Haskell enum type.
856−
857−>>> data Schwarma = Beef | Lamb | Chicken deriving GHC.Generic
858−>>> instance Generic Schwarma
859−>>> instance HasDatatypeInfo Schwarma
860−>>> :kind! LabelsPG Schwarma
861−LabelsPG Schwarma :: [Type.ConstructorName]
862−= '["Beef", "Lamb", "Chicken"]
863−-}
864−type family LabelsPG (hask :: Type) :: [Type.ConstructorName] where
865− LabelsPG hask =
866− ConstructorNamesOf (ConstructorsOf (DatatypeInfoOf hask))
867−
868−{- | `RowPG` turns a Haskell record type into a `RowType`.
869−
870−>>> data Person = Person { name :: Text, age :: Int32 } deriving GHC.Generic
871−>>> instance Generic Person
872−>>> instance HasDatatypeInfo Person
873−>>> :kind! RowPG Person
874−RowPG Person :: [(Symbol, NullityType)]
875−= '["name" ::: 'NotNull 'PGtext, "age" ::: 'NotNull 'PGint4]
876−-}
877−type family RowPG (hask :: Type) :: RowType where
878− RowPG (hask1, hask2) = Join (RowPG hask1) (RowPG hask2)
879− RowPG (hask1, hask2, hask3) =
880− Join (RowPG hask1) (RowPG (hask2, hask3))
881− RowPG (hask1, hask2, hask3, hask4) =
882− Join (RowPG hask1) (RowPG (hask2, hask3, hask4))
883− RowPG (hask1, hask2, hask3, hask4, hask5) =
884− Join (RowPG hask1) (RowPG (hask2, hask3, hask4, hask5))
885− RowPG (P (col ::: head)) = '[col ::: NullPG head]
886− RowPG hask = RowOf (RecordCodeOf hask)
887−
888−type family RowOf (record :: [(Symbol, Type)]) :: RowType where
889− RowOf '[] = '[]
890− RowOf (col ::: ty ': record) = col ::: NullPG ty ': RowOf record
891−
892−{- | `NullPG` turns a Haskell type into a `NullityType`.
893−
894−>>> :kind! NullPG Double
895−NullPG Double :: NullityType
896−= 'NotNull 'PGfloat8
897−>>> :kind! NullPG (Maybe Double)
898−NullPG (Maybe Double) :: NullityType
899−= 'Null 'PGfloat8
900−-}
901−type family NullPG (hask :: Type) :: NullityType where
902− NullPG (Maybe hask) = 'Null (PG hask)
903− NullPG hask = 'NotNull (PG hask)
904−
905−{- | `TuplePG` turns a Haskell tuple type (including record types) into
906−the corresponding list of `NullityType`s.
907−
908−>>> :kind! TuplePG (Double, Maybe Char)
909−TuplePG (Double, Maybe Char) :: [NullityType]
910−= '[ 'NotNull 'PGfloat8, 'Null ('PGchar 1)]
911−-}
912−type family TuplePG (hask :: Type) :: [NullityType] where
913− TuplePG hask = TupleOf (TupleCodeOf hask (Code hask))
914−
915−type family TupleOf (tuple :: [Type]) :: [NullityType] where
916− TupleOf '[] = '[]
917− TupleOf (hask ': tuple) = NullPG hask ': TupleOf tuple
918−
919−type family TupleCodeOf (hask :: Type) (code :: [[Type]]) :: [Type] where
920− TupleCodeOf hask '[tuple] = tuple
921− TupleCodeOf hask '[] =
922− TypeError
923− ( 'Text "The type `" ':<>: 'ShowType hask ':<>: 'Text "' is not a tuple type."
924− ':$$: 'Text "It is a void type with no constructors."
925− )
926− TupleCodeOf hask (_ ': _ ': _) =
927− TypeError
928− ( 'Text "The type `" ':<>: 'ShowType hask ':<>: 'Text "' is not a tuple type."
929− ':$$: 'Text "It is a sum type with more than one constructor."
930− )
931−
932−-- | Calculates constructors of a datatype.
933−type family ConstructorsOf (datatype :: Type.DatatypeInfo)
934− :: [Type.ConstructorInfo] where
935− ConstructorsOf ('Type.ADT _module _datatype constructors) =
936− constructors
937− ConstructorsOf ('Type.Newtype _module _datatype constructor) =
938− '[constructor]
939−
940−-- | Calculates the name of a nullary constructor, otherwise
941−-- generates a type error.
942−type family ConstructorNameOf (constructors :: Type.ConstructorInfo)
943− :: Type.ConstructorName where
944− ConstructorNameOf ('Type.Constructor name) = name
945− ConstructorNameOf ('Type.Infix name _assoc _fix) = TypeError
946− ('Text "ConstructorNameOf error: non-nullary constructor "
947− ':<>: 'Text name)
948− ConstructorNameOf ('Type.Record name _fields) = TypeError
949− ('Text "ConstructorNameOf error: non-nullary constructor "
950− ':<>: 'Text name)
951−
952−-- | Calculate the names of nullary constructors.
953−type family ConstructorNamesOf (constructors :: [Type.ConstructorInfo])
954− :: [Type.ConstructorName] where
955− ConstructorNamesOf '[] = '[]
956− ConstructorNamesOf (constructor ': constructors) =
957− ConstructorNameOf constructor ': ConstructorNamesOf constructors
958−
959−type family FromPG (hask :: Type) :: FromType where
960− FromPG (hask1, hask2) = Join (FromPG hask1) (FromPG hask2)
961− FromPG (hask1, hask2, hask3) =
962− Join (FromPG hask1) (FromPG (hask2, hask3))
963− FromPG (hask1, hask2, hask3, hask4) =
964− Join (FromPG hask1) (FromPG (hask2, hask3, hask4))
965− FromPG (hask1, hask2, hask3, hask4, hask5) =
966− Join (FromPG hask1) (FromPG (hask2, hask3, hask4, hask5))
967− FromPG (P (col ::: hask)) = '[col ::: RowPG hask]
968− FromPG hask = FromOf (RecordCodeOf hask)
969−
970−type family FromOf (record :: [(Symbol, Type)]) :: FromType where
971− FromOf '[] = '[]
972− FromOf (tab ::: ty ': record) = tab ::: RowPG ty ': FromOf record
squeal-postgresql/src/Squeal/PostgreSQL/Definition.hs+15−1012
@@ -11,13 +11,15 @@ Squeal data definition language.
11{-# LANGUAGE
11{-# LANGUAGE
12 AllowAmbiguousTypes
12 AllowAmbiguousTypes
13 , ConstraintKinds
13 , ConstraintKinds
14+ , DeriveAnyClass
14 , DeriveGeneric
15 , DeriveGeneric
16+ , DerivingStrategies
15 , FlexibleContexts
17 , FlexibleContexts
16 , FlexibleInstances
18 , FlexibleInstances
17 , GADTs
19 , GADTs
18− , GeneralizedNewtypeDeriving
19 , LambdaCase
20 , LambdaCase
20 , MultiParamTypeClasses
21 , MultiParamTypeClasses
22+ , OverloadedLabels
21 , OverloadedStrings
23 , OverloadedStrings
22 , RankNTypes
24 , RankNTypes
23 , ScopedTypeVariables
25 , ScopedTypeVariables
@@ -25,82 +27,31 @@ Squeal data definition language.
25 , TypeInType
27 , TypeInType
26 , TypeOperators
28 , TypeOperators
27 , UndecidableSuperClasses
29 , UndecidableSuperClasses
30+ , UndecidableInstances
28#-}
31#-}
29
32
30module Squeal.PostgreSQL.Definition
33module Squeal.PostgreSQL.Definition
31 ( -- * Definition
34 ( -- * Definition
32 Definition (..)
35 Definition (..)
33 , (>>>)
36 , (>>>)
34− -- * Tables
37+ , manipDefinition
35− -- ** Create
36− , createSchema
37− , createSchemaIfNotExists
38− , createTable
39− , createTableIfNotExists
40− , createView
41− , createTypeEnum
42− , createTypeEnumFrom
43− , createTypeComposite
44− , createTypeCompositeFrom
45− , createDomain
46− , TableConstraintExpression (..)
47− , check
48− , unique
49− , primaryKey
50− , foreignKey
51− , ForeignKeyed
52− , OnDeleteClause (..)
53− , OnUpdateClause (..)
54− -- ** Drop
55− , dropSchema
56− , dropTable
57− , dropView
58− , dropType
59− -- ** Alter
60− , alterTable
61− , alterTableRename
62− , AlterTable (..)
63− , addConstraint
64− , dropConstraint
65− , AddColumn (..)
66− , dropColumn
67− , renameColumn
68− , alterColumn
69− , AlterColumn (..)
70− , setDefault
71− , dropDefault
72− , setNotNull
73− , dropNotNull
74− , alterType
75− -- * Columns
76− , ColumnTypeExpression (..)
77− , nullable
78− , notNullable
79− , default_
80− , serial2
81− , smallserial
82− , serial4
83− , serial
84− , serial8
85− , bigserial
86 ) where
38 ) where
87
39
88import Control.Category
40import Control.Category
89import Control.DeepSeq
41import Control.DeepSeq
90import Data.ByteString
42import Data.ByteString
91import Data.Monoid
43import Data.Monoid
92−import GHC.TypeLits
93import Prelude hiding ((.), id)
44import Prelude hiding ((.), id)
94
45
95−import qualified Generics.SOP as SOP
96import qualified GHC.Generics as GHC
46import qualified GHC.Generics as GHC
97
47
98−import Squeal.PostgreSQL.Binary
48+import Squeal.PostgreSQL.Manipulation
99−import Squeal.PostgreSQL.Expression
100−import Squeal.PostgreSQL.Query
101import Squeal.PostgreSQL.Render
49import Squeal.PostgreSQL.Render
102import Squeal.PostgreSQL.Schema
50import Squeal.PostgreSQL.Schema
103
51
52+-- $setup
53+-- >>> import Squeal.PostgreSQL
54+
104{-----------------------------------------
55{-----------------------------------------
105statements
56statements
106-----------------------------------------}
57-----------------------------------------}
@@ -122,958 +73,10 @@ instance Category Definition where
122 ddl1 . ddl0 = UnsafeDefinition $
73 ddl1 . ddl0 = UnsafeDefinition $
123 renderSQL ddl0 <> "\n" <> renderSQL ddl1
74 renderSQL ddl0 <> "\n" <> renderSQL ddl1
124
75
125−{-----------------------------------------
76+-- | A `Manipulation` without input or output can be run as a statement
126−CREATE statements
77+-- along with other `Definition`s, by embedding it using `manipDefinition`.
127−-----------------------------------------}
78+manipDefinition
128−
79+ :: Manipulation '[] schemas '[] '[]
129−createSchema
80+ -- ^ no input or output
130− :: KnownSymbol sch
131− => Alias sch
132− -> Definition schemas (Create sch '[] schemas)
133−createSchema sch = UnsafeDefinition $
134− "CREATE" <+> "SCHEMA" <+> renderSQL sch <> ";"
135−
136−createSchemaIfNotExists
137− :: (KnownSymbol sch, Has sch schemas schema)
138− => Alias sch
139 -> Definition schemas schemas
81 -> Definition schemas schemas
140−createSchemaIfNotExists sch = UnsafeDefinition $
82+manipDefinition = UnsafeDefinition . (<> ";") . renderSQL
141− "CREATE" <+> "SCHEMA" <+> "IF" <+> "NOT" <+> "EXISTS"
142− <+> renderSQL sch <> ";"
143−
144−{- | `createTable` adds a table to the schema.
145−
146−>>> :set -XOverloadedLabels
147−>>> :{
148−type Table = '[] :=>
149− '[ "a" ::: 'NoDef :=> 'Null 'PGint4
150− , "b" ::: 'NoDef :=> 'Null 'PGfloat4 ]
151−:}
152−
153−>>> :{
154−let
155− setup :: Definition (Public '[]) (Public '["tab" ::: 'Table Table])
156− setup = createTable #tab
157− (nullable int `as` #a :* nullable real `as` #b) Nil
158−in printSQL setup
159−:}
160−CREATE TABLE "tab" ("a" int NULL, "b" real NULL);
161−-}
162−createTable
163− :: ( KnownSymbol sch
164− , KnownSymbol tab
165− , columns ~ (col ': cols)
166− , SOP.SListI columns
167− , SOP.SListI constraints
168− , Has sch schemas0 schema0
169− , schemas1 ~ Alter sch (Create tab ('Table (constraints :=> columns)) schema0) schemas0 )
170− => QualifiedAlias sch tab -- ^ the name of the table to add
171− -> NP (Aliased (ColumnTypeExpression schemas0)) columns
172− -- ^ the names and datatype of each column
173− -> NP (Aliased (TableConstraintExpression sch tab schemas1)) constraints
174− -- ^ constraints that must hold for the table
175− -> Definition schemas0 schemas1
176−createTable tab columns constraints = UnsafeDefinition $
177− "CREATE TABLE" <+> renderCreation tab columns constraints
178−
179−{-| `createTableIfNotExists` creates a table if it doesn't exist, but does not add it to the schema.
180−Instead, the schema already has the table so if the table did not yet exist, the schema was wrong.
181−`createTableIfNotExists` fixes this. Interestingly, this property makes it an idempotent in
182−the `Category` of `Definition`s.
183−
184−>>> :set -XOverloadedLabels -XTypeApplications
185−>>> :{
186−type Table = '[] :=>
187− '[ "a" ::: 'NoDef :=> 'Null 'PGint4
188− , "b" ::: 'NoDef :=> 'Null 'PGfloat4 ]
189−:}
190−
191−>>> type Schemas = Public '["tab" ::: 'Table Table]
192−
193−>>> :{
194−let
195− setup :: Definition Schemas Schemas
196− setup = createTableIfNotExists #tab
197− (nullable int `as` #a :* nullable real `as` #b) Nil
198−in printSQL setup
199−:}
200−CREATE TABLE IF NOT EXISTS "tab" ("a" int NULL, "b" real NULL);
201−-}
202−createTableIfNotExists
203− :: ( Has sch schemas schema
204− , Has tab schema ('Table (constraints :=> columns))
205− , SOP.SListI columns
206− , SOP.SListI constraints )
207− => QualifiedAlias sch tab -- ^ the name of the table to add
208− -> NP (Aliased (ColumnTypeExpression schemas)) columns
209− -- ^ the names and datatype of each column
210− -> NP (Aliased (TableConstraintExpression sch tab schemas)) constraints
211− -- ^ constraints that must hold for the table
212− -> Definition schemas schemas
213−createTableIfNotExists tab columns constraints = UnsafeDefinition $
214− "CREATE TABLE IF NOT EXISTS"
215− <+> renderCreation tab columns constraints
216−
217−-- helper function for `createTable` and `createTableIfNotExists`
218−renderCreation
219− :: ( KnownSymbol sch
220− , KnownSymbol tab
221− , SOP.SListI columns
222− , SOP.SListI constraints )
223− => QualifiedAlias sch tab -- ^ the name of the table to add
224− -> NP (Aliased (ColumnTypeExpression schemas0)) columns
225− -- ^ the names and datatype of each column
226− -> NP (Aliased (TableConstraintExpression sch tab schemas1)) constraints
227− -- ^ constraints that must hold for the table
228− -> ByteString
229−renderCreation tab columns constraints = renderSQL tab
230− <+> parenthesized
231− ( renderCommaSeparated renderColumnDef columns
232− <> ( case constraints of
233− Nil -> ""
234− _ -> ", " <>
235− renderCommaSeparated renderConstraint constraints ) )
236− <> ";"
237− where
238− renderColumnDef :: Aliased (ColumnTypeExpression schemas) x -> ByteString
239− renderColumnDef (ty `As` column) =
240− renderSQL column <+> renderColumnTypeExpression ty
241− renderConstraint
242− :: Aliased (TableConstraintExpression sch tab schemas) constraint
243− -> ByteString
244− renderConstraint (constraint `As` alias) =
245− "CONSTRAINT" <+> renderSQL alias <+> renderSQL constraint
246−
247−-- | Data types are a way to limit the kind of data that can be stored in a
248−-- table. For many applications, however, the constraint they provide is
249−-- too coarse. For example, a column containing a product price should
250−-- probably only accept positive values. But there is no standard data type
251−-- that accepts only positive numbers. Another issue is that you might want
252−-- to constrain column data with respect to other columns or rows.
253−-- For example, in a table containing product information,
254−-- there should be only one row for each product number.
255−-- `TableConstraint`s give you as much control over the data in your tables
256−-- as you wish. If a user attempts to store data in a column that would
257−-- violate a constraint, an error is raised. This applies
258−-- even if the value came from the default value definition.
259−newtype TableConstraintExpression
260− (sch :: Symbol)
261− (tab :: Symbol)
262− (schemas :: SchemasType)
263− (constraint :: TableConstraint)
264− = UnsafeTableConstraintExpression
265− { renderTableConstraintExpression :: ByteString }
266− deriving (GHC.Generic,Show,Eq,Ord,NFData)
267−instance RenderSQL
268− (TableConstraintExpression sch tab schemas constraint) where
269− renderSQL = renderTableConstraintExpression
270−
271−{-| A `check` constraint is the most generic `TableConstraint` type.
272−It allows you to specify that the value in a certain column must satisfy
273−a Boolean (truth-value) expression.
274−
275−>>> :{
276−type Schema = '[
277− "tab" ::: 'Table ('[ "inequality" ::: 'Check '["a","b"]] :=> '[
278− "a" ::: 'NoDef :=> 'NotNull 'PGint4,
279− "b" ::: 'NoDef :=> 'NotNull 'PGint4
280− ])]
281−:}
282−
283−>>> :{
284−let
285− definition :: Definition (Public '[]) (Public Schema)
286− definition = createTable #tab
287− ( (int & notNullable) `as` #a :*
288− (int & notNullable) `as` #b )
289− ( check (#a :* #b) (#a .> #b) `as` #inequality )
290−:}
291−
292−>>> printSQL definition
293−CREATE TABLE "tab" ("a" int NOT NULL, "b" int NOT NULL, CONSTRAINT "inequality" CHECK (("a" > "b")));
294−-}
295−check
296− :: ( Has sch schemas schema
297− , Has tab schema ('Table table)
298− , HasAll aliases (TableToRow table) subcolumns )
299− => NP Alias aliases
300− -- ^ specify the subcolumns which are getting checked
301− -> (forall t. Condition '[] 'Ungrouped '[] schemas '[] '[t ::: subcolumns])
302− -- ^ a closed `Condition` on those subcolumns
303− -> TableConstraintExpression sch tab schemas ('Check aliases)
304−check _cols condition = UnsafeTableConstraintExpression $
305− "CHECK" <+> parenthesized (renderSQL condition)
306−
307−{-| A `unique` constraint ensure that the data contained in a column,
308−or a group of columns, is unique among all the rows in the table.
309−
310−>>> :{
311−type Schema = '[
312− "tab" ::: 'Table( '[ "uq_a_b" ::: 'Unique '["a","b"]] :=> '[
313− "a" ::: 'NoDef :=> 'Null 'PGint4,
314− "b" ::: 'NoDef :=> 'Null 'PGint4
315− ])]
316−:}
317−
318−>>> :{
319−let
320− definition :: Definition (Public '[]) (Public Schema)
321− definition = createTable #tab
322− ( (int & nullable) `as` #a :*
323− (int & nullable) `as` #b )
324− ( unique (#a :* #b) `as` #uq_a_b )
325−:}
326−
327−>>> printSQL definition
328−CREATE TABLE "tab" ("a" int NULL, "b" int NULL, CONSTRAINT "uq_a_b" UNIQUE ("a", "b"));
329−-}
330−unique
331− :: ( Has sch schemas schema
332− , Has tab schema('Table table)
333− , HasAll aliases (TableToRow table) subcolumns )
334− => NP Alias aliases
335− -- ^ specify subcolumns which together are unique for each row
336− -> TableConstraintExpression sch tab schemas ('Unique aliases)
337−unique columns = UnsafeTableConstraintExpression $
338− "UNIQUE" <+> parenthesized (renderSQL columns)
339−
340−{-| A `primaryKey` constraint indicates that a column, or group of columns,
341−can be used as a unique identifier for rows in the table.
342−This requires that the values be both unique and not null.
343−
344−>>> :{
345−type Schema = '[
346− "tab" ::: 'Table ('[ "pk_id" ::: 'PrimaryKey '["id"]] :=> '[
347− "id" ::: 'Def :=> 'NotNull 'PGint4,
348− "name" ::: 'NoDef :=> 'NotNull 'PGtext
349− ])]
350−:}
351−
352−>>> :{
353−let
354− definition :: Definition (Public '[]) (Public Schema)
355− definition = createTable #tab
356− ( serial `as` #id :*
357− (text & notNullable) `as` #name )
358− ( primaryKey #id `as` #pk_id )
359−:}
360−
361−>>> printSQL definition
362−CREATE TABLE "tab" ("id" serial, "name" text NOT NULL, CONSTRAINT "pk_id" PRIMARY KEY ("id"));
363−-}
364−primaryKey
365− :: ( Has sch schemas schema
366− , Has tab schema ('Table table)
367− , HasAll aliases (TableToColumns table) subcolumns
368− , AllNotNull subcolumns )
369− => NP Alias aliases
370− -- ^ specify the subcolumns which together form a primary key.
371− -> TableConstraintExpression sch tab schemas ('PrimaryKey aliases)
372−primaryKey columns = UnsafeTableConstraintExpression $
373− "PRIMARY KEY" <+> parenthesized (renderSQL columns)
374−
375−{-| A `foreignKey` specifies that the values in a column
376−(or a group of columns) must match the values appearing in some row of
377−another table. We say this maintains the referential integrity
378−between two related tables.
379−
380−>>> :{
381−type Schema =
382− '[ "users" ::: 'Table (
383− '[ "pk_users" ::: 'PrimaryKey '["id"] ] :=>
384− '[ "id" ::: 'Def :=> 'NotNull 'PGint4
385− , "name" ::: 'NoDef :=> 'NotNull 'PGtext
386− ])
387− , "emails" ::: 'Table (
388− '[ "pk_emails" ::: 'PrimaryKey '["id"]
389− , "fk_user_id" ::: 'ForeignKey '["user_id"] "users" '["id"]
390− ] :=>
391− '[ "id" ::: 'Def :=> 'NotNull 'PGint4
392− , "user_id" ::: 'NoDef :=> 'NotNull 'PGint4
393− , "email" ::: 'NoDef :=> 'Null 'PGtext
394− ])
395− ]
396−:}
397−
398−>>> :{
399−let
400− setup :: Definition (Public '[]) (Public Schema)
401− setup =
402− createTable #users
403− ( serial `as` #id :*
404− (text & notNullable) `as` #name )
405− ( primaryKey #id `as` #pk_users ) >>>
406− createTable #emails
407− ( serial `as` #id :*
408− (int & notNullable) `as` #user_id :*
409− (text & nullable) `as` #email )
410− ( primaryKey #id `as` #pk_emails :*
411− foreignKey #user_id #users #id
412− OnDeleteCascade OnUpdateCascade `as` #fk_user_id )
413−in printSQL setup
414−:}
415−CREATE TABLE "users" ("id" serial, "name" text NOT NULL, CONSTRAINT "pk_users" PRIMARY KEY ("id"));
416−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);
417−
418−A `foreignKey` can even be a table self-reference.
419−
420−>>> :{
421−type Schema =
422− '[ "employees" ::: 'Table (
423− '[ "employees_pk" ::: 'PrimaryKey '["id"]
424− , "employees_employer_fk" ::: 'ForeignKey '["employer_id"] "employees" '["id"]
425− ] :=>
426− '[ "id" ::: 'Def :=> 'NotNull 'PGint4
427− , "name" ::: 'NoDef :=> 'NotNull 'PGtext
428− , "employer_id" ::: 'NoDef :=> 'Null 'PGint4
429− ])
430− ]
431−:}
432−
433−>>> :{
434−let
435− setup :: Definition (Public '[]) (Public Schema)
436− setup =
437− createTable #employees
438− ( serial `as` #id :*
439− (text & notNullable) `as` #name :*
440− (integer & nullable) `as` #employer_id )
441− ( primaryKey #id `as` #employees_pk :*
442− foreignKey #employer_id #employees #id
443− OnDeleteCascade OnUpdateCascade `as` #employees_employer_fk )
444−in printSQL setup
445−:}
446−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);
447−-}
448−foreignKey
449− :: (ForeignKeyed schemas sch schema child parent
450− table reftable
451− columns refcolumns
452− constraints cols
453− reftys tys )
454− => NP Alias columns
455− -- ^ column or columns in the table
456− -> Alias parent
457− -- ^ reference table
458− -> NP Alias refcolumns
459− -- ^ reference column or columns in the reference table
460− -> OnDeleteClause
461− -- ^ what to do when reference is deleted
462− -> OnUpdateClause
463− -- ^ what to do when reference is updated
464− -> TableConstraintExpression sch child schemas
465− ('ForeignKey columns parent refcolumns)
466−foreignKey keys parent refs ondel onupd = UnsafeTableConstraintExpression $
467− "FOREIGN KEY" <+> parenthesized (renderSQL keys)
468− <+> "REFERENCES" <+> renderSQL parent
469− <+> parenthesized (renderSQL refs)
470− <+> renderSQL ondel
471− <+> renderSQL onupd
472−
473−-- | A constraint synonym between types involved in a foreign key constraint.
474−type ForeignKeyed schemas
475− sch
476− schema
477− child parent
478− table reftable
479− columns refcolumns
480− constraints cols
481− reftys tys =
482− ( Has sch schemas schema
483− , Has child schema ('Table table)
484− , Has parent schema ('Table reftable)
485− , HasAll columns (TableToColumns table) tys
486− , reftable ~ (constraints :=> cols)
487− , HasAll refcolumns cols reftys
488− , SOP.AllZip SamePGType tys reftys
489− , Uniquely refcolumns constraints )
490−
491−-- | `OnDeleteClause` indicates what to do with rows that reference a deleted row.
492−data OnDeleteClause
493− = OnDeleteNoAction
494− -- ^ if any referencing rows still exist when the constraint is checked,
495− -- an error is raised
496− | OnDeleteRestrict -- ^ prevents deletion of a referenced row
497− | OnDeleteCascade
498− -- ^ specifies that when a referenced row is deleted,
499− -- row(s) referencing it should be automatically deleted as well
500− deriving (GHC.Generic,Show,Eq,Ord)
501−instance NFData OnDeleteClause
502−-- | Render `OnDeleteClause`.
503−instance RenderSQL OnDeleteClause where
504− renderSQL = \case
505− OnDeleteNoAction -> "ON DELETE NO ACTION"
506− OnDeleteRestrict -> "ON DELETE RESTRICT"
507− OnDeleteCascade -> "ON DELETE CASCADE"
508−
509−-- | Analagous to `OnDeleteClause` there is also `OnUpdateClause` which is invoked
510−-- when a referenced column is changed (updated).
511−data OnUpdateClause
512− = OnUpdateNoAction
513− -- ^ if any referencing rows has not changed when the constraint is checked,
514− -- an error is raised
515− | OnUpdateRestrict -- ^ prevents update of a referenced row
516− | OnUpdateCascade
517− -- ^ the updated values of the referenced column(s) should be copied
518− -- into the referencing row(s)
519− deriving (GHC.Generic,Show,Eq,Ord)
520−instance NFData OnUpdateClause
521−
522−-- | Render `OnUpdateClause`.
523−instance RenderSQL OnUpdateClause where
524− renderSQL = \case
525− OnUpdateNoAction -> "ON UPDATE NO ACTION"
526− OnUpdateRestrict -> "ON UPDATE RESTRICT"
527− OnUpdateCascade -> "ON UPDATE CASCADE"
528−
529−{-----------------------------------------
530−DROP statements
531−-----------------------------------------}
532−
533−-- >>> :{
534−-- let
535−-- definition :: Definition '["muh_schema" ::: schema, "public" ::: public] '["public" ::: public]
536−-- definition = dropSchema #muh_schema
537−-- :}
538−--
539−-- >>> printSQL definition
540−-- DROP SCHEMA "muh_schema";
541−dropSchema
542− :: Has sch schemas schema
543− => Alias sch
544− -> Definition schemas (Drop sch schemas)
545−dropSchema sch = UnsafeDefinition $ "DROP SCHEMA" <+> renderSQL sch <> ";"
546−
547−-- | `dropTable` removes a table from the schema.
548−--
549−-- >>> :{
550−-- let
551−-- definition :: Definition '["public" ::: '["muh_table" ::: 'Table t]] (Public '[])
552−-- definition = dropTable #muh_table
553−-- :}
554−--
555−-- >>> printSQL definition
556−-- DROP TABLE "muh_table";
557−dropTable
558− :: ( Has sch schemas schema
559− , Has tab schema ('Table table))
560− => QualifiedAlias sch tab -- ^ table to remove
561− -> Definition schemas (Alter sch (Drop tab schema) schemas)
562−dropTable tab = UnsafeDefinition $ "DROP TABLE" <+> renderSQL tab <> ";"
563−
564−{-----------------------------------------
565−ALTER statements
566−-----------------------------------------}
567−
568−-- | `alterTable` changes the definition of a table from the schema.
569−alterTable
570− :: (Has sch schemas schema, Has tab schema ('Table table0))
571− => QualifiedAlias sch tab -- ^ table to alter
572− -> AlterTable sch tab schemas table1 -- ^ alteration to perform
573− -> Definition schemas (Alter sch (Alter tab ('Table table1) schema) schemas)
574−alterTable tab alteration = UnsafeDefinition $
575− "ALTER TABLE"
576− <+> renderSQL tab
577− <+> renderAlterTable alteration
578− <> ";"
579−
580−-- | `alterTableRename` changes the name of a table from the schema.
581−--
582−-- >>> printSQL $ alterTableRename #foo #bar
583−-- ALTER TABLE "foo" RENAME TO "bar";
584−alterTableRename
585− :: (KnownSymbol table0, KnownSymbol table1)
586− => Alias table0 -- ^ table to rename
587− -> Alias table1 -- ^ what to rename it
588− -> Definition schema (Rename table0 table1 schema)
589−alterTableRename table0 table1 = UnsafeDefinition $
590− "ALTER TABLE" <+> renderSQL table0
591− <+> "RENAME TO" <+> renderSQL table1 <> ";"
592−
593−-- | An `AlterTable` describes the alteration to perform on the columns
594−-- of a table.
595−newtype AlterTable
596− (sch :: Symbol)
597− (tab :: Symbol)
598− (schemas :: SchemasType)
599− (table :: TableType) =
600− UnsafeAlterTable {renderAlterTable :: ByteString}
601− deriving (GHC.Generic,Show,Eq,Ord,NFData)
602−
603−-- | An `addConstraint` adds a table constraint.
604−--
605−-- >>> :{
606−-- let
607−-- definition :: Definition
608−-- '["public" ::: '["tab" ::: 'Table ('[] :=> '["col" ::: 'NoDef :=> 'NotNull 'PGint4])]]
609−-- '["public" ::: '["tab" ::: 'Table ('["positive" ::: 'Check '["col"]] :=> '["col" ::: 'NoDef :=> 'NotNull 'PGint4])]]
610−-- definition = alterTable #tab (addConstraint #positive (check #col (#col .> 0)))
611−-- in printSQL definition
612−-- :}
613−-- ALTER TABLE "tab" ADD CONSTRAINT "positive" CHECK (("col" > 0));
614−addConstraint
615− :: ( KnownSymbol alias
616− , Has sch schemas schema
617− , Has tab schema ('Table table0)
618− , table0 ~ (constraints :=> columns)
619− , table1 ~ (Create alias constraint constraints :=> columns) )
620− => Alias alias
621− -> TableConstraintExpression sch tab schemas constraint
622− -- ^ constraint to add
623− -> AlterTable sch tab schemas table1
624−addConstraint alias constraint = UnsafeAlterTable $
625− "ADD" <+> "CONSTRAINT" <+> renderSQL alias
626− <+> renderSQL constraint
627−
628−-- | A `dropConstraint` drops a table constraint.
629−--
630−-- >>> :{
631−-- let
632−-- definition :: Definition
633−-- '["public" ::: '["tab" ::: 'Table ('["positive" ::: Check '["col"]] :=> '["col" ::: 'NoDef :=> 'NotNull 'PGint4])]]
634−-- '["public" ::: '["tab" ::: 'Table ('[] :=> '["col" ::: 'NoDef :=> 'NotNull 'PGint4])]]
635−-- definition = alterTable #tab (dropConstraint #positive)
636−-- in printSQL definition
637−-- :}
638−-- ALTER TABLE "tab" DROP CONSTRAINT "positive";
639−dropConstraint
640− :: ( KnownSymbol constraint
641− , Has sch schemas schema
642− , Has tab schema ('Table table0)
643− , table0 ~ (constraints :=> columns)
644− , table1 ~ (Drop constraint constraints :=> columns) )
645− => Alias constraint
646− -- ^ constraint to drop
647− -> AlterTable sch tab schemas table1
648−dropConstraint constraint = UnsafeAlterTable $
649− "DROP" <+> "CONSTRAINT" <+> renderSQL constraint
650−
651−-- | An `AddColumn` is either @NULL@ or has @DEFAULT@.
652−class AddColumn ty where
653− -- | `addColumn` adds a new column, initially filled with whatever
654− -- default value is given or with @NULL@.
655− --
656− -- >>> :{
657− -- let
658− -- definition :: Definition
659− -- '["public" ::: '["tab" ::: 'Table ('[] :=> '["col1" ::: 'NoDef :=> 'Null 'PGint4])]]
660− -- '["public" ::: '["tab" ::: 'Table ('[] :=>
661− -- '[ "col1" ::: 'NoDef :=> 'Null 'PGint4
662− -- , "col2" ::: 'Def :=> 'Null 'PGtext ])]]
663− -- definition = alterTable #tab (addColumn #col2 (text & nullable & default_ "foo"))
664− -- in printSQL definition
665− -- :}
666− -- ALTER TABLE "tab" ADD COLUMN "col2" text NULL DEFAULT E'foo';
667− --
668− -- >>> :{
669− -- let
670− -- definition :: Definition
671− -- '["public" ::: '["tab" ::: 'Table ('[] :=> '["col1" ::: 'NoDef :=> 'Null 'PGint4])]]
672− -- '["public" ::: '["tab" ::: 'Table ('[] :=>
673− -- '[ "col1" ::: 'NoDef :=> 'Null 'PGint4
674− -- , "col2" ::: 'NoDef :=> 'Null 'PGtext ])]]
675− -- definition = alterTable #tab (addColumn #col2 (text & nullable))
676− -- in printSQL definition
677− -- :}
678− -- ALTER TABLE "tab" ADD COLUMN "col2" text NULL;
679− addColumn
680− :: ( KnownSymbol column
681− , Has sch schemas schema
682− , Has tab schema ('Table table0)
683− , table0 ~ (constraints :=> columns) )
684− => Alias column -- ^ column to add
685− -> ColumnTypeExpression schemas ty -- ^ type of the new column
686− -> AlterTable sch tab schemas (constraints :=> Create column ty columns)
687− addColumn column ty = UnsafeAlterTable $
688− "ADD COLUMN" <+> renderSQL column <+> renderColumnTypeExpression ty
689−instance {-# OVERLAPPING #-} AddColumn ('Def :=> ty)
690−instance {-# OVERLAPPABLE #-} AddColumn ('NoDef :=> 'Null ty)
691−
692−-- | A `dropColumn` removes a column. Whatever data was in the column
693−-- disappears. Table constraints involving the column are dropped, too.
694−-- However, if the column is referenced by a foreign key constraint of
695−-- another table, PostgreSQL will not silently drop that constraint.
696−--
697−-- >>> :{
698−-- let
699−-- definition :: Definition
700−-- '["public" ::: '["tab" ::: 'Table ('[] :=>
701−-- '[ "col1" ::: 'NoDef :=> 'Null 'PGint4
702−-- , "col2" ::: 'NoDef :=> 'Null 'PGtext ])]]
703−-- '["public" ::: '["tab" ::: 'Table ('[] :=> '["col1" ::: 'NoDef :=> 'Null 'PGint4])]]
704−-- definition = alterTable #tab (dropColumn #col2)
705−-- in printSQL definition
706−-- :}
707−-- ALTER TABLE "tab" DROP COLUMN "col2";
708−dropColumn
709− :: ( KnownSymbol column
710− , Has sch schemas schema
711− , Has tab schema ('Table table0)
712− , table0 ~ (constraints :=> columns)
713− , table1 ~ (constraints :=> Drop column columns) )
714− => Alias column -- ^ column to remove
715− -> AlterTable sch tab schemas table1
716−dropColumn column = UnsafeAlterTable $
717− "DROP COLUMN" <+> renderSQL column
718−
719−-- | A `renameColumn` renames a column.
720−--
721−-- >>> :{
722−-- let
723−-- definition :: Definition
724−-- '["public" ::: '["tab" ::: 'Table ('[] :=> '["foo" ::: 'NoDef :=> 'Null 'PGint4])]]
725−-- '["public" ::: '["tab" ::: 'Table ('[] :=> '["bar" ::: 'NoDef :=> 'Null 'PGint4])]]
726−-- definition = alterTable #tab (renameColumn #foo #bar)
727−-- in printSQL definition
728−-- :}
729−-- ALTER TABLE "tab" RENAME COLUMN "foo" TO "bar";
730−renameColumn
731− :: ( KnownSymbol column0
732− , KnownSymbol column1
733− , Has sch schemas schema
734− , Has tab schema ('Table table0)
735− , table0 ~ (constraints :=> columns)
736− , table1 ~ (constraints :=> Rename column0 column1 columns) )
737− => Alias column0 -- ^ column to rename
738− -> Alias column1 -- ^ what to rename the column
739− -> AlterTable sch tab schemas table1
740−renameColumn column0 column1 = UnsafeAlterTable $
741− "RENAME COLUMN" <+> renderSQL column0 <+> "TO" <+> renderSQL column1
742−
743−-- | An `alterColumn` alters a single column.
744−alterColumn
745− :: ( KnownSymbol column
746− , Has sch schemas schema
747− , Has tab schema ('Table table0)
748− , table0 ~ (constraints :=> columns)
749− , Has column columns ty0
750− , table1 ~ (constraints :=> Alter column ty1 columns))
751− => Alias column -- ^ column to alter
752− -> AlterColumn schemas ty0 ty1 -- ^ alteration to perform
753− -> AlterTable sch tab schemas table1
754−alterColumn column alteration = UnsafeAlterTable $
755− "ALTER COLUMN" <+> renderSQL column <+> renderAlterColumn alteration
756−
757−-- | An `AlterColumn` describes the alteration to perform on a single column.
758−newtype AlterColumn (schemas :: SchemasType) (ty0 :: ColumnType) (ty1 :: ColumnType) =
759− UnsafeAlterColumn {renderAlterColumn :: ByteString}
760− deriving (GHC.Generic,Show,Eq,Ord,NFData)
761−
762−-- | A `setDefault` sets a new default for a column. Note that this doesn't
763−-- affect any existing rows in the table, it just changes the default for
764−-- future insert and update commands.
765−--
766−-- >>> :{
767−-- let
768−-- definition :: Definition
769−-- '["public" ::: '["tab" ::: 'Table ('[] :=> '["col" ::: 'NoDef :=> 'Null 'PGint4])]]
770−-- '["public" ::: '["tab" ::: 'Table ('[] :=> '["col" ::: 'Def :=> 'Null 'PGint4])]]
771−-- definition = alterTable #tab (alterColumn #col (setDefault 5))
772−-- in printSQL definition
773−-- :}
774−-- ALTER TABLE "tab" ALTER COLUMN "col" SET DEFAULT 5;
775−setDefault
776− :: Expression '[] 'Ungrouped '[] schemas '[] '[] ty -- ^ default value to set
777− -> AlterColumn schemas (constraint :=> ty) ('Def :=> ty)
778−setDefault expression = UnsafeAlterColumn $
779− "SET DEFAULT" <+> renderExpression expression
780−
781−-- | A `dropDefault` removes any default value for a column.
782−--
783−-- >>> :{
784−-- let
785−-- definition :: Definition
786−-- '["public" ::: '["tab" ::: 'Table ('[] :=> '["col" ::: 'Def :=> 'Null 'PGint4])]]
787−-- '["public" ::: '["tab" ::: 'Table ('[] :=> '["col" ::: 'NoDef :=> 'Null 'PGint4])]]
788−-- definition = alterTable #tab (alterColumn #col dropDefault)
789−-- in printSQL definition
790−-- :}
791−-- ALTER TABLE "tab" ALTER COLUMN "col" DROP DEFAULT;
792−dropDefault :: AlterColumn schemas ('Def :=> ty) ('NoDef :=> ty)
793−dropDefault = UnsafeAlterColumn $ "DROP DEFAULT"
794−
795−-- | A `setNotNull` adds a @NOT NULL@ constraint to a column.
796−-- The constraint will be checked immediately, so the table data must satisfy
797−-- the constraint before it can be added.
798−--
799−-- >>> :{
800−-- let
801−-- definition :: Definition
802−-- '["public" ::: '["tab" ::: 'Table ('[] :=> '["col" ::: 'NoDef :=> 'Null 'PGint4])]]
803−-- '["public" ::: '["tab" ::: 'Table ('[] :=> '["col" ::: 'NoDef :=> 'NotNull 'PGint4])]]
804−-- definition = alterTable #tab (alterColumn #col setNotNull)
805−-- in printSQL definition
806−-- :}
807−-- ALTER TABLE "tab" ALTER COLUMN "col" SET NOT NULL;
808−setNotNull
809− :: AlterColumn schemas (constraint :=> 'Null ty) (constraint :=> 'NotNull ty)
810−setNotNull = UnsafeAlterColumn $ "SET NOT NULL"
811−
812−-- | A `dropNotNull` drops a @NOT NULL@ constraint from a column.
813−--
814−-- >>> :{
815−-- let
816−-- definition :: Definition
817−-- '["public" ::: '["tab" ::: 'Table ('[] :=> '["col" ::: 'NoDef :=> 'NotNull 'PGint4])]]
818−-- '["public" ::: '["tab" ::: 'Table ('[] :=> '["col" ::: 'NoDef :=> 'Null 'PGint4])]]
819−-- definition = alterTable #tab (alterColumn #col dropNotNull)
820−-- in printSQL definition
821−-- :}
822−-- ALTER TABLE "tab" ALTER COLUMN "col" DROP NOT NULL;
823−dropNotNull
824− :: AlterColumn schemas (constraint :=> 'NotNull ty) (constraint :=> 'Null ty)
825−dropNotNull = UnsafeAlterColumn $ "DROP NOT NULL"
826−
827−-- | An `alterType` converts a column to a different data type.
828−-- This will succeed only if each existing entry in the column can be
829−-- converted to the new type by an implicit cast.
830−--
831−-- >>> :{
832−-- let
833−-- definition :: Definition
834−-- '["public" ::: '["tab" ::: 'Table ('[] :=> '["col" ::: 'NoDef :=> 'NotNull 'PGint4])]]
835−-- '["public" ::: '["tab" ::: 'Table ('[] :=> '["col" ::: 'NoDef :=> 'NotNull 'PGnumeric])]]
836−-- definition =
837−-- alterTable #tab (alterColumn #col (alterType (numeric & notNullable)))
838−-- in printSQL definition
839−-- :}
840−-- ALTER TABLE "tab" ALTER COLUMN "col" TYPE numeric NOT NULL;
841−alterType :: ColumnTypeExpression schemas ty -> AlterColumn schemas ty0 ty
842−alterType ty = UnsafeAlterColumn $ "TYPE" <+> renderColumnTypeExpression ty
843−
844−{- | Create a view.
845−>>> type ABC = '["a" ::: 'NoDef :=> 'Null 'PGint4, "b" ::: 'NoDef :=> 'Null 'PGint4, "c" ::: 'NoDef :=> 'Null 'PGint4]
846−>>> type BC = '["b" ::: 'Null 'PGint4, "c" ::: 'Null 'PGint4]
847−>>> :{
848−let
849− definition :: Definition
850− '[ "public" ::: '["abc" ::: 'Table ('[] :=> ABC)]]
851− '[ "public" ::: '["abc" ::: 'Table ('[] :=> ABC), "bc" ::: 'View BC]]
852− definition =
853− createView #bc (select_ (#b :* #c) (from (table #abc)))
854−in printSQL definition
855−:}
856−CREATE VIEW "bc" AS SELECT "b" AS "b", "c" AS "c" FROM "abc" AS "abc";
857−-}
858−createView
859− :: (KnownSymbol sch, KnownSymbol vw, Has sch schemas schema)
860− => QualifiedAlias sch vw -- ^ the name of the view to add
861− -> Query '[] '[] schemas '[] view -- ^ query
862− -> Definition schemas (Alter sch (Create vw ('View view) schema) schemas)
863−createView alias query = UnsafeDefinition $
864− "CREATE" <+> "VIEW" <+> renderSQL alias <+> "AS"
865− <+> renderQuery query <> ";"
866−
867−-- | Drop a view.
868−--
869−-- >>> :{
870−-- let
871−-- definition :: Definition
872−-- '[ "public" ::: '["abc" ::: 'Table ('[] :=> '["a" ::: 'NoDef :=> 'Null 'PGint4, "b" ::: 'NoDef :=> 'Null 'PGint4, "c" ::: 'NoDef :=> 'Null 'PGint4])
873−-- , "bc" ::: 'View ('["b" ::: 'Null 'PGint4, "c" ::: 'Null 'PGint4])]]
874−-- '[ "public" ::: '["abc" ::: 'Table ('[] :=> '["a" ::: 'NoDef :=> 'Null 'PGint4, "b" ::: 'NoDef :=> 'Null 'PGint4, "c" ::: 'NoDef :=> 'Null 'PGint4])]]
875−-- definition = dropView #bc
876−-- in printSQL definition
877−-- :}
878−-- DROP VIEW "bc";
879−dropView
880− :: (Has sch schemas schema, Has vw schema ('View view))
881− => QualifiedAlias sch vw -- ^ view to remove
882− -> Definition schemas (Alter sch (Drop vw schema) schemas)
883−dropView vw = UnsafeDefinition $ "DROP VIEW" <+> renderSQL vw <> ";"
884−
885−-- | Enumerated types are created using the `createTypeEnum` command, for example
886−--
887−-- >>> printSQL $ (createTypeEnum #mood (label @"sad" :* label @"ok" :* label @"happy") :: Definition (Public '[]) '["public" ::: '["mood" ::: 'Typedef ('PGenum '["sad","ok","happy"])]])
888−-- CREATE TYPE "mood" AS ENUM ('sad', 'ok', 'happy');
889−createTypeEnum
890− :: (KnownSymbol enum, Has sch schemas schema, SOP.All KnownSymbol labels)
891− => QualifiedAlias sch enum
892− -- ^ name of the user defined enumerated type
893− -> NP PGlabel labels
894− -- ^ labels of the enumerated type
895− -> Definition schemas (Alter sch (Create enum ('Typedef ('PGenum labels)) schema) schemas)
896−createTypeEnum enum labels = UnsafeDefinition $
897− "CREATE" <+> "TYPE" <+> renderSQL enum <+> "AS" <+> "ENUM" <+>
898− parenthesized (renderSQL labels) <> ";"
899−
900−-- | Enumerated types can also be generated from a Haskell type, for example
901−--
902−-- >>> data Schwarma = Beef | Lamb | Chicken deriving GHC.Generic
903−-- >>> instance SOP.Generic Schwarma
904−-- >>> instance SOP.HasDatatypeInfo Schwarma
905−-- >>> :{
906−-- let
907−-- createSchwarma :: Definition (Public '[]) '["public" ::: '["schwarma" ::: 'Typedef (PG (Enumerated Schwarma))]]
908−-- createSchwarma = createTypeEnumFrom @Schwarma #schwarma
909−-- in
910−-- printSQL createSchwarma
911−-- :}
912−-- CREATE TYPE "schwarma" AS ENUM ('Beef', 'Lamb', 'Chicken');
913−createTypeEnumFrom
914− :: forall hask sch enum schemas schema.
915− ( SOP.Generic hask
916− , SOP.All KnownSymbol (LabelsPG hask)
917− , KnownSymbol enum
918− , Has sch schemas schema )
919− => QualifiedAlias sch enum
920− -- ^ name of the user defined enumerated type
921− -> Definition schemas (Alter sch (Create enum ('Typedef (PG (Enumerated hask))) schema) schemas)
922−createTypeEnumFrom enum = createTypeEnum enum
923− (SOP.hpure label :: NP PGlabel (LabelsPG hask))
924−
925−{- | `createTypeComposite` creates a composite type. The composite type is
926−specified by a list of attribute names and data types.
927−
928−>>> :{
929−type PGcomplex = 'PGcomposite
930− '[ "real" ::: 'NotNull 'PGfloat8
931− , "imaginary" ::: 'NotNull 'PGfloat8 ]
932−:}
933−
934−>>> :{
935−let
936− setup :: Definition (Public '[]) '["public" ::: '["complex" ::: 'Typedef PGcomplex]]
937− setup = createTypeComposite #complex
938− (float8 `as` #real :* float8 `as` #imaginary)
939−in printSQL setup
940−:}
941−CREATE TYPE "complex" AS ("real" float8, "imaginary" float8);
942−-}
943−createTypeComposite
944− :: (KnownSymbol ty, Has sch schemas schema, SOP.SListI fields)
945− => QualifiedAlias sch ty
946− -- ^ name of the user defined composite type
947− -> NP (Aliased (TypeExpression schemas)) fields
948− -- ^ list of attribute names and data types
949− -> Definition schemas (Alter sch (Create ty ('Typedef ('PGcomposite fields)) schema) schemas)
950−createTypeComposite ty fields = UnsafeDefinition $
951− "CREATE" <+> "TYPE" <+> renderSQL ty <+> "AS" <+> parenthesized
952− (renderCommaSeparated renderField fields) <> ";"
953− where
954− renderField :: Aliased (TypeExpression schemas) x -> ByteString
955− renderField (typ `As` alias) =
956− renderSQL alias <+> renderSQL typ
957−
958−-- | Composite types can also be generated from a Haskell type, for example
959−--
960−-- >>> data Complex = Complex {real :: Double, imaginary :: Double} deriving GHC.Generic
961−-- >>> instance SOP.Generic Complex
962−-- >>> instance SOP.HasDatatypeInfo Complex
963−-- >>> type Schema = '["complex" ::: 'Typedef (PG (Composite Complex))]
964−-- >>> :{
965−-- let
966−-- createComplex :: Definition (Public '[]) (Public Schema)
967−-- createComplex = createTypeCompositeFrom @Complex #complex
968−-- in
969−-- printSQL createComplex
970−-- :}
971−-- CREATE TYPE "complex" AS ("real" float8, "imaginary" float8);
972−createTypeCompositeFrom
973− :: forall hask sch ty schemas schema.
974− ( SOP.All (FieldTyped schemas) (RowPG hask)
975− , KnownSymbol ty
976− , Has sch schemas schema )
977− => QualifiedAlias sch ty
978− -- ^ name of the user defined composite type
979− -> Definition schemas (Alter sch (Create ty ( 'Typedef (PG (Composite hask))) schema) schemas)
980−createTypeCompositeFrom ty = createTypeComposite ty
981− (SOP.hcpure (SOP.Proxy :: SOP.Proxy (FieldTyped schemas)) fieldtype
982− :: NP (Aliased (TypeExpression schemas)) (RowPG hask))
983−
984−{-|
985−`createDomain` creates a new domain. A domain is essentially a data type
986−with constraints (restrictions on the allowed set of values).
987−
988−Domains are useful for abstracting common constraints on fields
989−into a single location for maintenance. For example, several tables might
990−contain email address columns, all requiring the same `check` constraint
991−to verify the address syntax. Define a domain rather than setting up
992−each table's constraint individually.
993−
994−>>> :{
995−let
996− createPositive :: Definition (Public '[]) (Public '["positive" ::: 'Typedef 'PGfloat4])
997− createPositive = createDomain #positive real (#value .> 0 .&& (#value & isNotNull))
998−in printSQL createPositive
999−:}
1000−CREATE DOMAIN "positive" AS real CHECK ((("value" > 0) AND "value" IS NOT NULL));
1001−-}
1002−createDomain
1003− :: (Has sch schemas schema, KnownSymbol dom)
1004− => QualifiedAlias sch dom
1005− -> (forall nullity. TypeExpression schemas (nullity ty))
1006− -> (forall tab. Condition '[] 'Ungrouped '[] schemas '[] '[tab ::: '["value" ::: 'Null ty]])
1007− -> Definition schemas (Alter sch (Create alias ('Typedef ty) schema) schemas)
1008−createDomain dom ty condition =
1009− UnsafeDefinition $ "CREATE DOMAIN" <+> renderSQL dom
1010− <+> "AS" <+> renderTypeExpression ty
1011− <+> "CHECK" <+> parenthesized (renderSQL condition) <> ";"
1012−
1013−class FieldTyped schemas ty where
1014− fieldtype :: Aliased (TypeExpression schemas) ty
1015−instance (KnownSymbol alias, PGTyped schemas ty)
1016− => FieldTyped schemas (alias ::: ty) where
1017− fieldtype = pgtype `As` Alias
1018−
1019−-- | Drop a type.
1020−--
1021−-- >>> data Schwarma = Beef | Lamb | Chicken deriving GHC.Generic
1022−-- >>> instance SOP.Generic Schwarma
1023−-- >>> instance SOP.HasDatatypeInfo Schwarma
1024−-- >>> printSQL (dropType #schwarma :: Definition '["public" ::: '["schwarma" ::: 'Typedef (PG (Enumerated Schwarma))]] (Public '[]))
1025−-- DROP TYPE "schwarma";
1026−dropType
1027− :: (Has sch schemas schema, Has td schema ('Typedef ty))
1028− => QualifiedAlias sch td
1029− -- ^ name of the user defined type
1030− -> Definition schemas (Alter sch (Drop td schema) schemas)
1031−dropType tydef = UnsafeDefinition $ "DROP" <+> "TYPE" <+> renderSQL tydef <> ";"
1032−
1033−-- | `ColumnTypeExpression`s are used in `createTable` commands.
1034−newtype ColumnTypeExpression (schemas :: SchemasType) (ty :: ColumnType)
1035− = UnsafeColumnTypeExpression { renderColumnTypeExpression :: ByteString }
1036− deriving (GHC.Generic,Show,Eq,Ord,NFData)
1037−instance RenderSQL (ColumnTypeExpression schemas ty) where
1038− renderSQL = renderColumnTypeExpression
1039−
1040−-- | used in `createTable` commands as a column constraint to note that
1041−-- @NULL@ may be present in a column
1042−nullable
1043− :: TypeExpression schemas (nullity ty)
1044− -> ColumnTypeExpression schemas ('NoDef :=> 'Null ty)
1045−nullable ty = UnsafeColumnTypeExpression $ renderSQL ty <+> "NULL"
1046−
1047−-- | used in `createTable` commands as a column constraint to ensure
1048−-- @NULL@ is not present in a column
1049−notNullable
1050− :: TypeExpression schemas (nullity ty)
1051− -> ColumnTypeExpression schemas ('NoDef :=> 'NotNull ty)
1052−notNullable ty = UnsafeColumnTypeExpression $ renderSQL ty <+> "NOT NULL"
1053−
1054−-- | used in `createTable` commands as a column constraint to give a default
1055−default_
1056− :: Expression '[] 'Ungrouped '[] schemas '[] '[] ty
1057− -> ColumnTypeExpression schemas ('NoDef :=> ty)
1058− -> ColumnTypeExpression schemas ('Def :=> ty)
1059−default_ x ty = UnsafeColumnTypeExpression $
1060− renderSQL ty <+> "DEFAULT" <+> renderExpression x
1061−
1062−-- | not a true type, but merely a notational convenience for creating
1063−-- unique identifier columns with type `PGint2`
1064−serial2, smallserial
1065− :: ColumnTypeExpression schemas ('Def :=> 'NotNull 'PGint2)
1066−serial2 = UnsafeColumnTypeExpression "serial2"
1067−smallserial = UnsafeColumnTypeExpression "smallserial"
1068−-- | not a true type, but merely a notational convenience for creating
1069−-- unique identifier columns with type `PGint4`
1070−serial4, serial
1071− :: ColumnTypeExpression schemas ('Def :=> 'NotNull 'PGint4)
1072−serial4 = UnsafeColumnTypeExpression "serial4"
1073−serial = UnsafeColumnTypeExpression "serial"
1074−-- | not a true type, but merely a notational convenience for creating
1075−-- unique identifier columns with type `PGint8`
1076−serial8, bigserial
1077− :: ColumnTypeExpression schemas ('Def :=> 'NotNull 'PGint8)
1078−serial8 = UnsafeColumnTypeExpression "serial8"
1079−bigserial = UnsafeColumnTypeExpression "bigserial"
squeal-postgresql/src/Squeal/PostgreSQL/Definition/Function.hsnew file+238
@@ -0,0 +1,238 @@
1+{-|
2+Module: Squeal.PostgreSQL.Definition.Function
3+Description: Create and drop function and operator definitions
4+Copyright: (c) Eitan Chatav, 2017
5+Maintainer: eitan@morphism.tech
6+Stability: experimental
7+
8+Create and drop function and operator definitions.
9+-}
10+
11+{-# LANGUAGE
12+ AllowAmbiguousTypes
13+ , ConstraintKinds
14+ , DeriveAnyClass
15+ , DeriveGeneric
16+ , DerivingStrategies
17+ , FlexibleContexts
18+ , FlexibleInstances
19+ , GADTs
20+ , LambdaCase
21+ , MultiParamTypeClasses
22+ , OverloadedLabels
23+ , OverloadedStrings
24+ , RankNTypes
25+ , ScopedTypeVariables
26+ , TypeApplications
27+ , TypeInType
28+ , TypeOperators
29+ , UndecidableSuperClasses
30+#-}
31+
32+module Squeal.PostgreSQL.Definition.Function
33+ ( createFunction
34+ , createOrReplaceFunction
35+ , createSetFunction
36+ , createOrReplaceSetFunction
37+ , createBinaryOp
38+ , createLeftOp
39+ , createRightOp
40+ , dropFunction
41+ , dropFunctionIfExists
42+ , dropOperator
43+ , dropOperatorIfExists
44+ , FunctionDefinition(..)
45+ , languageSqlExpr
46+ , languageSqlQuery
47+ ) where
48+
49+import Control.DeepSeq
50+import Data.ByteString
51+import GHC.TypeLits
52+
53+import qualified Generics.SOP as SOP
54+import qualified GHC.Generics as GHC
55+
56+import Squeal.PostgreSQL.Alias
57+import Squeal.PostgreSQL.Definition
58+import Squeal.PostgreSQL.Expression
59+import Squeal.PostgreSQL.Expression.Type
60+import Squeal.PostgreSQL.List
61+import Squeal.PostgreSQL.Query
62+import Squeal.PostgreSQL.Render
63+import Squeal.PostgreSQL.Schema
64+
65+-- $setup
66+-- >>> import Squeal.PostgreSQL
67+
68+createFunction
69+ :: ( Has sch schemas schema
70+ , KnownSymbol fun
71+ , SOP.SListI args )
72+ => QualifiedAlias sch fun
73+ -> NP (TypeExpression schemas) args
74+ -> TypeExpression schemas ret
75+ -> FunctionDefinition schemas args ('Returns ret)
76+ -> Definition schemas (Alter sch (Create fun ('Function (args :=> 'Returns ret)) schema) schemas)
77+createFunction fun args ret fundef = UnsafeDefinition $
78+ "CREATE" <+> "FUNCTION" <+> renderSQL fun
79+ <+> parenthesized (renderCommaSeparated renderSQL args)
80+ <+> "RETURNS" <+> renderSQL ret <+> renderSQL fundef <> ";"
81+
82+createOrReplaceFunction
83+ :: ( Has sch schemas schema
84+ , KnownSymbol fun
85+ , SOP.SListI args )
86+ => QualifiedAlias sch fun
87+ -> NP (TypeExpression schemas) args
88+ -> TypeExpression schemas ret
89+ -> FunctionDefinition schemas args ('Returns ret)
90+ -> Definition schemas (Alter sch (CreateOrReplace fun ('Function (args :=> 'Returns ret)) schema) schemas)
91+createOrReplaceFunction fun args ret fundef = UnsafeDefinition $
92+ "CREATE" <+> "OR" <+> "REPLACE" <+> "FUNCTION" <+> renderSQL fun
93+ <+> parenthesized (renderCommaSeparated renderSQL args)
94+ <+> "RETURNS" <+> renderSQL ret <+> renderSQL fundef <> ";"
95+
96+languageSqlExpr
97+ :: Expression '[] '[] 'Ungrouped schemas args '[] ret
98+ -> FunctionDefinition schemas args ('Returns ret)
99+languageSqlExpr expr = UnsafeFunctionDefinition $
100+ "language sql as"
101+ <+> "$$" <+> renderSQL (values_ (expr `as` #ret)) <+> "$$"
102+
103+languageSqlQuery
104+ :: Query '[] '[] schemas args rets
105+ -> FunctionDefinition schemas args ('ReturnsTable rets)
106+languageSqlQuery qry = UnsafeFunctionDefinition $
107+ "language sql as" <+> "$$" <+> renderSQL qry <+> "$$"
108+
109+createSetFunction
110+ :: ( Has sch schemas schema
111+ , KnownSymbol fun
112+ , SOP.SListI args
113+ , SOP.SListI rets )
114+ => QualifiedAlias sch fun
115+ -> NP (TypeExpression schemas) args
116+ -> NP (Aliased (TypeExpression schemas)) rets
117+ -> FunctionDefinition schemas args ('ReturnsTable rets)
118+ -> Definition schemas (Alter sch (Create fun ('Function (args :=> 'ReturnsTable rets)) schema) schemas)
119+createSetFunction fun args rets fundef = UnsafeDefinition $
120+ "CREATE" <+> "FUNCTION" <+> renderSQL fun
121+ <+> parenthesized (renderCommaSeparated renderSQL args)
122+ <+> "RETURNS" <+> "TABLE"
123+ <+> parenthesized (renderCommaSeparated renderRet rets)
124+ <+> renderSQL fundef <> ";"
125+ where
126+ renderRet :: Aliased (TypeExpression s) r -> ByteString
127+ renderRet (ty `As` col) = renderSQL col <+> renderSQL ty
128+
129+createOrReplaceSetFunction
130+ :: ( Has sch schemas schema
131+ , KnownSymbol fun
132+ , SOP.SListI args
133+ , SOP.SListI rets )
134+ => QualifiedAlias sch fun
135+ -> NP (TypeExpression schemas) args
136+ -> NP (Aliased (TypeExpression schemas)) rets
137+ -> FunctionDefinition schemas args ('ReturnsTable rets)
138+ -> Definition schemas (Alter sch (CreateOrReplace fun ('Function (args :=> 'ReturnsTable rets)) schema) schemas)
139+createOrReplaceSetFunction fun args rets fundef = UnsafeDefinition $
140+ "CREATE" <+> "OR" <+> "REPLACE" <+> "FUNCTION" <+> renderSQL fun
141+ <+> parenthesized (renderCommaSeparated renderSQL args)
142+ <+> "RETURNS" <+> "TABLE"
143+ <+> parenthesized (renderCommaSeparated renderRet rets)
144+ <+> renderSQL fundef <> ";"
145+ where
146+ renderRet :: Aliased (TypeExpression s) r -> ByteString
147+ renderRet (ty `As` col) = renderSQL col <+> renderSQL ty
148+
149+createBinaryOp
150+ :: forall op fun sch schemas schema x y z.
151+ ( Has sch schemas schema
152+ , Has fun schema ('Function ('[x,y] :=> 'Returns z))
153+ , KnownSymbol op )
154+ => QualifiedAlias sch fun
155+ -> TypeExpression schemas x
156+ -> TypeExpression schemas y
157+ -> Definition schemas
158+ (Alter sch (Create op ('Operator ('BinaryOp x y z)) schema) schemas)
159+createBinaryOp fun x y = UnsafeDefinition $
160+ "CREATE" <+> "OPERATOR" <+> renderSymbol @op
161+ <+> parenthesized (commaSeparated opdef)
162+ where
163+ opdef =
164+ [ "FUNCTION" <+> "=" <+> renderSQL fun
165+ , "LEFTARG" <+> "=" <+> renderSQL x
166+ , "RIGHTARG" <+> "=" <+> renderSQL y ]
167+
168+createLeftOp
169+ :: forall op fun sch schemas schema x y.
170+ ( Has sch schemas schema
171+ , Has fun schema ('Function ('[x] :=> 'Returns y))
172+ , KnownSymbol op )
173+ => QualifiedAlias sch fun
174+ -> TypeExpression schemas x
175+ -> Definition schemas
176+ (Alter sch (Create op ('Operator ('LeftOp x y)) schema) schemas)
177+createLeftOp fun x = UnsafeDefinition $
178+ "CREATE" <+> "OPERATOR" <+> renderSymbol @op
179+ <+> parenthesized (commaSeparated opdef)
180+ where
181+ opdef =
182+ [ "FUNCTION" <+> "=" <+> renderSQL fun
183+ , "RIGHTARG" <+> "=" <+> renderSQL x ]
184+
185+createRightOp
186+ :: forall op fun sch schemas schema x y.
187+ ( Has sch schemas schema
188+ , Has fun schema ('Function ('[x] :=> 'Returns y))
189+ , KnownSymbol op )
190+ => QualifiedAlias sch fun
191+ -> TypeExpression schemas x
192+ -> Definition schemas
193+ (Alter sch (Create op ('Operator ('RightOp x y)) schema) schemas)
194+createRightOp fun x = UnsafeDefinition $
195+ "CREATE" <+> "OPERATOR" <+> renderSymbol @op
196+ <+> parenthesized (commaSeparated opdef)
197+ where
198+ opdef =
199+ [ "FUNCTION" <+> "=" <+> renderSQL fun
200+ , "LEFTARG" <+> "=" <+> renderSQL x ]
201+
202+dropFunction
203+ :: (Has sch schemas schema, KnownSymbol fun)
204+ => QualifiedAlias sch fun
205+ -- ^ name of the user defined function
206+ -> Definition schemas (Alter sch (DropSchemum fun 'Function schema) schemas)
207+dropFunction fun = UnsafeDefinition $
208+ "DROP" <+> "FUNCTION" <+> renderSQL fun <> ";"
209+
210+dropFunctionIfExists
211+ :: (Has sch schemas schema, KnownSymbol fun)
212+ => QualifiedAlias sch fun
213+ -- ^ name of the user defined function
214+ -> Definition schemas (Alter sch (DropSchemumIfExists fun 'Function schema) schemas)
215+dropFunctionIfExists fun = UnsafeDefinition $
216+ "DROP FUNCTION IF EXISTS" <+> renderSQL fun <> ";"
217+
218+dropOperator
219+ :: (Has sch schemas schema, KnownSymbol op)
220+ => QualifiedAlias sch op
221+ -- ^ name of the user defined operator
222+ -> Definition schemas (Alter sch (DropSchemum op 'Operator schema) schemas)
223+dropOperator op = UnsafeDefinition $
224+ "DROP" <+> "OPERATOR" <+> renderSQL op <> ";"
225+
226+dropOperatorIfExists
227+ :: (Has sch schemas schema, KnownSymbol op)
228+ => QualifiedAlias sch op
229+ -- ^ name of the user defined operator
230+ -> Definition schemas (Alter sch (DropSchemumIfExists op 'Operator schema) schemas)
231+dropOperatorIfExists op = UnsafeDefinition $
232+ "DROP OPERATOR IF EXISTS" <+> renderSQL op <> ";"
233+
234+newtype FunctionDefinition schemas args ret = UnsafeFunctionDefinition
235+ { renderFunctionDefinition :: ByteString }
236+ deriving (Eq,Show,GHC.Generic,NFData)
237+instance RenderSQL (FunctionDefinition schemas args ret) where
238+ renderSQL = renderFunctionDefinition
squeal-postgresql/src/Squeal/PostgreSQL/Definition/Index.hsnew file+159
@@ -0,0 +1,159 @@
1+{-|
2+Module: Squeal.PostgreSQL.Definition.Index
3+Description: Create and drop index definitions
4+Copyright: (c) Eitan Chatav, 2017
5+Maintainer: eitan@morphism.tech
6+Stability: experimental
7+
8+Create and drop index definitions.
9+-}
10+
11+{-# LANGUAGE
12+ AllowAmbiguousTypes
13+ , ConstraintKinds
14+ , DeriveAnyClass
15+ , DeriveGeneric
16+ , DerivingStrategies
17+ , FlexibleContexts
18+ , FlexibleInstances
19+ , GADTs
20+ , LambdaCase
21+ , MultiParamTypeClasses
22+ , OverloadedLabels
23+ , OverloadedStrings
24+ , RankNTypes
25+ , ScopedTypeVariables
26+ , TypeApplications
27+ , TypeInType
28+ , TypeOperators
29+ , UndecidableSuperClasses
30+#-}
31+
32+module Squeal.PostgreSQL.Definition.Index
33+ ( createIndex
34+ , createIndexIfNotExists
35+ , dropIndex
36+ , dropIndexIfExists
37+ , IndexMethod (..)
38+ , btree
39+ , hash
40+ , gist
41+ , spgist
42+ , gin
43+ , brin
44+ ) where
45+
46+import Data.ByteString
47+import GHC.TypeLits
48+
49+import qualified GHC.Generics as GHC
50+
51+import Squeal.PostgreSQL.Alias
52+import Squeal.PostgreSQL.Definition
53+import Squeal.PostgreSQL.Expression.Sort
54+import Squeal.PostgreSQL.Render
55+import Squeal.PostgreSQL.Schema
56+
57+-- $setup
58+-- >>> import Squeal.PostgreSQL
59+
60+{- |
61+>>> :{
62+type Table = '[] :=>
63+ '[ "a" ::: 'NoDef :=> 'Null 'PGint4
64+ , "b" ::: 'NoDef :=> 'Null 'PGfloat4 ]
65+:}
66+
67+>>> :{
68+let
69+ setup :: Definition (Public '[]) (Public '["tab" ::: 'Table Table, "ix" ::: 'Index 'Btree])
70+ setup =
71+ createTable #tab (nullable int `as` #a :* nullable real `as` #b) Nil >>>
72+ createIndex #ix #tab btree [#a & AscNullsFirst, #b & AscNullsLast]
73+in printSQL setup
74+:}
75+CREATE TABLE "tab" ("a" int NULL, "b" real NULL);
76+CREATE INDEX "ix" ON "tab" USING btree (("a") ASC NULLS FIRST, ("b") ASC NULLS LAST);
77+-}
78+createIndex
79+ :: (Has sch schemas schema, Has tab schema ('Table table), KnownSymbol ix)
80+ => Alias ix
81+ -> QualifiedAlias sch tab
82+ -> IndexMethod method
83+ -> [SortExpression '[] '[] 'Ungrouped schemas '[] '[tab ::: TableToRow table]]
84+ -> Definition schemas (Alter sch (Create ix ('Index method) schema) schemas)
85+createIndex ix tab method cols = UnsafeDefinition $
86+ "CREATE" <+> "INDEX" <+> renderSQL ix <+> "ON" <+> renderSQL tab
87+ <+> "USING" <+> renderSQL method
88+ <+> parenthesized (commaSeparated (renderIndex <$> cols))
89+ <> ";"
90+ where
91+ renderIndex = \case
92+ Asc expression -> parenthesized (renderSQL expression) <+> "ASC"
93+ Desc expression -> parenthesized (renderSQL expression) <+> "DESC"
94+ AscNullsFirst expression -> parenthesized (renderSQL expression)
95+ <+> "ASC NULLS FIRST"
96+ DescNullsFirst expression -> parenthesized (renderSQL expression)
97+ <+> "DESC NULLS FIRST"
98+ AscNullsLast expression -> parenthesized (renderSQL expression)
99+ <+> "ASC NULLS LAST"
100+ DescNullsLast expression -> parenthesized (renderSQL expression)
101+ <+> "DESC NULLS LAST"
102+
103+createIndexIfNotExists
104+ :: (Has sch schemas schema, Has tab schema ('Table table), KnownSymbol ix)
105+ => Alias ix
106+ -> QualifiedAlias sch tab
107+ -> IndexMethod method
108+ -> [SortExpression '[] '[] 'Ungrouped schemas '[] '[tab ::: TableToRow table]]
109+ -> Definition schemas (Alter sch (CreateIfNotExists ix ('Index method) schema) schemas)
110+createIndexIfNotExists ix tab method cols = UnsafeDefinition $
111+ "CREATE INDEX IF NOT EXISTS" <+> renderSQL ix <+> "ON" <+> renderSQL tab
112+ <+> "USING" <+> renderSQL method
113+ <+> parenthesized (commaSeparated (renderIndex <$> cols))
114+ <> ";"
115+ where
116+ renderIndex = \case
117+ Asc expression -> parenthesized (renderSQL expression) <+> "ASC"
118+ Desc expression -> parenthesized (renderSQL expression) <+> "DESC"
119+ AscNullsFirst expression -> parenthesized (renderSQL expression)
120+ <+> "ASC NULLS FIRST"
121+ DescNullsFirst expression -> parenthesized (renderSQL expression)
122+ <+> "DESC NULLS FIRST"
123+ AscNullsLast expression -> parenthesized (renderSQL expression)
124+ <+> "ASC NULLS LAST"
125+ DescNullsLast expression -> parenthesized (renderSQL expression)
126+ <+> "DESC NULLS LAST"
127+
128+newtype IndexMethod ty = UnsafeIndexMethod {renderIndexMethod :: ByteString}
129+ deriving stock (Eq, Ord, Show, GHC.Generic)
130+instance RenderSQL (IndexMethod ty) where renderSQL = renderIndexMethod
131+btree :: IndexMethod 'Btree
132+btree = UnsafeIndexMethod "btree"
133+hash :: IndexMethod 'Hash
134+hash = UnsafeIndexMethod "hash"
135+gist :: IndexMethod 'Gist
136+gist = UnsafeIndexMethod "gist"
137+spgist :: IndexMethod 'Spgist
138+spgist = UnsafeIndexMethod "spgist"
139+gin :: IndexMethod 'Gin
140+gin = UnsafeIndexMethod "gin"
141+brin :: IndexMethod 'Brin
142+brin = UnsafeIndexMethod "brin"
143+
144+-- |
145+-- >>> printSQL (dropIndex #ix :: Definition (Public '["ix" ::: 'Index 'Btree]) (Public '[]))
146+-- DROP INDEX "ix";
147+dropIndex
148+ :: (Has sch schemas schema, KnownSymbol ix)
149+ => QualifiedAlias sch ix
150+ -- ^ name of the user defined index
151+ -> Definition schemas (Alter sch (DropSchemum ix 'Index schema) schemas)
152+dropIndex ix = UnsafeDefinition $ "DROP" <+> "INDEX" <+> renderSQL ix <> ";"
153+
154+dropIndexIfExists
155+ :: (Has sch schemas schema, KnownSymbol ix)
156+ => QualifiedAlias sch ix
157+ -- ^ name of the user defined index
158+ -> Definition schemas (Alter sch (DropSchemumIfExists ix 'Index schema) schemas)
159+dropIndexIfExists ix = UnsafeDefinition $ "DROP INDEX IF EXISTS" <+> renderSQL ix <> ";"
squeal-postgresql/src/Squeal/PostgreSQL/Definition/Schema.hsnew file+96
@@ -0,0 +1,96 @@
1+{-|
2+Module: Squeal.PostgreSQL.Definition.Schema
3+Description: Create and drop schema definitions
4+Copyright: (c) Eitan Chatav, 2017
5+Maintainer: eitan@morphism.tech
6+Stability: experimental
7+
8+Create and drop schema definitions.
9+-}
10+
11+{-# LANGUAGE
12+ AllowAmbiguousTypes
13+ , ConstraintKinds
14+ , DeriveAnyClass
15+ , DeriveGeneric
16+ , DerivingStrategies
17+ , FlexibleContexts
18+ , FlexibleInstances
19+ , GADTs
20+ , LambdaCase
21+ , MultiParamTypeClasses
22+ , OverloadedLabels
23+ , OverloadedStrings
24+ , RankNTypes
25+ , ScopedTypeVariables
26+ , TypeApplications
27+ , TypeInType
28+ , TypeOperators
29+ , UndecidableSuperClasses
30+#-}
31+
32+module Squeal.PostgreSQL.Definition.Schema
33+ ( createSchema
34+ , createSchemaIfNotExists
35+ , dropSchema
36+ , dropSchemaIfExists
37+ ) where
38+
39+import GHC.TypeLits
40+
41+import Squeal.PostgreSQL.Alias
42+import Squeal.PostgreSQL.Definition
43+import Squeal.PostgreSQL.Render
44+import Squeal.PostgreSQL.Schema
45+
46+-- $setup
47+-- >>> import Squeal.PostgreSQL
48+
49+{- |
50+`createSchema` enters a new schema into the current database.
51+The schema name must be distinct from the name of any existing schema
52+in the current database.
53+
54+A schema is essentially a namespace: it contains named objects
55+(tables, data types, functions, and operators) whose names
56+can duplicate those of other objects existing in other schemas.
57+Named objects are accessed by `QualifiedAlias`es with the schema
58+name as a prefix.
59+-}
60+createSchema
61+ :: KnownSymbol sch
62+ => Alias sch
63+ -> Definition schemas (Create sch '[] schemas)
64+createSchema sch = UnsafeDefinition $
65+ "CREATE" <+> "SCHEMA" <+> renderSQL sch <> ";"
66+
67+{- | Idempotent version of `createSchema`. -}
68+createSchemaIfNotExists
69+ :: (KnownSymbol sch, Has sch schemas schema)
70+ => Alias sch
71+ -> Definition schemas (CreateIfNotExists sch '[] schemas)
72+createSchemaIfNotExists sch = UnsafeDefinition $
73+ "CREATE" <+> "SCHEMA" <+> "IF" <+> "NOT" <+> "EXISTS"
74+ <+> renderSQL sch <> ";"
75+
76+-- | >>> :{
77+-- let
78+-- definition :: Definition '["muh_schema" ::: schema, "public" ::: public] '["public" ::: public]
79+-- definition = dropSchema #muh_schema
80+-- :}
81+--
82+-- >>> printSQL definition
83+-- DROP SCHEMA "muh_schema";
84+dropSchema
85+ :: KnownSymbol sch
86+ => Alias sch
87+ -- ^ user defined schema
88+ -> Definition schemas (Drop sch schemas)
89+dropSchema sch = UnsafeDefinition $ "DROP SCHEMA" <+> renderSQL sch <> ";"
90+
91+dropSchemaIfExists
92+ :: KnownSymbol sch
93+ => Alias sch
94+ -- ^ user defined schema
95+ -> Definition schemas (DropIfExists sch schemas)
96+dropSchemaIfExists sch = UnsafeDefinition $ "DROP SCHEMA" <+> renderSQL sch <> ";"
squeal-postgresql/src/Squeal/PostgreSQL/Definition/Table.hsnew file+500
@@ -0,0 +1,500 @@
1+{-|
2+Module: Squeal.PostgreSQL.Definition.Table
3+Description: Create, drop and alter table definitions
4+Copyright: (c) Eitan Chatav, 2017
5+Maintainer: eitan@morphism.tech
6+Stability: experimental
7+
8+Create, drop and alter table definitions.
9+-}
10+
11+{-# LANGUAGE
12+ AllowAmbiguousTypes
13+ , ConstraintKinds
14+ , DeriveAnyClass
15+ , DeriveGeneric
16+ , DerivingStrategies
17+ , FlexibleContexts
18+ , FlexibleInstances
19+ , GADTs
20+ , LambdaCase
21+ , MultiParamTypeClasses
22+ , OverloadedLabels
23+ , OverloadedStrings
24+ , RankNTypes
25+ , ScopedTypeVariables
26+ , TypeApplications
27+ , TypeInType
28+ , TypeOperators
29+ , UndecidableSuperClasses
30+#-}
31+
32+module Squeal.PostgreSQL.Definition.Table
33+ ( createTable
34+ , createTableIfNotExists
35+ , dropTable
36+ , dropTableIfExists
37+ , alterTable
38+ , alterTableIfExists
39+ , alterTableRename
40+ , alterTableIfExistsRename
41+ , AlterTable (..)
42+ , addConstraint
43+ , dropConstraint
44+ , AddColumn (..)
45+ , dropColumn
46+ , renameColumn
47+ , alterColumn
48+ , AlterColumn (..)
49+ , setDefault
50+ , dropDefault
51+ , setNotNull
52+ , dropNotNull
53+ , alterType
54+ ) where
55+
56+import Control.DeepSeq
57+import Data.ByteString
58+import GHC.TypeLits
59+
60+import qualified Generics.SOP as SOP
61+import qualified GHC.Generics as GHC
62+
63+import Squeal.PostgreSQL.Alias
64+import Squeal.PostgreSQL.Definition
65+import Squeal.PostgreSQL.Definition.Table.Constraint
66+import Squeal.PostgreSQL.Expression
67+import Squeal.PostgreSQL.Expression.Type
68+import Squeal.PostgreSQL.List
69+import Squeal.PostgreSQL.Render
70+import Squeal.PostgreSQL.Schema
71+
72+-- $setup
73+-- >>> import Squeal.PostgreSQL
74+
75+{- | `createTable` adds a table to the schema.
76+
77+>>> :set -XOverloadedLabels
78+>>> :{
79+type Table = '[] :=>
80+ '[ "a" ::: 'NoDef :=> 'Null 'PGint4
81+ , "b" ::: 'NoDef :=> 'Null 'PGfloat4 ]
82+:}
83+
84+>>> :{
85+let
86+ setup :: Definition (Public '[]) (Public '["tab" ::: 'Table Table])
87+ setup = createTable #tab
88+ (nullable int `as` #a :* nullable real `as` #b) Nil
89+in printSQL setup
90+:}
91+CREATE TABLE "tab" ("a" int NULL, "b" real NULL);
92+-}
93+createTable
94+ :: ( KnownSymbol sch
95+ , KnownSymbol tab
96+ , columns ~ (col ': cols)
97+ , SOP.SListI columns
98+ , SOP.SListI constraints
99+ , Has sch schemas0 schema0
100+ , schemas1 ~ Alter sch (Create tab ('Table (constraints :=> columns)) schema0) schemas0 )
101+ => QualifiedAlias sch tab -- ^ the name of the table to add
102+ -> NP (Aliased (ColumnTypeExpression schemas0)) columns
103+ -- ^ the names and datatype of each column
104+ -> NP (Aliased (TableConstraintExpression sch tab schemas1)) constraints
105+ -- ^ constraints that must hold for the table
106+ -> Definition schemas0 schemas1
107+createTable tab columns constraints = UnsafeDefinition $
108+ "CREATE TABLE" <+> renderCreation tab columns constraints
109+
110+{-| `createTableIfNotExists` creates a table if it doesn't exist, but does not add it to the schema.
111+Instead, the schema already has the table so if the table did not yet exist, the schema was wrong.
112+`createTableIfNotExists` fixes this. Interestingly, this property makes it an idempotent in
113+the `Category` of `Definition`s.
114+
115+>>> :set -XOverloadedLabels -XTypeApplications
116+>>> :{
117+type Table = '[] :=>
118+ '[ "a" ::: 'NoDef :=> 'Null 'PGint4
119+ , "b" ::: 'NoDef :=> 'Null 'PGfloat4 ]
120+:}
121+
122+>>> type Schemas = Public '["tab" ::: 'Table Table]
123+
124+>>> :{
125+let
126+ setup :: Definition Schemas Schemas
127+ setup = createTableIfNotExists #tab
128+ (nullable int `as` #a :* nullable real `as` #b) Nil
129+in printSQL setup
130+:}
131+CREATE TABLE IF NOT EXISTS "tab" ("a" int NULL, "b" real NULL);
132+-}
133+createTableIfNotExists
134+ :: ( KnownSymbol sch
135+ , KnownSymbol tab
136+ , columns ~ (col ': cols)
137+ , SOP.SListI columns
138+ , SOP.SListI constraints
139+ , Has sch schemas0 schema0
140+ , schemas1 ~ Alter sch (CreateIfNotExists tab ('Table (constraints :=> columns)) schema0) schemas0 )
141+ => QualifiedAlias sch tab -- ^ the name of the table to add
142+ -> NP (Aliased (ColumnTypeExpression schemas0)) columns
143+ -- ^ the names and datatype of each column
144+ -> NP (Aliased (TableConstraintExpression sch tab schemas1)) constraints
145+ -- ^ constraints that must hold for the table
146+ -> Definition schemas0 schemas1
147+createTableIfNotExists tab columns constraints = UnsafeDefinition $
148+ "CREATE TABLE IF NOT EXISTS"
149+ <+> renderCreation tab columns constraints
150+
151+-- helper function for `createTable` and `createTableIfNotExists`
152+renderCreation
153+ :: ( KnownSymbol sch
154+ , KnownSymbol tab
155+ , SOP.SListI columns
156+ , SOP.SListI constraints )
157+ => QualifiedAlias sch tab -- ^ the name of the table to add
158+ -> NP (Aliased (ColumnTypeExpression schemas0)) columns
159+ -- ^ the names and datatype of each column
160+ -> NP (Aliased (TableConstraintExpression sch tab schemas1)) constraints
161+ -- ^ constraints that must hold for the table
162+ -> ByteString
163+renderCreation tab columns constraints = renderSQL tab
164+ <+> parenthesized
165+ ( renderCommaSeparated renderColumnDef columns
166+ <> ( case constraints of
167+ Nil -> ""
168+ _ -> ", " <>
169+ renderCommaSeparated renderConstraint constraints ) )
170+ <> ";"
171+ where
172+ renderColumnDef :: Aliased (ColumnTypeExpression schemas) x -> ByteString
173+ renderColumnDef (ty `As` column) =
174+ renderSQL column <+> renderColumnTypeExpression ty
175+ renderConstraint
176+ :: Aliased (TableConstraintExpression sch tab schemas) constraint
177+ -> ByteString
178+ renderConstraint (constraint `As` alias) =
179+ "CONSTRAINT" <+> renderSQL alias <+> renderSQL constraint
180+
181+-- | `dropTable` removes a table from the schema.
182+--
183+-- >>> :{
184+-- let
185+-- definition :: Definition '["public" ::: '["muh_table" ::: 'Table t]] (Public '[])
186+-- definition = dropTable #muh_table
187+-- :}
188+--
189+-- >>> printSQL definition
190+-- DROP TABLE "muh_table";
191+dropTable
192+ :: ( Has sch schemas schema
193+ , KnownSymbol tab )
194+ => QualifiedAlias sch tab -- ^ table to remove
195+ -> Definition schemas (Alter sch (DropSchemum tab 'Table schema) schemas)
196+dropTable tab = UnsafeDefinition $ "DROP TABLE" <+> renderSQL tab <> ";"
197+
198+dropTableIfExists
199+ :: ( Has sch schemas schema
200+ , KnownSymbol tab)
201+ => QualifiedAlias sch tab -- ^ table to remove
202+ -> Definition schemas (Alter sch (DropSchemumIfExists tab 'Table schema) schemas)
203+dropTableIfExists tab = UnsafeDefinition $ "DROP TABLE IF EXISTS" <+> renderSQL tab <> ";"
204+
205+-- | `alterTable` changes the definition of a table from the schema.
206+alterTable
207+ :: (Has sch schemas schema, KnownSymbol tab)
208+ => QualifiedAlias sch tab -- ^ table to alter
209+ -> AlterTable sch tab schemas table -- ^ alteration to perform
210+ -> Definition schemas (Alter sch (Alter tab ('Table table) schema) schemas)
211+alterTable tab alteration = UnsafeDefinition $
212+ "ALTER TABLE"
213+ <+> renderSQL tab
214+ <+> renderAlterTable alteration
215+ <> ";"
216+
217+-- | `alterTable` changes the definition of a table from the schema.
218+alterTableIfExists
219+ :: (Has sch schemas schema, KnownSymbol tab)
220+ => QualifiedAlias sch tab -- ^ table to alter
221+ -> AlterTable sch tab schemas table -- ^ alteration to perform
222+ -> Definition schemas (Alter sch (AlterIfExists tab ('Table table) schema) schemas)
223+alterTableIfExists tab alteration = UnsafeDefinition $
224+ "ALTER TABLE IF EXISTS"
225+ <+> renderSQL tab
226+ <+> renderAlterTable alteration
227+ <> ";"
228+
229+-- | `alterTableRename` changes the name of a table from the schema.
230+--
231+-- >>> printSQL $ alterTableRename #foo #bar
232+-- ALTER TABLE "foo" RENAME TO "bar";
233+alterTableRename
234+ :: (KnownSymbol tab0, KnownSymbol tab1)
235+ => Alias tab0 -- ^ table to rename
236+ -> Alias tab1 -- ^ what to rename it
237+ -> Definition schema (Rename tab0 tab1 schema)
238+alterTableRename tab0 tab1 = UnsafeDefinition $
239+ "ALTER TABLE" <+> renderSQL tab0
240+ <+> "RENAME TO" <+> renderSQL tab1 <> ";"
241+
242+alterTableIfExistsRename
243+ :: (KnownSymbol tab0, KnownSymbol tab1)
244+ => Alias tab0 -- ^ table to rename
245+ -> Alias tab1 -- ^ what to rename it
246+ -> Definition schema (RenameIfExists tab0 tab1 schema)
247+alterTableIfExistsRename tab0 tab1 = UnsafeDefinition $
248+ "ALTER TABLE IF EXISTS" <+> renderSQL tab0
249+ <+> "RENAME TO" <+> renderSQL tab1 <> ";"
250+
251+-- | An `AlterTable` describes the alteration to perform on the columns
252+-- of a table.
253+newtype AlterTable
254+ (sch :: Symbol)
255+ (tab :: Symbol)
256+ (schemas :: SchemasType)
257+ (table :: TableType) =
258+ UnsafeAlterTable {renderAlterTable :: ByteString}
259+ deriving (GHC.Generic,Show,Eq,Ord,NFData)
260+
261+-- | An `addConstraint` adds a table constraint.
262+--
263+-- >>> :{
264+-- let
265+-- definition :: Definition
266+-- '["public" ::: '["tab" ::: 'Table ('[] :=> '["col" ::: 'NoDef :=> 'NotNull 'PGint4])]]
267+-- '["public" ::: '["tab" ::: 'Table ('["positive" ::: 'Check '["col"]] :=> '["col" ::: 'NoDef :=> 'NotNull 'PGint4])]]
268+-- definition = alterTable #tab (addConstraint #positive (check #col (#col .> 0)))
269+-- in printSQL definition
270+-- :}
271+-- ALTER TABLE "tab" ADD CONSTRAINT "positive" CHECK (("col" > 0));
272+addConstraint
273+ :: ( KnownSymbol alias
274+ , Has sch schemas schema
275+ , Has tab schema ('Table table0)
276+ , table0 ~ (constraints :=> columns)
277+ , table1 ~ (Create alias constraint constraints :=> columns) )
278+ => Alias alias
279+ -> TableConstraintExpression sch tab schemas constraint
280+ -- ^ constraint to add
281+ -> AlterTable sch tab schemas table1
282+addConstraint alias constraint = UnsafeAlterTable $
283+ "ADD" <+> "CONSTRAINT" <+> renderSQL alias
284+ <+> renderSQL constraint
285+
286+-- | A `dropConstraint` drops a table constraint.
287+--
288+-- >>> :{
289+-- let
290+-- definition :: Definition
291+-- '["public" ::: '["tab" ::: 'Table ('["positive" ::: Check '["col"]] :=> '["col" ::: 'NoDef :=> 'NotNull 'PGint4])]]
292+-- '["public" ::: '["tab" ::: 'Table ('[] :=> '["col" ::: 'NoDef :=> 'NotNull 'PGint4])]]
293+-- definition = alterTable #tab (dropConstraint #positive)
294+-- in printSQL definition
295+-- :}
296+-- ALTER TABLE "tab" DROP CONSTRAINT "positive";
297+dropConstraint
298+ :: ( KnownSymbol constraint
299+ , Has sch schemas schema
300+ , Has tab schema ('Table table0)
301+ , table0 ~ (constraints :=> columns)
302+ , table1 ~ (Drop constraint constraints :=> columns) )
303+ => Alias constraint
304+ -- ^ constraint to drop
305+ -> AlterTable sch tab schemas table1
306+dropConstraint constraint = UnsafeAlterTable $
307+ "DROP" <+> "CONSTRAINT" <+> renderSQL constraint
308+
309+-- | An `AddColumn` is either @NULL@ or has @DEFAULT@.
310+class AddColumn ty where
311+ -- | `addColumn` adds a new column, initially filled with whatever
312+ -- default value is given or with @NULL@.
313+ --
314+ -- >>> :{
315+ -- let
316+ -- definition :: Definition
317+ -- '["public" ::: '["tab" ::: 'Table ('[] :=> '["col1" ::: 'NoDef :=> 'Null 'PGint4])]]
318+ -- '["public" ::: '["tab" ::: 'Table ('[] :=>
319+ -- '[ "col1" ::: 'NoDef :=> 'Null 'PGint4
320+ -- , "col2" ::: 'Def :=> 'Null 'PGtext ])]]
321+ -- definition = alterTable #tab (addColumn #col2 (text & nullable & default_ "foo"))
322+ -- in printSQL definition
323+ -- :}
324+ -- ALTER TABLE "tab" ADD COLUMN "col2" text NULL DEFAULT E'foo';
325+ --
326+ -- >>> :{
327+ -- let
328+ -- definition :: Definition
329+ -- '["public" ::: '["tab" ::: 'Table ('[] :=> '["col1" ::: 'NoDef :=> 'Null 'PGint4])]]
330+ -- '["public" ::: '["tab" ::: 'Table ('[] :=>
331+ -- '[ "col1" ::: 'NoDef :=> 'Null 'PGint4
332+ -- , "col2" ::: 'NoDef :=> 'Null 'PGtext ])]]
333+ -- definition = alterTable #tab (addColumn #col2 (text & nullable))
334+ -- in printSQL definition
335+ -- :}
336+ -- ALTER TABLE "tab" ADD COLUMN "col2" text NULL;
337+ addColumn
338+ :: ( KnownSymbol column
339+ , Has sch schemas schema
340+ , Has tab schema ('Table table0)
341+ , table0 ~ (constraints :=> columns) )
342+ => Alias column -- ^ column to add
343+ -> ColumnTypeExpression schemas ty -- ^ type of the new column
344+ -> AlterTable sch tab schemas (constraints :=> Create column ty columns)
345+ addColumn column ty = UnsafeAlterTable $
346+ "ADD COLUMN" <+> renderSQL column <+> renderColumnTypeExpression ty
347+instance {-# OVERLAPPING #-} AddColumn ('Def :=> ty)
348+instance {-# OVERLAPPABLE #-} AddColumn ('NoDef :=> 'Null ty)
349+
350+-- | A `dropColumn` removes a column. Whatever data was in the column
351+-- disappears. Table constraints involving the column are dropped, too.
352+-- However, if the column is referenced by a foreign key constraint of
353+-- another table, PostgreSQL will not silently drop that constraint.
354+--
355+-- >>> :{
356+-- let
357+-- definition :: Definition
358+-- '["public" ::: '["tab" ::: 'Table ('[] :=>
359+-- '[ "col1" ::: 'NoDef :=> 'Null 'PGint4
360+-- , "col2" ::: 'NoDef :=> 'Null 'PGtext ])]]
361+-- '["public" ::: '["tab" ::: 'Table ('[] :=> '["col1" ::: 'NoDef :=> 'Null 'PGint4])]]
362+-- definition = alterTable #tab (dropColumn #col2)
363+-- in printSQL definition
364+-- :}
365+-- ALTER TABLE "tab" DROP COLUMN "col2";
366+dropColumn
367+ :: ( KnownSymbol column
368+ , Has sch schemas schema
369+ , Has tab schema ('Table table0)
370+ , table0 ~ (constraints :=> columns)
371+ , table1 ~ (constraints :=> Drop column columns) )
372+ => Alias column -- ^ column to remove
373+ -> AlterTable sch tab schemas table1
374+dropColumn column = UnsafeAlterTable $
375+ "DROP COLUMN" <+> renderSQL column
376+
377+-- | A `renameColumn` renames a column.
378+--
379+-- >>> :{
380+-- let
381+-- definition :: Definition
382+-- '["public" ::: '["tab" ::: 'Table ('[] :=> '["foo" ::: 'NoDef :=> 'Null 'PGint4])]]
383+-- '["public" ::: '["tab" ::: 'Table ('[] :=> '["bar" ::: 'NoDef :=> 'Null 'PGint4])]]
384+-- definition = alterTable #tab (renameColumn #foo #bar)
385+-- in printSQL definition
386+-- :}
387+-- ALTER TABLE "tab" RENAME COLUMN "foo" TO "bar";
388+renameColumn
389+ :: ( KnownSymbol column0
390+ , KnownSymbol column1
391+ , Has sch schemas schema
392+ , Has tab schema ('Table table0)
393+ , table0 ~ (constraints :=> columns)
394+ , table1 ~ (constraints :=> Rename column0 column1 columns) )
395+ => Alias column0 -- ^ column to rename
396+ -> Alias column1 -- ^ what to rename the column
397+ -> AlterTable sch tab schemas table1
398+renameColumn column0 column1 = UnsafeAlterTable $
399+ "RENAME COLUMN" <+> renderSQL column0 <+> "TO" <+> renderSQL column1
400+
401+-- | An `alterColumn` alters a single column.
402+alterColumn
403+ :: ( KnownSymbol column
404+ , Has sch schemas schema
405+ , Has tab schema ('Table table0)
406+ , table0 ~ (constraints :=> columns)
407+ , Has column columns ty0
408+ , table1 ~ (constraints :=> Alter column ty1 columns))
409+ => Alias column -- ^ column to alter
410+ -> AlterColumn schemas ty0 ty1 -- ^ alteration to perform
411+ -> AlterTable sch tab schemas table1
412+alterColumn column alteration = UnsafeAlterTable $
413+ "ALTER COLUMN" <+> renderSQL column <+> renderAlterColumn alteration
414+
415+-- | An `AlterColumn` describes the alteration to perform on a single column.
416+newtype AlterColumn (schemas :: SchemasType) (ty0 :: ColumnType) (ty1 :: ColumnType) =
417+ UnsafeAlterColumn {renderAlterColumn :: ByteString}
418+ deriving (GHC.Generic,Show,Eq,Ord,NFData)
419+
420+-- | A `setDefault` sets a new default for a column. Note that this doesn't
421+-- affect any existing rows in the table, it just changes the default for
422+-- future insert and update commands.
423+--
424+-- >>> :{
425+-- let
426+-- definition :: Definition
427+-- '["public" ::: '["tab" ::: 'Table ('[] :=> '["col" ::: 'NoDef :=> 'Null 'PGint4])]]
428+-- '["public" ::: '["tab" ::: 'Table ('[] :=> '["col" ::: 'Def :=> 'Null 'PGint4])]]
429+-- definition = alterTable #tab (alterColumn #col (setDefault 5))
430+-- in printSQL definition
431+-- :}
432+-- ALTER TABLE "tab" ALTER COLUMN "col" SET DEFAULT 5;
433+setDefault
434+ :: Expression '[] '[] 'Ungrouped schemas '[] '[] ty -- ^ default value to set
435+ -> AlterColumn schemas (constraint :=> ty) ('Def :=> ty)
436+setDefault expression = UnsafeAlterColumn $
437+ "SET DEFAULT" <+> renderExpression expression
438+
439+-- | A `dropDefault` removes any default value for a column.
440+--
441+-- >>> :{
442+-- let
443+-- definition :: Definition
444+-- '["public" ::: '["tab" ::: 'Table ('[] :=> '["col" ::: 'Def :=> 'Null 'PGint4])]]
445+-- '["public" ::: '["tab" ::: 'Table ('[] :=> '["col" ::: 'NoDef :=> 'Null 'PGint4])]]
446+-- definition = alterTable #tab (alterColumn #col dropDefault)
447+-- in printSQL definition
448+-- :}
449+-- ALTER TABLE "tab" ALTER COLUMN "col" DROP DEFAULT;
450+dropDefault :: AlterColumn schemas ('Def :=> ty) ('NoDef :=> ty)
451+dropDefault = UnsafeAlterColumn $ "DROP DEFAULT"
452+
453+-- | A `setNotNull` adds a @NOT NULL@ constraint to a column.
454+-- The constraint will be checked immediately, so the table data must satisfy
455+-- the constraint before it can be added.
456+--
457+-- >>> :{
458+-- let
459+-- definition :: Definition
460+-- '["public" ::: '["tab" ::: 'Table ('[] :=> '["col" ::: 'NoDef :=> 'Null 'PGint4])]]
461+-- '["public" ::: '["tab" ::: 'Table ('[] :=> '["col" ::: 'NoDef :=> 'NotNull 'PGint4])]]
462+-- definition = alterTable #tab (alterColumn #col setNotNull)
463+-- in printSQL definition
464+-- :}
465+-- ALTER TABLE "tab" ALTER COLUMN "col" SET NOT NULL;
466+setNotNull
467+ :: AlterColumn schemas (constraint :=> 'Null ty) (constraint :=> 'NotNull ty)
468+setNotNull = UnsafeAlterColumn $ "SET NOT NULL"
469+
470+-- | A `dropNotNull` drops a @NOT NULL@ constraint from a column.
471+--
472+-- >>> :{
473+-- let
474+-- definition :: Definition
475+-- '["public" ::: '["tab" ::: 'Table ('[] :=> '["col" ::: 'NoDef :=> 'NotNull 'PGint4])]]
476+-- '["public" ::: '["tab" ::: 'Table ('[] :=> '["col" ::: 'NoDef :=> 'Null 'PGint4])]]
477+-- definition = alterTable #tab (alterColumn #col dropNotNull)
478+-- in printSQL definition
479+-- :}
480+-- ALTER TABLE "tab" ALTER COLUMN "col" DROP NOT NULL;
481+dropNotNull
482+ :: AlterColumn schemas (constraint :=> 'NotNull ty) (constraint :=> 'Null ty)
483+dropNotNull = UnsafeAlterColumn $ "DROP NOT NULL"
484+
485+-- | An `alterType` converts a column to a different data type.
486+-- This will succeed only if each existing entry in the column can be
487+-- converted to the new type by an implicit cast.
488+--
489+-- >>> :{
490+-- let
491+-- definition :: Definition
492+-- '["public" ::: '["tab" ::: 'Table ('[] :=> '["col" ::: 'NoDef :=> 'NotNull 'PGint4])]]
493+-- '["public" ::: '["tab" ::: 'Table ('[] :=> '["col" ::: 'NoDef :=> 'NotNull 'PGnumeric])]]
494+-- definition =
495+-- alterTable #tab (alterColumn #col (alterType (numeric & notNullable)))
496+-- in printSQL definition
497+-- :}
498+-- ALTER TABLE "tab" ALTER COLUMN "col" TYPE numeric NOT NULL;
499+alterType :: ColumnTypeExpression schemas ty -> AlterColumn schemas ty0 ty
500+alterType ty = UnsafeAlterColumn $ "TYPE" <+> renderColumnTypeExpression ty
squeal-postgresql/src/Squeal/PostgreSQL/Definition/Table/Constraint.hsnew file+339
@@ -0,0 +1,339 @@
1+{-|
2+Module: Squeal.PostgreSQL.Definition.Table.Constraint
3+Description: Table constraint expressions
4+Copyright: (c) Eitan Chatav, 2017
5+Maintainer: eitan@morphism.tech
6+Stability: experimental
7+
8+Table constraint expressions.
9+-}
10+
11+{-# LANGUAGE
12+ AllowAmbiguousTypes
13+ , ConstraintKinds
14+ , DeriveAnyClass
15+ , DeriveGeneric
16+ , DerivingStrategies
17+ , FlexibleContexts
18+ , FlexibleInstances
19+ , GADTs
20+ , LambdaCase
21+ , MultiParamTypeClasses
22+ , OverloadedLabels
23+ , OverloadedStrings
24+ , RankNTypes
25+ , ScopedTypeVariables
26+ , TypeApplications
27+ , TypeInType
28+ , TypeOperators
29+ , UndecidableSuperClasses
30+#-}
31+
32+module Squeal.PostgreSQL.Definition.Table.Constraint
33+ ( TableConstraintExpression (..)
34+ , check
35+ , unique
36+ , primaryKey
37+ , foreignKey
38+ , ForeignKeyed
39+ , OnDeleteClause (..)
40+ , OnUpdateClause (..)
41+ ) where
42+
43+import Control.DeepSeq
44+import Data.ByteString
45+import GHC.TypeLits
46+
47+import qualified Generics.SOP as SOP
48+import qualified GHC.Generics as GHC
49+
50+import Squeal.PostgreSQL.Alias
51+import Squeal.PostgreSQL.Expression.Logic
52+import Squeal.PostgreSQL.List
53+import Squeal.PostgreSQL.Render
54+import Squeal.PostgreSQL.Schema
55+
56+-- $setup
57+-- >>> import Squeal.PostgreSQL
58+
59+-- | Data types are a way to limit the kind of data that can be stored in a
60+-- table. For many applications, however, the constraint they provide is
61+-- too coarse. For example, a column containing a product price should
62+-- probably only accept positive values. But there is no standard data type
63+-- that accepts only positive numbers. Another issue is that you might want
64+-- to constrain column data with respect to other columns or rows.
65+-- For example, in a table containing product information,
66+-- there should be only one row for each product number.
67+-- `TableConstraint`s give you as much control over the data in your tables
68+-- as you wish. If a user attempts to store data in a column that would
69+-- violate a constraint, an error is raised. This applies
70+-- even if the value came from the default value definition.
71+newtype TableConstraintExpression
72+ (sch :: Symbol)
73+ (tab :: Symbol)
74+ (schemas :: SchemasType)
75+ (constraint :: TableConstraint)
76+ = UnsafeTableConstraintExpression
77+ { renderTableConstraintExpression :: ByteString }
78+ deriving (GHC.Generic,Show,Eq,Ord,NFData)
79+instance RenderSQL
80+ (TableConstraintExpression sch tab schemas constraint) where
81+ renderSQL = renderTableConstraintExpression
82+
83+{-| A `check` constraint is the most generic `TableConstraint` type.
84+It allows you to specify that the value in a certain column must satisfy
85+a Boolean (truth-value) expression.
86+
87+>>> :{
88+type Schema = '[
89+ "tab" ::: 'Table ('[ "inequality" ::: 'Check '["a","b"]] :=> '[
90+ "a" ::: 'NoDef :=> 'NotNull 'PGint4,
91+ "b" ::: 'NoDef :=> 'NotNull 'PGint4
92+ ])]
93+:}
94+
95+>>> :{
96+let
97+ definition :: Definition (Public '[]) (Public Schema)
98+ definition = createTable #tab
99+ ( (int & notNullable) `as` #a :*
100+ (int & notNullable) `as` #b )
101+ ( check (#a :* #b) (#a .> #b) `as` #inequality )
102+:}
103+
104+>>> printSQL definition
105+CREATE TABLE "tab" ("a" int NOT NULL, "b" int NOT NULL, CONSTRAINT "inequality" CHECK (("a" > "b")));
106+-}
107+check
108+ :: ( Has sch schemas schema
109+ , Has tab schema ('Table table)
110+ , HasAll aliases (TableToRow table) subcolumns )
111+ => NP Alias aliases
112+ -- ^ specify the subcolumns which are getting checked
113+ -> (forall t. Condition '[] '[] 'Ungrouped schemas '[] '[t ::: subcolumns])
114+ -- ^ a closed `Condition` on those subcolumns
115+ -> TableConstraintExpression sch tab schemas ('Check aliases)
116+check _cols condition = UnsafeTableConstraintExpression $
117+ "CHECK" <+> parenthesized (renderSQL condition)
118+
119+{-| A `unique` constraint ensure that the data contained in a column,
120+or a group of columns, is unique among all the rows in the table.
121+
122+>>> :{
123+type Schema = '[
124+ "tab" ::: 'Table( '[ "uq_a_b" ::: 'Unique '["a","b"]] :=> '[
125+ "a" ::: 'NoDef :=> 'Null 'PGint4,
126+ "b" ::: 'NoDef :=> 'Null 'PGint4
127+ ])]
128+:}
129+
130+>>> :{
131+let
132+ definition :: Definition (Public '[]) (Public Schema)
133+ definition = createTable #tab
134+ ( (int & nullable) `as` #a :*
135+ (int & nullable) `as` #b )
136+ ( unique (#a :* #b) `as` #uq_a_b )
137+:}
138+
139+>>> printSQL definition
140+CREATE TABLE "tab" ("a" int NULL, "b" int NULL, CONSTRAINT "uq_a_b" UNIQUE ("a", "b"));
141+-}
142+unique
143+ :: ( Has sch schemas schema
144+ , Has tab schema('Table table)
145+ , HasAll aliases (TableToRow table) subcolumns )
146+ => NP Alias aliases
147+ -- ^ specify subcolumns which together are unique for each row
148+ -> TableConstraintExpression sch tab schemas ('Unique aliases)
149+unique columns = UnsafeTableConstraintExpression $
150+ "UNIQUE" <+> parenthesized (renderSQL columns)
151+
152+{-| A `primaryKey` constraint indicates that a column, or group of columns,
153+can be used as a unique identifier for rows in the table.
154+This requires that the values be both unique and not null.
155+
156+>>> :{
157+type Schema = '[
158+ "tab" ::: 'Table ('[ "pk_id" ::: 'PrimaryKey '["id"]] :=> '[
159+ "id" ::: 'Def :=> 'NotNull 'PGint4,
160+ "name" ::: 'NoDef :=> 'NotNull 'PGtext
161+ ])]
162+:}
163+
164+>>> :{
165+let
166+ definition :: Definition (Public '[]) (Public Schema)
167+ definition = createTable #tab
168+ ( serial `as` #id :*
169+ (text & notNullable) `as` #name )
170+ ( primaryKey #id `as` #pk_id )
171+:}
172+
173+>>> printSQL definition
174+CREATE TABLE "tab" ("id" serial, "name" text NOT NULL, CONSTRAINT "pk_id" PRIMARY KEY ("id"));
175+-}
176+primaryKey
177+ :: ( Has sch schemas schema
178+ , Has tab schema ('Table table)
179+ , HasAll aliases (TableToColumns table) subcolumns
180+ , AllNotNull subcolumns )
181+ => NP Alias aliases
182+ -- ^ specify the subcolumns which together form a primary key.
183+ -> TableConstraintExpression sch tab schemas ('PrimaryKey aliases)
184+primaryKey columns = UnsafeTableConstraintExpression $
185+ "PRIMARY KEY" <+> parenthesized (renderSQL columns)
186+
187+{-| A `foreignKey` specifies that the values in a column
188+(or a group of columns) must match the values appearing in some row of
189+another table. We say this maintains the referential integrity
190+between two related tables.
191+
192+>>> :{
193+type Schema =
194+ '[ "users" ::: 'Table (
195+ '[ "pk_users" ::: 'PrimaryKey '["id"] ] :=>
196+ '[ "id" ::: 'Def :=> 'NotNull 'PGint4
197+ , "name" ::: 'NoDef :=> 'NotNull 'PGtext
198+ ])
199+ , "emails" ::: 'Table (
200+ '[ "pk_emails" ::: 'PrimaryKey '["id"]
201+ , "fk_user_id" ::: 'ForeignKey '["user_id"] "users" '["id"]
202+ ] :=>
203+ '[ "id" ::: 'Def :=> 'NotNull 'PGint4
204+ , "user_id" ::: 'NoDef :=> 'NotNull 'PGint4
205+ , "email" ::: 'NoDef :=> 'Null 'PGtext
206+ ])
207+ ]
208+:}
209+
210+>>> :{
211+let
212+ setup :: Definition (Public '[]) (Public Schema)
213+ setup =
214+ createTable #users
215+ ( serial `as` #id :*
216+ (text & notNullable) `as` #name )
217+ ( primaryKey #id `as` #pk_users ) >>>
218+ createTable #emails
219+ ( serial `as` #id :*
220+ (int & notNullable) `as` #user_id :*
221+ (text & nullable) `as` #email )
222+ ( primaryKey #id `as` #pk_emails :*
223+ foreignKey #user_id #users #id
224+ OnDeleteCascade OnUpdateCascade `as` #fk_user_id )
225+in printSQL setup
226+:}
227+CREATE TABLE "users" ("id" serial, "name" text NOT NULL, CONSTRAINT "pk_users" PRIMARY KEY ("id"));
228+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);
229+
230+A `foreignKey` can even be a table self-reference.
231+
232+>>> :{
233+type Schema =
234+ '[ "employees" ::: 'Table (
235+ '[ "employees_pk" ::: 'PrimaryKey '["id"]
236+ , "employees_employer_fk" ::: 'ForeignKey '["employer_id"] "employees" '["id"]
237+ ] :=>
238+ '[ "id" ::: 'Def :=> 'NotNull 'PGint4
239+ , "name" ::: 'NoDef :=> 'NotNull 'PGtext
240+ , "employer_id" ::: 'NoDef :=> 'Null 'PGint4
241+ ])
242+ ]
243+:}
244+
245+>>> :{
246+let
247+ setup :: Definition (Public '[]) (Public Schema)
248+ setup =
249+ createTable #employees
250+ ( serial `as` #id :*
251+ (text & notNullable) `as` #name :*
252+ (integer & nullable) `as` #employer_id )
253+ ( primaryKey #id `as` #employees_pk :*
254+ foreignKey #employer_id #employees #id
255+ OnDeleteCascade OnUpdateCascade `as` #employees_employer_fk )
256+in printSQL setup
257+:}
258+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);
259+-}
260+foreignKey
261+ :: (ForeignKeyed schemas sch schema child parent
262+ table reftable
263+ columns refcolumns
264+ constraints cols
265+ reftys tys )
266+ => NP Alias columns
267+ -- ^ column or columns in the table
268+ -> Alias parent
269+ -- ^ reference table
270+ -> NP Alias refcolumns
271+ -- ^ reference column or columns in the reference table
272+ -> OnDeleteClause
273+ -- ^ what to do when reference is deleted
274+ -> OnUpdateClause
275+ -- ^ what to do when reference is updated
276+ -> TableConstraintExpression sch child schemas
277+ ('ForeignKey columns parent refcolumns)
278+foreignKey keys parent refs ondel onupd = UnsafeTableConstraintExpression $
279+ "FOREIGN KEY" <+> parenthesized (renderSQL keys)
280+ <+> "REFERENCES" <+> renderSQL parent
281+ <+> parenthesized (renderSQL refs)
282+ <+> renderSQL ondel
283+ <+> renderSQL onupd
284+
285+-- | A constraint synonym between types involved in a foreign key constraint.
286+type ForeignKeyed schemas
287+ sch
288+ schema
289+ child parent
290+ table reftable
291+ columns refcolumns
292+ constraints cols
293+ reftys tys =
294+ ( Has sch schemas schema
295+ , Has child schema ('Table table)
296+ , Has parent schema ('Table reftable)
297+ , HasAll columns (TableToColumns table) tys
298+ , reftable ~ (constraints :=> cols)
299+ , HasAll refcolumns cols reftys
300+ , SOP.AllZip SamePGType tys reftys
301+ , Uniquely refcolumns constraints )
302+
303+-- | `OnDeleteClause` indicates what to do with rows that reference a deleted row.
304+data OnDeleteClause
305+ = OnDeleteNoAction
306+ -- ^ if any referencing rows still exist when the constraint is checked,
307+ -- an error is raised
308+ | OnDeleteRestrict -- ^ prevents deletion of a referenced row
309+ | OnDeleteCascade
310+ -- ^ specifies that when a referenced row is deleted,
311+ -- row(s) referencing it should be automatically deleted as well
312+ deriving (GHC.Generic,Show,Eq,Ord)
313+instance NFData OnDeleteClause
314+-- | Render `OnDeleteClause`.
315+instance RenderSQL OnDeleteClause where
316+ renderSQL = \case
317+ OnDeleteNoAction -> "ON DELETE NO ACTION"
318+ OnDeleteRestrict -> "ON DELETE RESTRICT"
319+ OnDeleteCascade -> "ON DELETE CASCADE"
320+
321+-- | Analagous to `OnDeleteClause` there is also `OnUpdateClause` which is invoked
322+-- when a referenced column is changed (updated).
323+data OnUpdateClause
324+ = OnUpdateNoAction
325+ -- ^ if any referencing rows has not changed when the constraint is checked,
326+ -- an error is raised
327+ | OnUpdateRestrict -- ^ prevents update of a referenced row
328+ | OnUpdateCascade
329+ -- ^ the updated values of the referenced column(s) should be copied
330+ -- into the referencing row(s)
331+ deriving (GHC.Generic,Show,Eq,Ord)
332+instance NFData OnUpdateClause
333+
334+-- | Render `OnUpdateClause`.
335+instance RenderSQL OnUpdateClause where
336+ renderSQL = \case
337+ OnUpdateNoAction -> "ON UPDATE NO ACTION"
338+ OnUpdateRestrict -> "ON UPDATE RESTRICT"
339+ OnUpdateCascade -> "ON UPDATE CASCADE"
squeal-postgresql/src/Squeal/PostgreSQL/Definition/Type.hsnew file+229
@@ -0,0 +1,229 @@
1+{-|
2+Module: Squeal.PostgreSQL.Definition.Type
3+Description: Create and drop type definitions
4+Copyright: (c) Eitan Chatav, 2017
5+Maintainer: eitan@morphism.tech
6+Stability: experimental
7+
8+Create and drop type definitions.
9+-}
10+
11+{-# LANGUAGE
12+ AllowAmbiguousTypes
13+ , ConstraintKinds
14+ , DeriveAnyClass
15+ , DeriveGeneric
16+ , DerivingStrategies
17+ , FlexibleContexts
18+ , FlexibleInstances
19+ , GADTs
20+ , LambdaCase
21+ , MultiParamTypeClasses
22+ , OverloadedLabels
23+ , OverloadedStrings
24+ , RankNTypes
25+ , ScopedTypeVariables
26+ , TypeApplications
27+ , TypeInType
28+ , TypeOperators
29+ , UndecidableSuperClasses
30+#-}
31+
32+module Squeal.PostgreSQL.Definition.Type
33+ ( createTypeEnum
34+ , createTypeEnumFrom
35+ , createTypeComposite
36+ , createTypeCompositeFrom
37+ , createTypeRange
38+ , createDomain
39+ , dropType
40+ , dropTypeIfExists
41+ ) where
42+
43+import Data.ByteString
44+import Data.Monoid
45+import GHC.TypeLits
46+import Prelude hiding ((.), id)
47+
48+import qualified Generics.SOP as SOP
49+
50+import Squeal.PostgreSQL.Alias
51+import Squeal.PostgreSQL.Expression.Logic
52+import Squeal.PostgreSQL.Expression.Type
53+import Squeal.PostgreSQL.Definition
54+import Squeal.PostgreSQL.List
55+import Squeal.PostgreSQL.PG
56+import Squeal.PostgreSQL.Render
57+import Squeal.PostgreSQL.Schema
58+
59+-- $setup
60+-- >>> import Squeal.PostgreSQL
61+-- >>> import qualified GHC.Generics as GHC
62+-- >>> import qualified Generics.SOP as SOP
63+
64+-- | Enumerated types are created using the `createTypeEnum` command, for example
65+--
66+-- >>> printSQL $ (createTypeEnum #mood (label @"sad" :* label @"ok" :* label @"happy") :: Definition (Public '[]) '["public" ::: '["mood" ::: 'Typedef ('PGenum '["sad","ok","happy"])]])
67+-- CREATE TYPE "mood" AS ENUM ('sad', 'ok', 'happy');
68+createTypeEnum
69+ :: (KnownSymbol enum, Has sch schemas schema, SOP.All KnownSymbol labels)
70+ => QualifiedAlias sch enum
71+ -- ^ name of the user defined enumerated type
72+ -> NP PGlabel labels
73+ -- ^ labels of the enumerated type
74+ -> Definition schemas (Alter sch (Create enum ('Typedef ('PGenum labels)) schema) schemas)
75+createTypeEnum enum labels = UnsafeDefinition $
76+ "CREATE" <+> "TYPE" <+> renderSQL enum <+> "AS" <+> "ENUM" <+>
77+ parenthesized (renderSQL labels) <> ";"
78+
79+-- | Enumerated types can also be generated from a Haskell type, for example
80+--
81+-- >>> data Schwarma = Beef | Lamb | Chicken deriving GHC.Generic
82+-- >>> instance SOP.Generic Schwarma
83+-- >>> instance SOP.HasDatatypeInfo Schwarma
84+-- >>> :{
85+-- let
86+-- createSchwarma :: Definition (Public '[]) '["public" ::: '["schwarma" ::: 'Typedef (PG (Enumerated Schwarma))]]
87+-- createSchwarma = createTypeEnumFrom @Schwarma #schwarma
88+-- in
89+-- printSQL createSchwarma
90+-- :}
91+-- CREATE TYPE "schwarma" AS ENUM ('Beef', 'Lamb', 'Chicken');
92+createTypeEnumFrom
93+ :: forall hask sch enum schemas schema.
94+ ( SOP.Generic hask
95+ , SOP.All KnownSymbol (LabelsPG hask)
96+ , KnownSymbol enum
97+ , Has sch schemas schema )
98+ => QualifiedAlias sch enum
99+ -- ^ name of the user defined enumerated type
100+ -> Definition schemas (Alter sch (Create enum ('Typedef (PG (Enumerated hask))) schema) schemas)
101+createTypeEnumFrom enum = createTypeEnum enum
102+ (SOP.hpure label :: NP PGlabel (LabelsPG hask))
103+
104+{- | `createTypeComposite` creates a composite type. The composite type is
105+specified by a list of attribute names and data types.
106+
107+>>> :{
108+type PGcomplex = 'PGcomposite
109+ '[ "real" ::: 'NotNull 'PGfloat8
110+ , "imaginary" ::: 'NotNull 'PGfloat8 ]
111+:}
112+
113+>>> :{
114+let
115+ setup :: Definition (Public '[]) '["public" ::: '["complex" ::: 'Typedef PGcomplex]]
116+ setup = createTypeComposite #complex
117+ (float8 `as` #real :* float8 `as` #imaginary)
118+in printSQL setup
119+:}
120+CREATE TYPE "complex" AS ("real" float8, "imaginary" float8);
121+-}
122+createTypeComposite
123+ :: (KnownSymbol ty, Has sch schemas schema, SOP.SListI fields)
124+ => QualifiedAlias sch ty
125+ -- ^ name of the user defined composite type
126+ -> NP (Aliased (TypeExpression schemas)) fields
127+ -- ^ list of attribute names and data types
128+ -> Definition schemas (Alter sch (Create ty ('Typedef ('PGcomposite fields)) schema) schemas)
129+createTypeComposite ty fields = UnsafeDefinition $
130+ "CREATE" <+> "TYPE" <+> renderSQL ty <+> "AS" <+> parenthesized
131+ (renderCommaSeparated renderField fields) <> ";"
132+ where
133+ renderField :: Aliased (TypeExpression schemas) x -> ByteString
134+ renderField (typ `As` alias) =
135+ renderSQL alias <+> renderSQL typ
136+
137+-- | Composite types can also be generated from a Haskell type, for example
138+--
139+-- >>> data Complex = Complex {real :: Double, imaginary :: Double} deriving GHC.Generic
140+-- >>> instance SOP.Generic Complex
141+-- >>> instance SOP.HasDatatypeInfo Complex
142+-- >>> type Schema = '["complex" ::: 'Typedef (PG (Composite Complex))]
143+-- >>> :{
144+-- let
145+-- createComplex :: Definition (Public '[]) (Public Schema)
146+-- createComplex = createTypeCompositeFrom @Complex #complex
147+-- in
148+-- printSQL createComplex
149+-- :}
150+-- CREATE TYPE "complex" AS ("real" float8, "imaginary" float8);
151+createTypeCompositeFrom
152+ :: forall hask sch ty schemas schema.
153+ ( SOP.All (FieldTyped schemas) (RowPG hask)
154+ , KnownSymbol ty
155+ , Has sch schemas schema )
156+ => QualifiedAlias sch ty
157+ -- ^ name of the user defined composite type
158+ -> Definition schemas (Alter sch (Create ty ( 'Typedef (PG (Composite hask))) schema) schemas)
159+createTypeCompositeFrom ty = createTypeComposite ty
160+ (SOP.hcpure (SOP.Proxy :: SOP.Proxy (FieldTyped schemas)) fieldtype
161+ :: NP (Aliased (TypeExpression schemas)) (RowPG hask))
162+
163+{-|
164+`createDomain` creates a new domain. A domain is essentially a data type
165+with constraints (restrictions on the allowed set of values).
166+
167+Domains are useful for abstracting common constraints on fields
168+into a single location for maintenance. For example, several tables might
169+contain email address columns, all requiring the same `check` constraint
170+to verify the address syntax. Define a domain rather than setting up
171+each table's constraint individually.
172+
173+>>> :{
174+let
175+ createPositive :: Definition (Public '[]) (Public '["positive" ::: 'Typedef 'PGfloat4])
176+ createPositive = createDomain #positive real (#value .> 0 .&& (#value & isNotNull))
177+in printSQL createPositive
178+:}
179+CREATE DOMAIN "positive" AS real CHECK ((("value" > 0) AND "value" IS NOT NULL));
180+-}
181+createDomain
182+ :: (Has sch schemas schema, KnownSymbol dom)
183+ => QualifiedAlias sch dom
184+ -> (forall null. TypeExpression schemas (null ty))
185+ -> (forall tab. Condition '[] '[] 'Ungrouped schemas '[] '[tab ::: '["value" ::: 'Null ty]])
186+ -> Definition schemas (Alter sch (Create dom ('Typedef ty) schema) schemas)
187+createDomain dom ty condition =
188+ UnsafeDefinition $ "CREATE DOMAIN" <+> renderSQL dom
189+ <+> "AS" <+> renderTypeExpression ty
190+ <+> "CHECK" <+> parenthesized (renderSQL condition) <> ";"
191+
192+{- |
193+>>> :{
194+let
195+ createSmallIntRange :: Definition (Public '[]) (Public '["int2range" ::: 'Typedef ('PGrange 'PGint2)])
196+ createSmallIntRange = createTypeRange #int2range int2
197+in printSQL createSmallIntRange
198+:}
199+CREATE TYPE "int2range" AS RANGE (subtype = int2);
200+-}
201+createTypeRange
202+ :: (Has sch schemas schema, KnownSymbol range)
203+ => QualifiedAlias sch range
204+ -> (forall null. TypeExpression schemas (null ty))
205+ -> Definition schemas (Alter sch (Create range ('Typedef ('PGrange ty)) schema) schemas)
206+createTypeRange range ty = UnsafeDefinition $
207+ "CREATE" <+> "TYPE" <+> renderSQL range <+> "AS" <+> "RANGE" <+>
208+ parenthesized ("subtype" <+> "=" <+> renderTypeExpression ty) <> ";"
209+
210+-- | Drop a type.
211+--
212+-- >>> data Schwarma = Beef | Lamb | Chicken deriving GHC.Generic
213+-- >>> instance SOP.Generic Schwarma
214+-- >>> instance SOP.HasDatatypeInfo Schwarma
215+-- >>> printSQL (dropType #schwarma :: Definition '["public" ::: '["schwarma" ::: 'Typedef (PG (Enumerated Schwarma))]] (Public '[]))
216+-- DROP TYPE "schwarma";
217+dropType
218+ :: (Has sch schemas schema, KnownSymbol td)
219+ => QualifiedAlias sch td
220+ -- ^ name of the user defined type
221+ -> Definition schemas (Alter sch (DropSchemum td 'Typedef schema) schemas)
222+dropType tydef = UnsafeDefinition $ "DROP" <+> "TYPE" <+> renderSQL tydef <> ";"
223+
224+dropTypeIfExists
225+ :: (Has sch schemas schema, KnownSymbol td)
226+ => QualifiedAlias sch td
227+ -- ^ name of the user defined type
228+ -> Definition schemas (Alter sch (DropSchemumIfExists td 'Typedef schema) schemas)
229+dropTypeIfExists tydef = UnsafeDefinition $ "DROP" <+> "TYPE" <+> renderSQL tydef <> ";"
squeal-postgresql/src/Squeal/PostgreSQL/Definition/View.hsnew file+104
@@ -0,0 +1,104 @@
1+{-|
2+Module: Squeal.PostgreSQL.Definition.View
3+Description: Create and drop view definitions
4+Copyright: (c) Eitan Chatav, 2017
5+Maintainer: eitan@morphism.tech
6+Stability: experimental
7+
8+Create and drop view definitions.
9+-}
10+
11+{-# LANGUAGE
12+ AllowAmbiguousTypes
13+ , ConstraintKinds
14+ , DeriveAnyClass
15+ , DeriveGeneric
16+ , DerivingStrategies
17+ , FlexibleContexts
18+ , FlexibleInstances
19+ , GADTs
20+ , LambdaCase
21+ , MultiParamTypeClasses
22+ , OverloadedLabels
23+ , OverloadedStrings
24+ , RankNTypes
25+ , ScopedTypeVariables
26+ , TypeApplications
27+ , TypeInType
28+ , TypeOperators
29+ , UndecidableSuperClasses
30+#-}
31+
32+module Squeal.PostgreSQL.Definition.View
33+ ( createView
34+ , createOrReplaceView
35+ , dropView
36+ , dropViewIfExists
37+ ) where
38+
39+import GHC.TypeLits
40+
41+import Squeal.PostgreSQL.Alias
42+import Squeal.PostgreSQL.Definition
43+import Squeal.PostgreSQL.Query
44+import Squeal.PostgreSQL.Render
45+import Squeal.PostgreSQL.Schema
46+
47+-- $setup
48+-- >>> import Squeal.PostgreSQL
49+
50+{- | Create a view.
51+>>> type ABC = '["a" ::: 'NoDef :=> 'Null 'PGint4, "b" ::: 'NoDef :=> 'Null 'PGint4, "c" ::: 'NoDef :=> 'Null 'PGint4]
52+>>> type BC = '["b" ::: 'Null 'PGint4, "c" ::: 'Null 'PGint4]
53+>>> :{
54+let
55+ definition :: Definition
56+ '[ "public" ::: '["abc" ::: 'Table ('[] :=> ABC)]]
57+ '[ "public" ::: '["abc" ::: 'Table ('[] :=> ABC), "bc" ::: 'View BC]]
58+ definition =
59+ createView #bc (select_ (#b :* #c) (from (table #abc)))
60+in printSQL definition
61+:}
62+CREATE VIEW "bc" AS SELECT "b" AS "b", "c" AS "c" FROM "abc" AS "abc";
63+-}
64+createView
65+ :: (Has sch schemas schema, KnownSymbol vw)
66+ => QualifiedAlias sch vw -- ^ the name of the view to add
67+ -> Query '[] '[] schemas '[] view -- ^ query
68+ -> Definition schemas (Alter sch (Create vw ('View view) schema) schemas)
69+createView alias query = UnsafeDefinition $
70+ "CREATE" <+> "VIEW" <+> renderSQL alias <+> "AS"
71+ <+> renderQuery query <> ";"
72+
73+createOrReplaceView
74+ :: (Has sch schemas schema, KnownSymbol vw)
75+ => QualifiedAlias sch vw -- ^ the name of the view to add
76+ -> Query '[] '[] schemas '[] view -- ^ query
77+ -> Definition schemas (Alter sch (CreateOrReplace vw ('View view) schema) schemas)
78+createOrReplaceView alias query = UnsafeDefinition $
79+ "CREATE OR REPLACE VIEW" <+> renderSQL alias <+> "AS"
80+ <+> renderQuery query <> ";"
81+
82+-- | Drop a view.
83+--
84+-- >>> :{
85+-- let
86+-- definition :: Definition
87+-- '[ "public" ::: '["abc" ::: 'Table ('[] :=> '["a" ::: 'NoDef :=> 'Null 'PGint4, "b" ::: 'NoDef :=> 'Null 'PGint4, "c" ::: 'NoDef :=> 'Null 'PGint4])
88+-- , "bc" ::: 'View ('["b" ::: 'Null 'PGint4, "c" ::: 'Null 'PGint4])]]
89+-- '[ "public" ::: '["abc" ::: 'Table ('[] :=> '["a" ::: 'NoDef :=> 'Null 'PGint4, "b" ::: 'NoDef :=> 'Null 'PGint4, "c" ::: 'NoDef :=> 'Null 'PGint4])]]
90+-- definition = dropView #bc
91+-- in printSQL definition
92+-- :}
93+-- DROP VIEW "bc";
94+dropView
95+ :: (Has sch schemas schema, KnownSymbol vw)
96+ => QualifiedAlias sch vw -- ^ view to remove
97+ -> Definition schemas (Alter sch (DropSchemum vw 'View schema) schemas)
98+dropView vw = UnsafeDefinition $ "DROP VIEW" <+> renderSQL vw <> ";"
99+
100+dropViewIfExists
101+ :: (Has sch schemas schema, KnownSymbol vw)
102+ => QualifiedAlias sch vw -- ^ view to remove
103+ -> Definition schemas (Alter sch (DropIfExists vw schema) schemas)
104+dropViewIfExists vw = UnsafeDefinition $ "DROP VIEW IF EXISTS" <+> renderSQL vw <> ";"
squeal-postgresql/src/Squeal/PostgreSQL/Expression.hs+209−2239
@@ -1,14 +1,13 @@
1{-|
1{-|
2Module: Squeal.PostgreSQL.Expression
2Module: Squeal.PostgreSQL.Expression
3Description: Squeal expressions
3Description: Squeal expressions
4−Copyright: (c) Eitan Chatav, 2017
4+Copyright: (c) Eitan Chatav, 2019
5Maintainer: eitan@morphism.tech
5Maintainer: eitan@morphism.tech
6Stability: experimental
6Stability: experimental
7
7
8Squeal expressions are the atoms used to build statements.
8Squeal expressions are the atoms used to build statements.
9-}
9-}
10
10
11−{-# OPTIONS_GHC -fno-warn-redundant-constraints #-}
12{-# LANGUAGE
11{-# LANGUAGE
13 AllowAmbiguousTypes
12 AllowAmbiguousTypes
14 , ConstraintKinds
13 , ConstraintKinds
@@ -35,377 +34,213 @@ module Squeal.PostgreSQL.Expression
35 ( -- * Expression
34 ( -- * Expression
36 Expression (..)
35 Expression (..)
37 , Expr
36 , Expr
37+ , type (-->)
38+ , FunctionDB
39+ , unsafeFunction
40+ , function
41+ , unsafeLeftOp
42+ , leftOp
43+ , unsafeRightOp
44+ , rightOp
38 , Operator
45 , Operator
39− , (:-->)
46+ , OperatorDB
40− , HasParameter (parameter)
41− , param
42− -- ** Null
43− , null_
44− , notNull
45− , coalesce
46− , fromNull
47− , isNull
48− , isNotNull
49− , matchNull
50− , nullIf
51− -- ** Collections
52− , array
53− , cardinality
54− , index
55− , row
56− , field
57− , PGSubset (..)
58− -- ** Functions
59 , unsafeBinaryOp
47 , unsafeBinaryOp
60− , unsafeUnaryOpL
48+ , binaryOp
61− , unsafeFunction
49+ , FunctionVar
62− , unsafeVariadicFunction
50+ , unsafeFunctionVar
63− , atan2_
51+ , type (--->)
64− , cast
52+ , FunctionNDB
65− , quot_
53+ , unsafeFunctionN
66− , rem_
54+ , functionN
67− , trunc
55+ , PGSubset (..)
68− , round_
56+ , PGIntersect (..)
69− , ceiling_
70− , greatest
71− , least
72− , litChar
73− -- ** Conditions
74− , true
75− , false
76− , not_
77− , (.&&)
78− , (.||)
79− , Condition
80− , caseWhenThenElse
81− , ifThenElse
82− , (.==)
83− , (./=)
84− , (.>=)
85− , (.<)
86− , (.<=)
87− , (.>)
88− , between
89− , notBetween
90− , betweenSymmetric
91− , notBetweenSymmetric
92− , isDistinctFrom
93− , isNotDistinctFrom
94− , isTrue
95− , isNotTrue
96− , isFalse
97− , isNotFalse
98− , isUnknown
99− , isNotUnknown
100− -- ** Time
101− , currentDate
102− , currentTime
103− , currentTimestamp
104− , localTime
105− , localTimestamp
106− , TimeOp (..)
107− , makeDate
108− , makeTime
109− , makeTimestamp
110− , makeTimestamptz
111− -- ** Text
112− , lower
113− , upper
114− , charLength
115− , like
116− , ilike
117− -- ** Json
118− -- *** Json and Jsonb operators
119− , (.->)
120− , (.->>)
121− , (.#>)
122− , (.#>>)
123− -- *** Jsonb operators
124− , (.?)
125− , (.?|)
126− , (.?&)
127− , (.-.)
128− , (#-.)
129− -- *** Functions
130− , jsonLit
131− , jsonbLit
132− , toJson
133− , toJsonb
134− , arrayToJson
135− , rowToJson
136− , jsonBuildArray
137− , jsonbBuildArray
138− , jsonBuildObject
139− , jsonbBuildObject
140− , jsonObject
141− , jsonbObject
142− , jsonZipObject
143− , jsonbZipObject
144− , jsonArrayLength
145− , jsonbArrayLength
146− , jsonExtractPath
147− , jsonbExtractPath
148− , jsonExtractPathAsText
149− , jsonbExtractPathAsText
150− , jsonTypeof
151− , jsonbTypeof
152− , jsonStripNulls
153− , jsonbStripNulls
154− , jsonbSet
155− , jsonbInsert
156− , jsonbPretty
157− -- ** Text Search
158− , (@@)
159− , (.&)
160− , (.|)
161− , (.!)
162− , (<->)
163− , arrayToTSvector
164− , tsvectorLength
165− , numnode
166− , plainToTSquery
167− , phraseToTSquery
168− , websearchToTSquery
169− , queryTree
170− , toTSquery
171− , toTSvector
172− , setWeight
173− , strip
174− , jsonToTSvector
175− , jsonbToTSvector
176− , tsDelete
177− , tsFilter
178− , tsHeadline
179− -- ** Aggregation
180− , Aggregate (..)
181− , Distinction (..)
182− , PGAvg
183− -- * Window Functions
184− , WindowDefinition (..)
185− , partitionBy
186− , WindowFunction (..)
187− , rank
188− , rowNumber
189− , denseRank
190− , percentRank
191− , cumeDist
192− , ntile
193− , lag
194− , lead
195− , firstValue
196− , lastValue
197− , nthValue
198− -- * Sorting
199− , SortExpression (..)
200− , OrderBy (..)
201− -- * Types
202− , TypeExpression (..)
203− , PGTyped (..)
204− , typedef
205− , typetable
206− , typeview
207− , bool
208− , int2
209− , smallint
210− , int4
211− , int
212− , integer
213− , int8
214− , bigint
215− , numeric
216− , float4
217− , real
218− , float8
219− , doublePrecision
220− , money
221− , text
222− , char
223− , character
224− , varchar
225− , characterVarying
226− , bytea
227− , timestamp
228− , timestampWithTimeZone
229− , date
230− , time
231− , timeWithTimeZone
232− , interval
233− , uuid
234− , inet
235− , json
236− , jsonb
237− , vararray
238− , fixarray
239− , tsvector
240− , tsquery
241 -- * Re-export
57 -- * Re-export
242 , (&)
58 , (&)
243− , NP (..)
244− , (:*:) (..)
245 , K (..)
59 , K (..)
60+ , unK
246 ) where
61 ) where
247
62
248import Control.Category
63import Control.Category
249import Control.DeepSeq
64import Control.DeepSeq
250import Data.ByteString (ByteString)
65import Data.ByteString (ByteString)
251−import Data.ByteString.Lazy (toStrict)
252import Data.Function ((&))
66import Data.Function ((&))
253import Data.Semigroup hiding (All)
67import Data.Semigroup hiding (All)
254−import qualified Data.Aeson as JSON
255import Data.String
68import Data.String
256−import Data.Word
257import Generics.SOP hiding (All, from)
69import Generics.SOP hiding (All, from)
258−import GHC.Generics ((:*:) (..))
259import GHC.OverloadedLabels
70import GHC.OverloadedLabels
260import GHC.TypeLits
71import GHC.TypeLits
261import Numeric
72import Numeric
262import Prelude hiding (id, (.))
73import Prelude hiding (id, (.))
263
74
264−import qualified Data.ByteString as ByteString
265import qualified GHC.Generics as GHC
75import qualified GHC.Generics as GHC
266−import qualified Generics.SOP as SOP
267
76
77+import Squeal.PostgreSQL.Alias
78+import Squeal.PostgreSQL.List
268import Squeal.PostgreSQL.Render
79import Squeal.PostgreSQL.Render
269import Squeal.PostgreSQL.Schema
80import Squeal.PostgreSQL.Schema
270
81
82+-- $setup
83+-- >>> import Squeal.PostgreSQL
84+
271{-----------------------------------------
85{-----------------------------------------
272column expressions
86column expressions
273-----------------------------------------}
87-----------------------------------------}
274
88
275{- | `Expression`s are used in a variety of contexts,
89{- | `Expression`s are used in a variety of contexts,
90+such as in the target `Squeal.PostgreSQL.Query.List` of the
276−such as in the target list of the `Squeal.PostgreSQL.Query.select` command,
91+`Squeal.PostgreSQL.Query.select` command,
277as new column values in `Squeal.PostgreSQL.Manipulation.insertRow` or
92as new column values in `Squeal.PostgreSQL.Manipulation.insertRow` or
278`Squeal.PostgreSQL.Manipulation.update`,
93`Squeal.PostgreSQL.Manipulation.update`,
279−or in search `Condition`s in a number of commands.
94+or in search `Squeal.PostgreSQL.Logic.Condition`s in a number of commands.
280
95
281The expression syntax allows the calculation of
96The expression syntax allows the calculation of
282values from primitive expression using arithmetic, logical,
97values from primitive expression using arithmetic, logical,
283and other operations.
98and other operations.
99+
100+The type parameters of `Expression` are
101+
102+* @outer :: @ `FromType`, the @from@ clauses of any outer queries in which
103+ the `Expression` is a correlated subquery expression;
104+* @commons :: @ `FromType`, the `Squeal.PostgreSQL.Query.CommonTableExpression`s
105+ that are in scope for the `Expression`;
106+* @grp :: @ `Grouping`, the `Grouping` of the @from@ clause which may limit
107+ which columns may be referenced by alias;
108+* @schemas :: @ `SchemasType`, the schemas of your database that are in
109+ scope for the `Expression`;
110+* @from :: @ `FromType`, the @from@ clause which the `Expression` may use
111+ to reference columns by alias;
112+* @ty :: @ `NullityType`, the type of the `Expression`.
284-}
113-}
285newtype Expression
114newtype Expression
286 (outer :: FromType)
115 (outer :: FromType)
287− (grp :: Grouping)
288 (commons :: FromType)
116 (commons :: FromType)
117+ (grp :: Grouping)
289 (schemas :: SchemasType)
118 (schemas :: SchemasType)
290 (params :: [NullityType])
119 (params :: [NullityType])
291 (from :: FromType)
120 (from :: FromType)
292 (ty :: NullityType)
121 (ty :: NullityType)
293 = UnsafeExpression { renderExpression :: ByteString }
122 = UnsafeExpression { renderExpression :: ByteString }
294 deriving (GHC.Generic,Show,Eq,Ord,NFData)
123 deriving (GHC.Generic,Show,Eq,Ord,NFData)
295−instance RenderSQL (Expression outer grp commons schemas params from ty) where
124+instance RenderSQL (Expression outer commons grp schemas params from ty) where
296 renderSQL = renderExpression
125 renderSQL = renderExpression
297
126
298-- | An `Expr` is a closed `Expression`.
127-- | An `Expr` is a closed `Expression`.
128+-- It is a F@RankNType@ but don't be scared.
129+-- Think of it as an expression which sees no
130+-- namespaces, so you can't use parameters
131+-- or alias references. It can be used as
132+-- a simple piece of more complex `Expression`s.
299type Expr x
133type Expr x
300− = forall outer grp commons schemas params from
134+ = forall outer commons grp schemas params from
301− . Expression outer grp commons schemas params from x
135+ . Expression outer commons grp schemas params from x
302 -- ^ cannot reference aliases
136 -- ^ cannot reference aliases
303
137
138+-- | A @RankNType@ for binary operators.
304type Operator x1 x2 y
139type Operator x1 x2 y
305− = forall outer grp commons schemas params from
140+ = forall outer commons grp schemas params from
306− . Expression outer grp commons schemas params from x1
141+ . Expression outer commons grp schemas params from x1
307 -- ^ left input
142 -- ^ left input
308− -> Expression outer grp commons schemas params from x2
143+ -> Expression outer commons grp schemas params from x2
309 -- ^ right input
144 -- ^ right input
310− -> Expression outer grp commons schemas params from y
145+ -> Expression outer commons grp schemas params from y
311 -- ^ output
146 -- ^ output
312
147
313−type (:-->) x y
148+type OperatorDB schemas x1 x2 y
149+ = forall outer commons grp params from
150+ . Expression outer commons grp schemas params from x1
151+ -- ^ left input
152+ -> Expression outer commons grp schemas params from x2
153+ -- ^ right input
154+ -> Expression outer commons grp schemas params from y
155+ -- ^ output
156+
157+-- | A @RankNType@ for functions with a single argument.
158+-- These could be either function calls or unary operators.
159+-- This is a subtype of the usual Haskell function type `Prelude.->`,
160+-- indeed a subcategory as it is closed under the usual
161+-- `Prelude..` and `Prelude.id`.
162+type (-->) x y
314− = forall outer grp commons schemas params from
163+ = forall outer commons grp schemas params from
315− . Expression outer grp commons schemas params from x
164+ . Expression outer commons grp schemas params from x
316 -- ^ input
165 -- ^ input
317− -> Expression outer grp commons schemas params from y
166+ -> Expression outer commons grp schemas params from y
318 -- ^ output
167 -- ^ output
319
168
320−type FunctionHet xs y
169+type FunctionDB schemas x y
321− = forall outer grp commons schemas params from
170+ = forall outer commons grp params from
322− . NP (Expression outer grp commons schemas params from) xs
171+ . Expression outer commons grp schemas params from x
323− -- ^ inputs
172+ -- ^ input
324− -> Expression outer grp commons schemas params from y
173+ -> Expression outer commons grp schemas params from y
325 -- ^ output
174 -- ^ output
326
175
327−type FunctionHom x0 x1 y
176+{- | A @RankNType@ for functions with a fixed-length list of heterogeneous arguments.
177+Use the `*:` operator to end your argument lists, like so.
178+
179+>>> printSQL (unsafeFunctionN "fun" (true :* false :* localTime *: true))
180+fun(TRUE, FALSE, LOCALTIME, TRUE)
181+-}
182+type (--->) xs y
328− = forall outer grp commons schemas params from
183+ = forall outer commons grp schemas params from
329− . [Expression outer grp commons schemas params from x0]
184+ . NP (Expression outer commons grp schemas params from) xs
330 -- ^ inputs
185 -- ^ inputs
331− -> Expression outer grp commons schemas params from x1
186+ -> Expression outer commons grp schemas params from y
332− -- ^ must have at least 1 input
333− -> Expression outer grp commons schemas params from y
334 -- ^ output
187 -- ^ output
335
188
336−unsafeFunctionHom :: ByteString -> FunctionHom x0 x1 y
189+type FunctionNDB schemas xs y
337−unsafeFunctionHom fun xs x = UnsafeExpression $ fun <> parenthesized
190+ = forall outer commons grp params from
338− (commaSeparated (renderSQL <$> xs) <> ", " <> renderSQL x)
191+ . NP (Expression outer commons grp schemas params from) xs
192+ -- ^ inputs
193+ -> Expression outer commons grp schemas params from y
194+ -- ^ output
339
195
340−{- | A `HasParameter` constraint is used to indicate a value that is
196+{- | A @RankNType@ for functions with a variable-length list of
341−supplied externally to a SQL statement.
197+homogeneous arguments and at least 1 more argument.
342−`Squeal.PostgreSQL.PQ.manipulateParams`,
343−`Squeal.PostgreSQL.PQ.queryParams` and
344−`Squeal.PostgreSQL.PQ.traversePrepared` support specifying data values
345−separately from the SQL command string, in which case `param`s are used to
346−refer to the out-of-line data values.
347-}
198-}
348−class KnownNat n => HasParameter
199+type FunctionVar x0 x1 y
349− (n :: Nat)
200+ = forall outer commons grp schemas params from
350− (params :: [NullityType])
351− (ty :: NullityType)
352− | n params -> ty where
353− -- | `parameter` takes a `Nat` using type application and a `TypeExpression`.
354− --
355− -- >>> let expr = parameter @1 int4 :: Expression outer grp '[] schemas '[ 'Null 'PGint4] from ('Null 'PGint4)
201+ . [Expression outer commons grp schemas params from x0]
356− -- >>> printSQL expr
202+ -- ^ inputs
357− -- ($1 :: int4)
358− parameter
359− :: TypeExpression schemas ty
360− -> Expression outer grp commons schemas params from ty
203+ -> Expression outer commons grp schemas params from x1
361− parameter ty = UnsafeExpression $ parenthesized $
204+ -- ^ must have at least 1 input
362− "$" <> renderNat @n <+> "::"
205+ -> Expression outer commons grp schemas params from y
363− <+> renderSQL ty
206+ -- ^ output
364−instance {-# OVERLAPPING #-} HasParameter 1 (ty1:tys) ty1
365−instance {-# OVERLAPPABLE #-} (KnownNat n, HasParameter (n-1) params ty)
366− => HasParameter n (ty' : params) ty
367
207
368−-- | `param` takes a `Nat` using type application and for basic types,
208+{- | >>> printSQL (unsafeFunctionVar "greatest" [true, null_] false)
369−-- infers a `TypeExpression`.
209+greatest(TRUE, NULL, FALSE)
370−--
210+-}
371−-- >>> let expr = param @1 :: Expression outer grp commons schemas '[ 'Null 'PGint4] from ('Null 'PGint4)
211+unsafeFunctionVar :: ByteString -> FunctionVar x0 x1 y
372−-- >>> printSQL expr
212+unsafeFunctionVar fun xs x = UnsafeExpression $ fun <> parenthesized
373−-- ($1 :: int4)
213+ (commaSeparated (renderSQL <$> xs) <> ", " <> renderSQL x)
374−param
375− :: forall n outer commons schemas params from grp ty
376− . (PGTyped schemas ty, HasParameter n params ty)
377− => Expression outer grp commons schemas params from ty -- ^ param
378−param = parameter @n (pgtype @schemas)
379
214
380instance (HasUnique tab (Join outer from) row, Has col row ty)
215instance (HasUnique tab (Join outer from) row, Has col row ty)
381− => IsLabel col (Expression outer 'Ungrouped commons schemas params from ty) where
216+ => IsLabel col (Expression outer commons 'Ungrouped schemas params from ty) where
382 fromLabel = UnsafeExpression $ renderSQL (Alias @col)
217 fromLabel = UnsafeExpression $ renderSQL (Alias @col)
383instance (HasUnique tab (Join outer from) row, Has col row ty, tys ~ '[ty])
218instance (HasUnique tab (Join outer from) row, Has col row ty, tys ~ '[ty])
384− => IsLabel col (NP (Expression outer 'Ungrouped commons schemas params from) tys) where
219+ => IsLabel col (NP (Expression outer commons 'Ungrouped schemas params from) tys) where
385 fromLabel = fromLabel @col :* Nil
220 fromLabel = fromLabel @col :* Nil
386instance (HasUnique tab (Join outer from) row, Has col row ty, column ~ (col ::: ty))
221instance (HasUnique tab (Join outer from) row, Has col row ty, column ~ (col ::: ty))
387 => IsLabel col
222 => IsLabel col
388− (Aliased (Expression outer 'Ungrouped commons schemas params from) column) where
223+ (Aliased (Expression outer commons 'Ungrouped schemas params from) column) where
389 fromLabel = fromLabel @col `As` Alias
224 fromLabel = fromLabel @col `As` Alias
390instance (HasUnique tab (Join outer from) row, Has col row ty, columns ~ '[col ::: ty])
225instance (HasUnique tab (Join outer from) row, Has col row ty, columns ~ '[col ::: ty])
391 => IsLabel col
226 => IsLabel col
392− (NP (Aliased (Expression outer 'Ungrouped commons schemas params from)) columns) where
227+ (NP (Aliased (Expression outer commons 'Ungrouped schemas params from)) columns) where
393 fromLabel = fromLabel @col :* Nil
228 fromLabel = fromLabel @col :* Nil
394
229
395instance (Has tab (Join outer from) row, Has col row ty)
230instance (Has tab (Join outer from) row, Has col row ty)
396− => IsQualified tab col (Expression outer 'Ungrouped commons schemas params from ty) where
231+ => IsQualified tab col (Expression outer commons 'Ungrouped schemas params from ty) where
397 tab ! col = UnsafeExpression $
232 tab ! col = UnsafeExpression $
398 renderSQL tab <> "." <> renderSQL col
233 renderSQL tab <> "." <> renderSQL col
399instance (Has tab (Join outer from) row, Has col row ty, tys ~ '[ty])
234instance (Has tab (Join outer from) row, Has col row ty, tys ~ '[ty])
400− => IsQualified tab col (NP (Expression outer 'Ungrouped commons schemas params from) tys) where
235+ => IsQualified tab col (NP (Expression outer commons 'Ungrouped schemas params from) tys) where
401 tab ! col = tab ! col :* Nil
236 tab ! col = tab ! col :* Nil
402instance (Has tab (Join outer from) row, Has col row ty, column ~ (col ::: ty))
237instance (Has tab (Join outer from) row, Has col row ty, column ~ (col ::: ty))
403 => IsQualified tab col
238 => IsQualified tab col
404− (Aliased (Expression outer 'Ungrouped commons schemas params from) column) where
239+ (Aliased (Expression outer commons 'Ungrouped schemas params from) column) where
405 tab ! col = tab ! col `As` col
240 tab ! col = tab ! col `As` col
406instance (Has tab (Join outer from) row, Has col row ty, columns ~ '[col ::: ty])
241instance (Has tab (Join outer from) row, Has col row ty, columns ~ '[col ::: ty])
407 => IsQualified tab col
242 => IsQualified tab col
408− (NP (Aliased (Expression outer 'Ungrouped commons schemas params from)) columns) where
243+ (NP (Aliased (Expression outer commons 'Ungrouped schemas params from)) columns) where
409 tab ! col = tab ! col :* Nil
244 tab ! col = tab ! col :* Nil
410
245
411instance
246instance
@@ -413,7 +248,7 @@ instance
413 , Has col row ty
248 , Has col row ty
414 , GroupedBy tab col bys
249 , GroupedBy tab col bys
415 ) => IsLabel col
250 ) => IsLabel col
416− (Expression outer ('Grouped bys) commons schemas params from ty) where
251+ (Expression outer commons ('Grouped bys) schemas params from ty) where
417 fromLabel = UnsafeExpression $ renderSQL (Alias @col)
252 fromLabel = UnsafeExpression $ renderSQL (Alias @col)
418instance
253instance
419 ( HasUnique tab (Join outer from) row
254 ( HasUnique tab (Join outer from) row
@@ -421,7 +256,7 @@ instance
421 , GroupedBy tab col bys
256 , GroupedBy tab col bys
422 , tys ~ '[ty]
257 , tys ~ '[ty]
423 ) => IsLabel col
258 ) => IsLabel col
424− (NP (Expression outer ('Grouped bys) commons schemas params from) tys) where
259+ (NP (Expression outer commons ('Grouped bys) schemas params from) tys) where
425 fromLabel = fromLabel @col :* Nil
260 fromLabel = fromLabel @col :* Nil
426instance
261instance
427 ( HasUnique tab (Join outer from) row
262 ( HasUnique tab (Join outer from) row
@@ -429,7 +264,7 @@ instance
429 , GroupedBy tab col bys
264 , GroupedBy tab col bys
430 , column ~ (col ::: ty)
265 , column ~ (col ::: ty)
431 ) => IsLabel col
266 ) => IsLabel col
432− (Aliased (Expression outer ('Grouped bys) commons schemas params from) column) where
267+ (Aliased (Expression outer commons ('Grouped bys) schemas params from) column) where
433 fromLabel = fromLabel @col `As` Alias
268 fromLabel = fromLabel @col `As` Alias
434instance
269instance
435 ( HasUnique tab (Join outer from) row
270 ( HasUnique tab (Join outer from) row
@@ -437,7 +272,7 @@ instance
437 , GroupedBy tab col bys
272 , GroupedBy tab col bys
438 , columns ~ '[col ::: ty]
273 , columns ~ '[col ::: ty]
439 ) => IsLabel col
274 ) => IsLabel col
440− (NP (Aliased (Expression outer ('Grouped bys) commons schemas params from)) columns) where
275+ (NP (Aliased (Expression outer commons ('Grouped bys) schemas params from)) columns) where
441 fromLabel = fromLabel @col :* Nil
276 fromLabel = fromLabel @col :* Nil
442
277
443instance
278instance
@@ -445,7 +280,7 @@ instance
445 , Has col row ty
280 , Has col row ty
446 , GroupedBy tab col bys
281 , GroupedBy tab col bys
447 ) => IsQualified tab col
282 ) => IsQualified tab col
448− (Expression outer ('Grouped bys) commons schemas params from ty) where
283+ (Expression outer commons ('Grouped bys) schemas params from ty) where
449 tab ! col = UnsafeExpression $
284 tab ! col = UnsafeExpression $
450 renderSQL tab <> "." <> renderSQL col
285 renderSQL tab <> "." <> renderSQL col
451instance
286instance
@@ -454,7 +289,7 @@ instance
454 , GroupedBy tab col bys
289 , GroupedBy tab col bys
455 , tys ~ '[ty]
290 , tys ~ '[ty]
456 ) => IsQualified tab col
291 ) => IsQualified tab col
457− (NP (Expression outer ('Grouped bys) commons schemas params from) tys) where
292+ (NP (Expression outer commons ('Grouped bys) schemas params from) tys) where
458 tab ! col = tab ! col :* Nil
293 tab ! col = tab ! col :* Nil
459instance
294instance
460 ( Has tab (Join outer from) row
295 ( Has tab (Join outer from) row
@@ -462,7 +297,7 @@ instance
462 , GroupedBy tab col bys
297 , GroupedBy tab col bys
463 , column ~ (col ::: ty)
298 , column ~ (col ::: ty)
464 ) => IsQualified tab col
299 ) => IsQualified tab col
465− (Aliased (Expression outer ('Grouped bys) commons schemas params from) column) where
300+ (Aliased (Expression outer commons ('Grouped bys) schemas params from) column) where
466 tab ! col = tab ! col `As` col
301 tab ! col = tab ! col `As` col
467instance
302instance
468 ( Has tab (Join outer from) row
303 ( Has tab (Join outer from) row
@@ -470,206 +305,78 @@ instance
470 , GroupedBy tab col bys
305 , GroupedBy tab col bys
471 , columns ~ '[col ::: ty]
306 , columns ~ '[col ::: ty]
472 ) => IsQualified tab col
307 ) => IsQualified tab col
473− (NP (Aliased (Expression outer ('Grouped bys) commons schemas params from)) columns) where
308+ (NP (Aliased (Expression outer commons ('Grouped bys) schemas params from)) columns) where
474 tab ! col = tab ! col :* Nil
309 tab ! col = tab ! col :* Nil
475
310
476−-- | analagous to `Nothing`
477−--
478−-- >>> printSQL null_
479−-- NULL
480−null_ :: Expr ('Null ty)
481−null_ = UnsafeExpression "NULL"
482−
483−-- | analagous to `Just`
484−--
485−-- >>> printSQL $ notNull true
486−-- TRUE
487−notNull :: 'NotNull ty :--> 'Null ty
488−notNull = UnsafeExpression . renderSQL
489−
490−-- | return the leftmost value which is not NULL
491−--
492−-- >>> printSQL $ coalesce [null_, true] false
493−-- COALESCE(NULL, TRUE, FALSE)
494−coalesce :: FunctionHom ('Null ty) ('NotNull ty) ('NotNull ty)
495−coalesce nullxs notNullx = UnsafeExpression $
496− "COALESCE" <> parenthesized (commaSeparated
497− ((renderSQL <$> nullxs) <> [renderSQL notNullx]))
498−
499−-- | analagous to `Data.Maybe.fromMaybe` using @COALESCE@
500−--
501−-- >>> printSQL $ fromNull true null_
502−-- COALESCE(NULL, TRUE)
503−fromNull
504− :: Expression outer grp commons schemas params from ('NotNull ty)
505− -- ^ what to convert @NULL@ to
506− -> Expression outer grp commons schemas params from ('Null ty)
507− -> Expression outer grp commons schemas params from ('NotNull ty)
508−fromNull notNullx nullx = coalesce [nullx] notNullx
509−
510−-- | >>> printSQL $ null_ & isNull
511−-- NULL IS NULL
512−isNull :: 'Null ty :--> null 'PGbool
513−isNull x = UnsafeExpression $ renderSQL x <+> "IS NULL"
514−
515−-- | >>> printSQL $ null_ & isNotNull
516−-- NULL IS NOT NULL
517−isNotNull :: 'Null ty :--> null 'PGbool
518−isNotNull x = UnsafeExpression $ renderSQL x <+> "IS NOT NULL"
519−
520−-- | analagous to `maybe` using @IS NULL@
521−--
522−-- >>> printSQL $ matchNull true not_ null_
523−-- CASE WHEN NULL IS NULL THEN TRUE ELSE (NOT NULL) END
524−matchNull
525− :: Expression outer grp commons schemas params from (nullty)
526− -- ^ what to convert @NULL@ to
527− -> ( Expression outer grp commons schemas params from ('NotNull ty)
528− -> Expression outer grp commons schemas params from (nullty) )
529− -- ^ function to perform when @NULL@ is absent
530− -> Expression outer grp commons schemas params from ('Null ty)
531− -> Expression outer grp commons schemas params from (nullty)
532−matchNull y f x = ifThenElse (isNull x) y
533− (f (UnsafeExpression (renderSQL x)))
534−
535−{-| right inverse to `fromNull`, if its arguments are equal then
536−`nullIf` gives @NULL@.
537−
538−>>> :set -XTypeApplications -XDataKinds
539−>>> let expr = nullIf (false *: param @1) :: Expression outer grp commons schemas '[ 'NotNull 'PGbool] from ('Null 'PGbool)
540−>>> printSQL expr
541−NULLIF(FALSE, ($1 :: bool))
542−-}
543−nullIf :: FunctionHet '[ 'NotNull ty, 'NotNull ty] ('Null ty)
544−nullIf = unsafeFunctionHet "NULLIF"
545−
546−-- | >>> printSQL $ array [null_, false, true]
547−-- ARRAY[NULL, FALSE, TRUE]
548−array
549− :: [Expression outer grp commons schemas params from ty]
550− -- ^ array elements
551− -> Expression outer grp commons schemas params from (null ('PGvararray ty))
552−array xs = UnsafeExpression $
553− "ARRAY[" <> commaSeparated (renderSQL <$> xs) <> "]"
554−
555−-- | >>> printSQL $ cardinality (array [null_, false, true])
556−-- cardinality(ARRAY[NULL, FALSE, TRUE])
557−cardinality :: null ('PGvararray ty) :--> null 'PGint8
558−cardinality = unsafeFunction "cardinality"
559−
560−-- | >>> printSQL $ array [null_, false, true] & index 2
561−-- (ARRAY[NULL, FALSE, TRUE])[2]
562−index
563− :: Word64 -- ^ index
564− -> null ('PGvararray ty) :--> NullifyType ty
565−index n expr = UnsafeExpression $
566− parenthesized (renderSQL expr) <> "[" <> fromString (show n) <> "]"
567−
568instance (KnownSymbol label, label `In` labels) => IsPGlabel label
311instance (KnownSymbol label, label `In` labels) => IsPGlabel label
569− (Expression outer grp commons schemas params from (null ('PGenum labels))) where
312+ (Expression outer commons grp schemas params from (null ('PGenum labels))) where
570 label = UnsafeExpression $ renderSQL (PGlabel @label)
313 label = UnsafeExpression $ renderSQL (PGlabel @label)
571
314
572−-- | A row constructor is an expression that builds a row value
573−-- (also called a composite value) using values for its member fields.
574−--
575−-- >>> :{
576−-- type Complex = 'PGcomposite
577−-- '[ "real" ::: 'NotNull 'PGfloat8
578−-- , "imaginary" ::: 'NotNull 'PGfloat8 ]
579−-- :}
580−--
581−-- >>> let i = row (0 `as` #real :* 1 `as` #imaginary) :: Expression outer grp commons schemas params from ('NotNull Complex)
582−-- >>> printSQL i
583−-- ROW(0, 1)
584−row
585− :: SListI row
586− => NP (Aliased (Expression outer grp commons schemas params from)) row
587− -- ^ zero or more expressions for the row field values
588− -> Expression outer grp commons schemas params from (null ('PGcomposite row))
589−row exprs = UnsafeExpression $ "ROW" <> parenthesized
590− (renderCommaSeparated (\ (expr `As` _) -> renderSQL expr) exprs)
591−
592−-- | >>> :{
593−-- type Complex = 'PGcomposite
594−-- '[ "real" ::: 'NotNull 'PGfloat8
595−-- , "imaginary" ::: 'NotNull 'PGfloat8 ]
596−-- type Schema = '["complex" ::: 'Typedef Complex]
597−-- :}
598−--
599−-- >>> let i = row (0 `as` #real :* 1 `as` #imaginary) :: Expression outer grp '[] (Public Schema) from params ('NotNull Complex)
600−-- >>> printSQL $ i & field #complex #imaginary
601−-- (ROW(0, 1)::"complex")."imaginary"
602−field
603− :: ( Has sch schemas schema
604− , Has tydef schema ('Typedef ('PGcomposite row))
605− , Has field row ty)
606− => QualifiedAlias sch tydef -- ^ row type
607− -> Alias field -- ^ field name
608− -> Expression outer grp commons schemas params from ('NotNull ('PGcomposite row))
609− -> Expression outer grp commons schemas params from ty
610−field td fld expr = UnsafeExpression $
611− parenthesized (renderSQL expr <> "::" <> renderSQL td)
612− <> "." <> renderSQL fld
613−
614−instance Semigroup
615− (Expression outer grp commons schemas params from (null ('PGvararray ty))) where
616− (<>) = unsafeBinaryOp "||"
617−
618−instance Monoid
619− (Expression outer grp commons schemas params from (null ('PGvararray ty))) where
620− mempty = array []
621− mappend = (<>)
622−
623−-- | >>> let expr = greatest [param @1] currentTimestamp :: Expression outer grp commons schemas '[ 'NotNull 'PGtimestamptz] from ('NotNull 'PGtimestamptz)
624−-- >>> printSQL expr
625−-- GREATEST(($1 :: timestamp with time zone), CURRENT_TIMESTAMP)
626−greatest :: FunctionHom ty ty ty
627−greatest = unsafeFunctionHom "GREATEST"
628−
629−-- | >>> printSQL $ least [null_] currentTimestamp
630−-- LEAST(NULL, CURRENT_TIMESTAMP)
631−least :: FunctionHom ty ty ty
632−least = unsafeFunctionHom "LEAST"
633−
634-- | >>> printSQL $ unsafeBinaryOp "OR" true false
315-- | >>> printSQL $ unsafeBinaryOp "OR" true false
635-- (TRUE OR FALSE)
316-- (TRUE OR FALSE)
636−unsafeBinaryOp :: ByteString {- ^ operator -} -> Operator ty0 ty1 ty2
317+unsafeBinaryOp :: ByteString -> Operator ty0 ty1 ty2
637unsafeBinaryOp op x y = UnsafeExpression $ parenthesized $
318unsafeBinaryOp op x y = UnsafeExpression $ parenthesized $
638 renderSQL x <+> op <+> renderSQL y
319 renderSQL x <+> op <+> renderSQL y
639
320
640−-- | >>> printSQL $ unsafeUnaryOpL "NOT" true
321+binaryOp
641−-- (NOT TRUE)
322+ :: forall op sch schemas schema x y z.
642−unsafeUnaryOpL :: ByteString {- ^ operator -} -> x :--> y
323+ ( Has sch schemas schema
643−unsafeUnaryOpL op x = UnsafeExpression $ parenthesized $ op <+> renderSQL x
324+ , Has op schema ('Operator ('BinaryOp x y z)) )
325+ => OperatorDB schemas x y z
326+binaryOp = unsafeBinaryOp $ renderSymbol @op
644
327
645−unsafeUnaryOpR :: ByteString {- ^ operator -} -> x :--> y
328+-- | >>> printSQL $ unsafeLeftOp "NOT" true
329+-- (NOT TRUE)
330+unsafeLeftOp :: ByteString -> x --> y
331+unsafeLeftOp op x = UnsafeExpression $ parenthesized $ op <+> renderSQL x
332+
333+leftOp
334+ :: forall op sch schemas schema x y.
335+ ( Has sch schemas schema
336+ , Has op schema ('Operator ('LeftOp x y)) )
337+ => FunctionDB schemas x y
338+leftOp = unsafeLeftOp $ renderSymbol @op
339+
340+-- | >>> printSQL $ true & unsafeRightOp "IS NOT TRUE"
341+-- (TRUE IS NOT TRUE)
342+unsafeRightOp :: ByteString -> x --> y
646−unsafeUnaryOpR op x = UnsafeExpression $ parenthesized $ renderSQL x <+> op
343+unsafeRightOp op x = UnsafeExpression $ parenthesized $ renderSQL x <+> op
344+
345+rightOp
346+ :: forall op sch schemas schema x y.
347+ ( Has sch schemas schema
348+ , Has op schema ('Operator ('RightOp x y)) )
349+ => FunctionDB schemas x y
350+rightOp = unsafeRightOp $ renderSymbol @op
647
351
648-- | >>> printSQL $ unsafeFunction "f" true
352-- | >>> printSQL $ unsafeFunction "f" true
649-- f(TRUE)
353-- f(TRUE)
650−unsafeFunction :: ByteString {- ^ function -} -> x :--> y
354+unsafeFunction :: ByteString -> x --> y
651unsafeFunction fun x = UnsafeExpression $
355unsafeFunction fun x = UnsafeExpression $
652 fun <> parenthesized (renderSQL x)
356 fun <> parenthesized (renderSQL x)
653
357
654−unsafeFunctionHet
358+function
655− :: SListI xs
359+ :: (Has sch schemas schema, Has fun schema ('Function ('[x] :=> 'Returns y)))
656− => ByteString {- ^ function -}
360+ => QualifiedAlias sch fun
657− -> FunctionHet xs y
361+ -> FunctionDB schemas x y
362+function = unsafeFunction . renderSQL
363+
364+-- | >>> printSQL $ unsafeFunctionN "f" (currentTime :* localTimestamp :* false *: literal 'a')
365+-- f(CURRENT_TIME, LOCALTIMESTAMP, FALSE, E'a')
366+unsafeFunctionN :: SListI xs => ByteString -> xs ---> y
658−unsafeFunctionHet fun xs = UnsafeExpression $
367+unsafeFunctionN fun xs = UnsafeExpression $
659 fun <> parenthesized (renderCommaSeparated renderSQL xs)
368 fun <> parenthesized (renderCommaSeparated renderSQL xs)
660
369
661−-- | Helper for defining variadic functions.
370+functionN
662−unsafeVariadicFunction
371+ :: ( Has sch schemas schema
372+ , Has fun schema ('Function (xs :=> 'Returns y))
663− :: SListI elems
373+ , SListI xs )
664− => ByteString
374+ => QualifiedAlias sch fun
665− -- ^ function
375+ -> FunctionNDB schemas xs y
666− -> NP (Expression outer grp commons schemas params from) elems
376+functionN = unsafeFunctionN . renderSQL
667− -> Expression outer grp commons schemas params from ret
668−unsafeVariadicFunction fun x = UnsafeExpression $
669− fun <> parenthesized (commaSeparated (hcollapse (hmap (K . renderSQL) x)))
670
377
671instance ty `In` PGNum
378instance ty `In` PGNum
672− => Num (Expression outer grp commons schemas params from (null ty)) where
379+ => Num (Expression outer commons grp schemas params from (null ty)) where
673 (+) = unsafeBinaryOp "+"
380 (+) = unsafeBinaryOp "+"
674 (-) = unsafeBinaryOp "-"
381 (-) = unsafeBinaryOp "-"
675 (*) = unsafeBinaryOp "*"
382 (*) = unsafeBinaryOp "*"
@@ -681,7 +388,7 @@ instance ty `In` PGNum
681 . show
388 . show
682
389
683instance (ty `In` PGNum, ty `In` PGFloating) => Fractional
390instance (ty `In` PGNum, ty `In` PGFloating) => Fractional
684− (Expression outer grp commons schemas params from (null ty)) where
391+ (Expression outer commons grp schemas params from (null ty)) where
685 (/) = unsafeBinaryOp "/"
392 (/) = unsafeBinaryOp "/"
686 fromRational
393 fromRational
687 = UnsafeExpression
394 = UnsafeExpression
@@ -691,7 +398,7 @@ instance (ty `In` PGNum, ty `In` PGFloating) => Fractional
691 . fromRat @Double
398 . fromRat @Double
692
399
693instance (ty `In` PGNum, ty `In` PGFloating) => Floating
400instance (ty `In` PGNum, ty `In` PGFloating) => Floating
694− (Expression outer grp commons schemas params from (null ty)) where
401+ (Expression outer commons grp schemas params from (null ty)) where
695 pi = UnsafeExpression "pi()"
402 pi = UnsafeExpression "pi()"
696 exp = unsafeFunction "exp"
403 exp = unsafeFunction "exp"
697 log = unsafeFunction "ln"
404 log = unsafeFunction "ln"
@@ -712,1791 +419,54 @@ instance (ty `In` PGNum, ty `In` PGFloating) => Floating
712 acosh x = log (x + sqrt (x*x - 1))
419 acosh x = log (x + sqrt (x*x - 1))
713 atanh x = log ((1 + x) / (1 - x)) / 2
420 atanh x = log ((1 + x) / (1 - x)) / 2
714
421
715−-- | >>> :{
422+-- | Contained by operators
716−-- let
423+class PGSubset ty where
717−-- expression :: Expr (null 'PGfloat4)
424+ (@>) :: Operator (null0 ty) (null1 ty) ('Null 'PGbool)
718−-- expression = atan2_ (pi *: 2)
425+ (@>) = unsafeBinaryOp "@>"
719−-- in printSQL expression
426+ (<@) :: Operator (null0 ty) (null1 ty) ('Null 'PGbool)
720−-- :}
427+ (<@) = unsafeBinaryOp "<@"
721−-- atan2(pi(), 2)
428+instance PGSubset 'PGjsonb
722−atan2_
429+instance PGSubset 'PGtsquery
723− :: float `In` PGFloating
430+instance PGSubset ('PGvararray ty)
724− => FunctionHet '[ null float, null float] (null float)
431+instance PGSubset ('PGrange ty)
725−atan2_ = unsafeFunctionHet "atan2"
726−
727−-- When a `cast` is applied to an `Expression` of a known type, it
728−-- represents a run-time type conversion. The cast will succeed only if a
729−-- suitable type conversion operation has been defined.
730−--
731−-- | >>> printSQL $ true & cast int4
732−-- (TRUE :: int4)
733−cast
734− :: TypeExpression schemas ty1
735− -- ^ type to cast as
736− -> Expression outer grp commons schemas params from ty0
737− -- ^ value to convert
738− -> Expression outer grp commons schemas params from ty1
739−cast ty x = UnsafeExpression $ parenthesized $
740− renderSQL x <+> "::" <+> renderSQL ty
741−
742−-- | integer division, truncates the result
743−--
744−-- >>> :{
745−-- let
746−-- expression :: Expression outer grp commons schemas params from (null 'PGint2)
747−-- expression = 5 `quot_` 2
748−-- in printSQL expression
749−-- :}
750−-- (5 / 2)
751−quot_
752− :: int `In` PGIntegral
753− => Operator (null int) (null int) (null int)
754−quot_ = unsafeBinaryOp "/"
755−
756−-- | remainder upon integer division
757−--
758−-- >>> :{
759−-- let
760−-- expression :: Expression outer grp commons schemas params from (null 'PGint2)
761−-- expression = 5 `rem_` 2
762−-- in printSQL expression
763−-- :}
764−-- (5 % 2)
765−rem_
766− :: int `In` PGIntegral
767− => Operator (null int) (null int) (null int)
768−rem_ = unsafeBinaryOp "%"
769−
770−-- | >>> :{
771−-- let
772−-- expression :: Expression outer grp commons schemas params from (null 'PGfloat4)
773−-- expression = trunc pi
774−-- in printSQL expression
775−-- :}
776−-- trunc(pi())
777−trunc :: frac `In` PGFloating => null frac :--> null frac
778−trunc = unsafeFunction "trunc"
779−
780−-- | >>> :{
781−-- let
782−-- expression :: Expression outer grp commons schemas params from (null 'PGfloat4)
783−-- expression = round_ pi
784−-- in printSQL expression
785−-- :}
786−-- round(pi())
787−round_ :: frac `In` PGFloating => null frac :--> null frac
788−round_ = unsafeFunction "round"
789−
790−-- | >>> :{
791−-- let
792−-- expression :: Expression outer grp commons schemas params from (null 'PGfloat4)
793−-- expression = ceiling_ pi
794−-- in printSQL expression
795−-- :}
796−-- ceiling(pi())
797−ceiling_ :: frac `In` PGFloating => null frac :--> null frac
798−ceiling_ = unsafeFunction "ceiling"
799−
800−-- | A `Condition` is an `Expression`, which can evaluate
801−-- to `true`, `false` or `null_`. This is because SQL uses
802−-- a three valued logic.
803−type Condition outer grp commons schemas params from =
804− Expression outer grp commons schemas params from ('Null 'PGbool)
805−
806−-- | >>> printSQL true
807−-- TRUE
808−true :: Expr (null 'PGbool)
809−true = UnsafeExpression "TRUE"
810−
811−-- | >>> printSQL false
812−-- FALSE
813−false :: Expr (null 'PGbool)
814−false = UnsafeExpression "FALSE"
815−
816−-- | >>> printSQL $ not_ true
817−-- (NOT TRUE)
818−not_ :: null 'PGbool :--> null 'PGbool
819−not_ = unsafeUnaryOpL "NOT"
820−
821−-- | >>> printSQL $ true .&& false
822−-- (TRUE AND FALSE)
823−(.&&) :: Operator (null 'PGbool) (null 'PGbool) (null 'PGbool)
824−infixr 3 .&&
825−(.&&) = unsafeBinaryOp "AND"
826−
827−-- | >>> printSQL $ true .|| false
828−-- (TRUE OR FALSE)
829−(.||) :: Operator (null 'PGbool) (null 'PGbool) (null 'PGbool)
830−infixr 2 .||
831−(.||) = unsafeBinaryOp "OR"
832−
833−-- | >>> :{
834−-- let
835−-- expression :: Expression outer grp commons schemas params from (null 'PGint2)
836−-- expression = caseWhenThenElse [(true, 1), (false, 2)] 3
837−-- in printSQL expression
838−-- :}
839−-- CASE WHEN TRUE THEN 1 WHEN FALSE THEN 2 ELSE 3 END
840−caseWhenThenElse
841− :: [ ( Condition outer grp commons schemas params from
842− , Expression outer grp commons schemas params from ty
843− ) ]
844− -- ^ whens and thens
845− -> Expression outer grp commons schemas params from ty
846− -- ^ else
847− -> Expression outer grp commons schemas params from ty
848−caseWhenThenElse whenThens else_ = UnsafeExpression $ mconcat
849− [ "CASE"
850− , mconcat
851− [ mconcat
852− [ " WHEN ", renderSQL when_
853− , " THEN ", renderSQL then_
854− ]
855− | (when_,then_) <- whenThens
856− ]
857− , " ELSE ", renderSQL else_
858− , " END"
859− ]
860−
861−-- | >>> :{
862−-- let
863−-- expression :: Expression outer grp commons schemas params from (null 'PGint2)
864−-- expression = ifThenElse true 1 0
865−-- in printSQL expression
866−-- :}
867−-- CASE WHEN TRUE THEN 1 ELSE 0 END
868−ifThenElse
869− :: Condition outer grp commons schemas params from
870− -> Expression outer grp commons schemas params from ty -- ^ then
871− -> Expression outer grp commons schemas params from ty -- ^ else
872− -> Expression outer grp commons schemas params from ty
873−ifThenElse if_ then_ else_ = caseWhenThenElse [(if_,then_)] else_
874−
875−-- | Comparison operations like `.==`, `./=`, `.>`, `.>=`, `.<` and `.<=`
876−-- will produce @NULL@s if one of their arguments is @NULL@.
877−--
878−-- >>> printSQL $ true .== null_
879−-- (TRUE = NULL)
880−(.==) :: Operator (null0 ty) (null1 ty) ('Null 'PGbool)
881−(.==) = unsafeBinaryOp "="
882−infix 4 .==
883−
884−-- | >>> printSQL $ true ./= null_
885−-- (TRUE <> NULL)
886−(./=) :: Operator (null0 ty) (null1 ty) ('Null 'PGbool)
887−(./=) = unsafeBinaryOp "<>"
888−infix 4 ./=
889−
890−-- | >>> printSQL $ true .>= null_
891−-- (TRUE >= NULL)
892−(.>=) :: Operator (null0 ty) (null1 ty) ('Null 'PGbool)
893−(.>=) = unsafeBinaryOp ">="
894−infix 4 .>=
895−
896−-- | >>> printSQL $ true .< null_
897−-- (TRUE < NULL)
898−(.<) :: Operator (null0 ty) (null1 ty) ('Null 'PGbool)
899−(.<) = unsafeBinaryOp "<"
900−infix 4 .<
901−
902−-- | >>> printSQL $ true .<= null_
903−-- (TRUE <= NULL)
904−(.<=) :: Operator (null0 ty) (null1 ty) ('Null 'PGbool)
905−(.<=) = unsafeBinaryOp "<="
906−infix 4 .<=
907−
908−-- | >>> printSQL $ true .> null_
909−-- (TRUE > NULL)
910−(.>) :: Operator (null0 ty) (null1 ty) ('Null 'PGbool)
911−(.>) = unsafeBinaryOp ">"
912−infix 4 .>
913−
914−{- | between
915−>>> printSQL $ true `between` (null_, false)
916−TRUE BETWEEN NULL AND FALSE
917−-}
918−between
919− :: Expression outer grp commons schemas params from (null ty)
920− -> ( Expression outer grp commons schemas params from (null ty)
921− , Expression outer grp commons schemas params from (null ty) ) -- ^ bounds
922− -> Condition outer grp commons schemas params from
923−between a (x,y) = UnsafeExpression $ renderSQL a <+> "BETWEEN"
924− <+> renderSQL x <+> "AND" <+> renderSQL y
925−
926−{- | not between
927−>>> printSQL $ true `notBetween` (null_, false)
928−TRUE NOT BETWEEN NULL AND FALSE
929−-}
930−notBetween
931− :: Expression outer grp commons schemas params from (null ty)
932− -> ( Expression outer grp commons schemas params from (null ty)
933− , Expression outer grp commons schemas params from (null ty) ) -- ^ bounds
934− -> Condition outer grp commons schemas params from
935−notBetween a (x,y) = UnsafeExpression $ renderSQL a <+> "NOT BETWEEN"
936− <+> renderSQL x <+> "AND" <+> renderSQL y
937−
938−{- | between, after sorting the comparison values
939−>>> printSQL $ true `betweenSymmetric` (null_, false)
940−TRUE BETWEEN SYMMETRIC NULL AND FALSE
941−-}
942−betweenSymmetric
943− :: Expression outer grp commons schemas params from (null ty)
944− -> ( Expression outer grp commons schemas params from (null ty)
945− , Expression outer grp commons schemas params from (null ty) ) -- ^ bounds
946− -> Condition outer grp commons schemas params from
947−betweenSymmetric a (x,y) = UnsafeExpression $ renderSQL a
948− <+> "BETWEEN SYMMETRIC" <+> renderSQL x <+> "AND" <+> renderSQL y
949−
950−{- | not between, after sorting the comparison values
951−>>> printSQL $ true `notBetweenSymmetric` (null_, false)
952−TRUE NOT BETWEEN SYMMETRIC NULL AND FALSE
953−-}
954−notBetweenSymmetric
955− :: Expression outer grp commons schemas params from (null ty)
956− -> ( Expression outer grp commons schemas params from (null ty)
957− , Expression outer grp commons schemas params from (null ty) ) -- ^ bounds
958− -> Condition outer grp commons schemas params from
959−notBetweenSymmetric a (x,y) = UnsafeExpression $ renderSQL a
960− <+> "NOT BETWEEN SYMMETRIC" <+> renderSQL x <+> "AND" <+> renderSQL y
961−
962−{- | not equal, treating null like an ordinary value
963−>>> printSQL $ true `isDistinctFrom` null_
964−(TRUE IS DISTINCT FROM NULL)
965−-}
966−isDistinctFrom :: Operator (null0 ty) (null1 ty) ('Null 'PGbool)
967−isDistinctFrom = unsafeBinaryOp "IS DISTINCT FROM"
968−
969−{- | equal, treating null like an ordinary value
970−>>> printSQL $ true `isNotDistinctFrom` null_
971−(TRUE IS NOT DISTINCT FROM NULL)
972−-}
973−isNotDistinctFrom :: Operator (null0 ty) (null1 ty) ('NotNull 'PGbool)
974−isNotDistinctFrom = unsafeBinaryOp "IS NOT DISTINCT FROM"
975−
976−{- | is true
977−>>> printSQL $ true & isTrue
978−(TRUE IS TRUE)
979−-}
980−isTrue :: null0 'PGbool :--> null1 'PGbool
981−isTrue = unsafeUnaryOpR "IS TRUE"
982−
983−{- | is false or unknown
984−>>> printSQL $ true & isNotTrue
985−(TRUE IS NOT TRUE)
986−-}
987−isNotTrue :: null0 'PGbool :--> null1 'PGbool
988−isNotTrue = unsafeUnaryOpR "IS NOT TRUE"
989−
990−{- | is false
991−>>> printSQL $ true & isFalse
992−(TRUE IS FALSE)
993−-}
994−isFalse :: null0 'PGbool :--> null1 'PGbool
995−isFalse = unsafeUnaryOpR "IS FALSE"
996−
997−{- | is true or unknown
998−>>> printSQL $ true & isNotFalse
999−(TRUE IS NOT FALSE)
1000−-}
1001−isNotFalse :: null0 'PGbool :--> null1 'PGbool
1002−isNotFalse = unsafeUnaryOpR "IS NOT FALSE"
1003−
1004−{- | is unknown
1005−>>> printSQL $ true & isUnknown
1006−(TRUE IS UNKNOWN)
1007−-}
1008−isUnknown :: null0 'PGbool :--> null1 'PGbool
1009−isUnknown = unsafeUnaryOpR "IS UNKNOWN"
1010−
1011−{- | is true or false
1012−>>> printSQL $ true & isNotUnknown
1013−(TRUE IS NOT UNKNOWN)
1014−-}
1015−isNotUnknown :: null0 'PGbool :--> null1 'PGbool
1016−isNotUnknown = unsafeUnaryOpR "IS NOT UNKNOWN"
1017−
1018−-- | >>> printSQL currentDate
1019−-- CURRENT_DATE
1020−currentDate :: Expr (null 'PGdate)
1021−currentDate = UnsafeExpression "CURRENT_DATE"
1022−
1023−-- | >>> printSQL currentTime
1024−-- CURRENT_TIME
1025−currentTime :: Expr (null 'PGtimetz)
1026−currentTime = UnsafeExpression "CURRENT_TIME"
1027−
1028−-- | >>> printSQL currentTimestamp
1029−-- CURRENT_TIMESTAMP
1030−currentTimestamp :: Expr (null 'PGtimestamptz)
1031−currentTimestamp = UnsafeExpression "CURRENT_TIMESTAMP"
1032−
1033−-- | >>> printSQL localTime
1034−-- LOCALTIME
1035−localTime :: Expr (null 'PGtime)
1036−localTime = UnsafeExpression "LOCALTIME"
1037−
1038−-- | >>> printSQL localTimestamp
1039−-- LOCALTIMESTAMP
1040−localTimestamp :: Expr (null 'PGtimestamp)
1041−localTimestamp = UnsafeExpression "LOCALTIMESTAMP"
1042−
1043−{-----------------------------------------
1044−text
1045−-----------------------------------------}
1046
432
1047−escape :: Char -> String
433+class PGIntersect ty where
1048−escape = \case
434+ (@&&) :: Operator (null0 ty) (null1 ty) ('Null 'PGbool)
1049− '\NUL' -> "\\0"
435+ (@&&) = unsafeBinaryOp "&&"
1050− '\'' -> "''"
436+instance PGIntersect ('PGvararray ty)
1051− '"' -> "\\\""
437+instance PGIntersect ('PGrange ty)
1052− '\b' -> "\\b"
1053− '\n' -> "\\n"
1054− '\r' -> "\\r"
1055− '\t' -> "\\t"
1056− '\\' -> "\\\\"
1057− c -> [c]
1058
438
1059instance IsString
439instance IsString
1060− (Expression outer grp commons schemas params from (null 'PGtext)) where
440+ (Expression outer commons grp schemas params from (null 'PGtext)) where
1061 fromString str = UnsafeExpression $
441 fromString str = UnsafeExpression $
1062 "E\'" <> fromString (escape =<< str) <> "\'"
442 "E\'" <> fromString (escape =<< str) <> "\'"
1063instance IsString
443instance IsString
1064− (Expression outer grp commons schemas params from (null 'PGtsvector)) where
444+ (Expression outer commons grp schemas params from (null 'PGtsvector)) where
1065− fromString str = cast tsvector . UnsafeExpression $
445+ fromString str = UnsafeExpression . parenthesized . (<> " :: tsvector") $
1066 "E\'" <> fromString (escape =<< str) <> "\'"
446 "E\'" <> fromString (escape =<< str) <> "\'"
1067instance IsString
447instance IsString
1068− (Expression outer grp commons schemas params from (null 'PGtsquery)) where
448+ (Expression outer commons grp schemas params from (null 'PGtsquery)) where
1069− fromString str = cast tsquery . UnsafeExpression $
449+ fromString str = UnsafeExpression . parenthesized . (<> " :: tsquery") $
1070 "E\'" <> fromString (escape =<< str) <> "\'"
450 "E\'" <> fromString (escape =<< str) <> "\'"
1071
451
1072instance Semigroup
452instance Semigroup
453+ (Expression outer commons grp schemas params from (null ('PGvararray ty))) where
454+ (<>) = unsafeBinaryOp "||"
455+instance Semigroup
456+ (Expression outer commons grp schemas params from (null 'PGjsonb)) where
457+ (<>) = unsafeBinaryOp "||"
458+instance Semigroup
1073− (Expression outer grp commons schemas params from (null 'PGtext)) where
459+ (Expression outer commons grp schemas params from (null 'PGtext)) where
1074 (<>) = unsafeBinaryOp "||"
460 (<>) = unsafeBinaryOp "||"
1075instance Semigroup
461instance Semigroup
1076− (Expression outer grp commons schemas params from (null 'PGtsvector)) where
462+ (Expression outer commons grp schemas params from (null 'PGtsvector)) where
1077 (<>) = unsafeBinaryOp "||"
463 (<>) = unsafeBinaryOp "||"
1078
464
1079instance Monoid
465instance Monoid
1080− (Expression outer grp commons schemas params from (null 'PGtext)) where
466+ (Expression outer commons grp schemas params from (null 'PGtext)) where
1081 mempty = fromString ""
467 mempty = fromString ""
1082 mappend = (<>)
468 mappend = (<>)
1083instance Monoid
469instance Monoid
1084− (Expression outer grp commons schemas params from (null 'PGtsvector)) where
470+ (Expression outer commons grp schemas params from (null 'PGtsvector)) where
1085 mempty = fromString ""
471 mempty = fromString ""
1086 mappend = (<>)
472 mappend = (<>)
1087−
1088−-- | >>> printSQL $ lower "ARRRGGG"
1089−-- lower(E'ARRRGGG')
1090−lower :: null 'PGtext :--> null 'PGtext
1091−lower = unsafeFunction "lower"
1092−
1093−-- | >>> printSQL $ upper "eeee"
1094−-- upper(E'eeee')
1095−upper :: null 'PGtext :--> null 'PGtext
1096−upper = unsafeFunction "upper"
1097−
1098−-- | >>> printSQL $ charLength "four"
1099−-- char_length(E'four')
1100−charLength :: null 'PGtext :--> null 'PGint4
1101−charLength = unsafeFunction "char_length"
1102−
1103−-- | The `like` expression returns true if the @string@ matches
1104−-- the supplied @pattern@. If @pattern@ does not contain percent signs
1105−-- or underscores, then the pattern only represents the string itself;
1106−-- in that case `like` acts like the equals operator. An underscore (_)
1107−-- in pattern stands for (matches) any single character; a percent sign (%)
1108−-- matches any sequence of zero or more characters.
1109−--
1110−-- >>> printSQL $ "abc" `like` "a%"
1111−-- (E'abc' LIKE E'a%')
1112−like :: Operator (null 'PGtext) (null 'PGtext) ('Null 'PGbool)
1113−like = unsafeBinaryOp "LIKE"
1114−
1115−-- | The key word ILIKE can be used instead of LIKE to make the
1116−-- match case-insensitive according to the active locale.
1117−--
1118−-- >>> printSQL $ "abc" `ilike` "a%"
1119−-- (E'abc' ILIKE E'a%')
1120−ilike :: Operator (null 'PGtext) (null 'PGtext) ('Null 'PGbool)
1121−ilike = unsafeBinaryOp "ILIKE"
1122−
1123−{-----------------------------------------
1124− -- json and jsonb support
1125−
1126−See https://www.postgresql.org/docs/10/static/functions-json.html -- most
1127−comments lifted directly from this page.
1128−
1129−Table 9.44: json and jsonb operators
1130−-----------------------------------------}
1131−
1132−-- | Get JSON value (object field or array element) at a key.
1133−(.->)
1134− :: (json `In` PGJsonType, key `In` PGJsonKey)
1135− => Operator (null json) (null key) ('Null json)
1136−infixl 8 .->
1137−(.->) = unsafeBinaryOp "->"
1138−
1139−-- | Get JSON value (object field or array element) at a key, as text.
1140−(.->>)
1141− :: (json `In` PGJsonType, key `In` PGJsonKey)
1142− => Operator (null json) (null key) ('Null 'PGtext)
1143−infixl 8 .->>
1144−(.->>) = unsafeBinaryOp "->>"
1145−
1146−-- | Get JSON value at a specified path.
1147−(.#>)
1148− :: (json `In` PGJsonType, PGTextArray "(.#>)" path)
1149− => Operator (null json) (null path) ('Null json)
1150−infixl 8 .#>
1151−(.#>) = unsafeBinaryOp "#>"
1152−
1153−-- | Get JSON value at a specified path as text.
1154−(.#>>)
1155− :: (json `In` PGJsonType, PGTextArray "(.#>>)" path)
1156− => Operator (null json) (null path) ('Null 'PGtext)
1157−infixl 8 .#>>
1158−(.#>>) = unsafeBinaryOp "#>>"
1159−
1160−-- Additional jsonb operators
1161−
1162−class PGSubset container where
1163− (@>) :: Operator (null0 container) (null1 container) ('Null 'PGbool)
1164− (@>) = unsafeBinaryOp "@>"
1165− (<@) :: Operator (null0 container) (null1 container) ('Null 'PGbool)
1166− (<@) = unsafeBinaryOp "<@"
1167−instance PGSubset 'PGjsonb
1168−instance PGSubset 'PGtsquery
1169−instance PGSubset ('PGvararray ty)
1170−
1171−-- | Does the string exist as a top-level key within the JSON value?
1172−(.?) :: Operator (null 'PGjsonb) (null 'PGtext) ('Null 'PGbool)
1173−infixl 9 .?
1174−(.?) = unsafeBinaryOp "?"
1175−
1176−-- | Do any of these array strings exist as top-level keys?
1177−(.?|) :: Operator
1178− (null 'PGjsonb)
1179− (null ('PGvararray ('NotNull 'PGtext)))
1180− ('Null 'PGbool)
1181−infixl 9 .?|
1182−(.?|) = unsafeBinaryOp "?|"
1183−
1184−-- | Do all of these array strings exist as top-level keys?
1185−(.?&) :: Operator
1186− (null 'PGjsonb)
1187− (null ('PGvararray ('NotNull 'PGtext)))
1188− ('Null 'PGbool)
1189−infixl 9 .?&
1190−(.?&) = unsafeBinaryOp "?&"
1191−
1192−-- | Concatenate two jsonb values into a new jsonb value.
1193−instance Semigroup
1194− (Expression outer grp commons schemas params from (null 'PGjsonb)) where
1195− (<>) = unsafeBinaryOp "||"
1196−
1197−-- | Delete a key or keys from a JSON object, or remove an array element.
1198−--
1199−-- If the right operand is..
1200−--
1201−-- @ text @: Delete key/value pair or string element from left operand. Key/value pairs
1202−-- are matched based on their key value.
1203−--
1204−-- @ text[] @: Delete multiple key/value pairs or string elements
1205−-- from left operand. Key/value pairs are matched based on their key value.
1206−--
1207−-- @ integer @: Delete the array element with specified index (Negative integers
1208−-- count from the end). Throws an error if top level container is not an array.
1209−(.-.)
1210− :: (key `In` '[ 'PGtext, 'PGvararray ('NotNull 'PGtext), 'PGint4, 'PGint2 ]) -- hlint error without parens here
1211− => Operator (null 'PGjsonb) (null key) (null 'PGjsonb)
1212−infixl 6 .-.
1213−(.-.) = unsafeBinaryOp "-"
1214−
1215−-- | Delete the field or element with specified path (for JSON arrays, negative
1216−-- integers count from the end)
1217−(#-.)
1218− :: PGTextArray "(#-.)" arrayty
1219− => Operator (null 'PGjsonb) (null arrayty) (null 'PGjsonb)
1220−infixl 6 #-.
1221−(#-.) = unsafeBinaryOp "#-"
1222−
1223−{-----------------------------------------
1224−Table 9.45: JSON creation functions
1225−-----------------------------------------}
1226−
1227−-- | Literal binary JSON
1228−jsonbLit :: JSON.ToJSON x => x -> Expr (null 'PGjsonb)
1229−jsonbLit = cast jsonb . UnsafeExpression
1230− . singleQuotedUtf8 . toStrict . JSON.encode
1231−
1232−-- | Literal JSON
1233−jsonLit :: JSON.ToJSON x => x -> Expr (null 'PGjson)
1234−jsonLit = cast json . UnsafeExpression
1235− . singleQuotedUtf8 . toStrict . JSON.encode
1236−
1237−-- | Returns the value as json. Arrays and composites are converted
1238−-- (recursively) to arrays and objects; otherwise, if there is a cast from the
1239−-- type to json, the cast function will be used to perform the conversion;
1240−-- otherwise, a scalar value is produced. For any scalar type other than a
1241−-- number, a Boolean, or a null value, the text representation will be used, in
1242−-- such a fashion that it is a valid json value.
1243−toJson :: null ty :--> null 'PGjson
1244−toJson = unsafeFunction "to_json"
1245−
1246−-- | Returns the value as jsonb. Arrays and composites are converted
1247−-- (recursively) to arrays and objects; otherwise, if there is a cast from the
1248−-- type to json, the cast function will be used to perform the conversion;
1249−-- otherwise, a scalar value is produced. For any scalar type other than a
1250−-- number, a Boolean, or a null value, the text representation will be used, in
1251−-- such a fashion that it is a valid jsonb value.
1252−toJsonb :: null ty :--> null 'PGjsonb
1253−toJsonb = unsafeFunction "to_jsonb"
1254−
1255−-- | Returns the array as a JSON array. A PostgreSQL multidimensional array
1256−-- becomes a JSON array of arrays.
1257−arrayToJson
1258− :: PGArray "arrayToJson" arr
1259− => null arr :--> null 'PGjson
1260−arrayToJson = unsafeFunction "array_to_json"
1261−
1262−-- | Returns the row as a JSON object.
1263−rowToJson :: null ('PGcomposite ty) :--> null 'PGjson
1264−rowToJson = unsafeFunction "row_to_json"
1265−
1266−-- | Builds a possibly-heterogeneously-typed JSON array out of a variadic
1267−-- argument list.
1268−jsonBuildArray
1269− :: SListI elems
1270− => NP (Expression outer grp commons schemas params from) elems
1271− -> Expression outer grp commons schemas params from (null 'PGjson)
1272−jsonBuildArray = unsafeVariadicFunction "json_build_array"
1273−
1274−-- | Builds a possibly-heterogeneously-typed (binary) JSON array out of a
1275−-- variadic argument list.
1276−jsonbBuildArray
1277− :: SListI elems
1278− => NP (Expression outer grp commons schemas params from) elems
1279− -> Expression outer grp commons schemas params from (null 'PGjsonb)
1280−jsonbBuildArray = unsafeVariadicFunction "jsonb_build_array"
1281−
1282−unsafeRowFunction
1283− :: SOP.SListI elems
1284− => NP (Aliased (Expression outer grp commons schemas params from)) elems
1285− -> [ByteString]
1286−unsafeRowFunction =
1287− (`appEndo` []) . hcfoldMap (Proxy :: SOP.Proxy SOP.Top)
1288− (\(col `As` name) -> Endo $ \xs ->
1289− renderAliasString name : renderSQL col : xs)
1290− where
1291− renderAliasString :: KnownSymbol alias => Alias alias -> ByteString
1292− renderAliasString = singleQuotedText . fromString . symbolVal
1293−
1294−-- | Builds a possibly-heterogeneously-typed JSON object out of a variadic
1295−-- argument list. The elements of the argument list must alternate between text
1296−-- and values.
1297−jsonBuildObject
1298− :: SOP.SListI elems
1299− => NP (Aliased (Expression outer grp commons schemas params from)) elems
1300− -> Expression outer grp commons schemas params from (null 'PGjson)
1301−jsonBuildObject
1302− = unsafeFunction "json_build_object"
1303− . UnsafeExpression
1304− . commaSeparated
1305− . unsafeRowFunction
1306−
1307−-- | Builds a possibly-heterogeneously-typed (binary) JSON object out of a
1308−-- variadic argument list. The elements of the argument list must alternate
1309−-- between text and values.
1310−jsonbBuildObject
1311− :: SOP.SListI elems
1312− => NP (Aliased (Expression outer grp commons schemas params from)) elems
1313− -> Expression outer grp commons schemas params from (null 'PGjsonb)
1314−jsonbBuildObject
1315− = unsafeFunction "jsonb_build_object"
1316− . UnsafeExpression
1317− . commaSeparated
1318− . unsafeRowFunction
1319−
1320−-- | Builds a JSON object out of a text array. The array must have either
1321−-- exactly one dimension with an even number of members, in which case they are
1322−-- taken as alternating key/value pairs, or two dimensions such that each inner
1323−-- array has exactly two elements, which are taken as a key/value pair.
1324−jsonObject
1325− :: PGArrayOf "jsonObject" arr ('NotNull 'PGtext)
1326− => null arr :--> null 'PGjson
1327−jsonObject = unsafeFunction "json_object"
1328−
1329−-- | Builds a binary JSON object out of a text array. The array must have either
1330−-- exactly one dimension with an even number of members, in which case they are
1331−-- taken as alternating key/value pairs, or two dimensions such that each inner
1332−-- array has exactly two elements, which are taken as a key/value pair.
1333−jsonbObject
1334− :: PGArrayOf "jsonbObject" arr ('NotNull 'PGtext)
1335− => null arr :--> null 'PGjsonb
1336−jsonbObject = unsafeFunction "jsonb_object"
1337−
1338−-- | This is an alternate form of 'jsonObject' that takes two arrays; one for
1339−-- keys and one for values, that are zipped pairwise to create a JSON object.
1340−jsonZipObject
1341− :: ( PGArrayOf "jsonZipObject" keysArray ('NotNull 'PGtext)
1342− , PGArrayOf "jsonZipObject" valuesArray ('NotNull 'PGtext))
1343− => Expression outer grp commons schemas params from (null keysArray)
1344− -> Expression outer grp commons schemas params from (null valuesArray)
1345− -> Expression outer grp commons schemas params from (null 'PGjson)
1346−jsonZipObject ks vs =
1347− unsafeVariadicFunction "json_object" (ks :* vs :* Nil)
1348−
1349−-- | This is an alternate form of 'jsonObject' that takes two arrays; one for
1350−-- keys and one for values, that are zipped pairwise to create a binary JSON
1351−-- object.
1352−jsonbZipObject
1353− :: ( PGArrayOf "jsonbZipObject" keysArray ('NotNull 'PGtext)
1354− , PGArrayOf "jsonbZipObject" valuesArray ('NotNull 'PGtext))
1355− => Expression outer grp commons schemas params from (null keysArray)
1356− -> Expression outer grp commons schemas params from (null valuesArray)
1357− -> Expression outer grp commons schemas params from (null 'PGjsonb)
1358−jsonbZipObject ks vs =
1359− unsafeVariadicFunction "jsonb_object" (ks :* vs :* Nil)
1360−
1361−{-----------------------------------------
1362−Table 9.46: JSON processing functions
1363−-----------------------------------------}
1364−
1365−-- | Returns the number of elements in the outermost JSON array.
1366−jsonArrayLength :: null 'PGjson :--> null 'PGint4
1367−jsonArrayLength = unsafeFunction "json_array_length"
1368−
1369−-- | Returns the number of elements in the outermost binary JSON array.
1370−jsonbArrayLength :: null 'PGjsonb :--> null 'PGint4
1371−jsonbArrayLength = unsafeFunction "jsonb_array_length"
1372−
1373−-- | Returns JSON value pointed to by the given path (equivalent to #>
1374−-- operator).
1375−jsonExtractPath
1376− :: SListI elems
1377− => Expression outer grp commons schemas params from (null 'PGjson)
1378− -> NP (Expression outer grp commons schemas params from) elems
1379− -> Expression outer grp commons schemas params from (null 'PGjsonb)
1380−jsonExtractPath x xs =
1381− unsafeVariadicFunction "json_extract_path" (x :* xs)
1382−
1383−-- | Returns JSON value pointed to by the given path (equivalent to #>
1384−-- operator).
1385−jsonbExtractPath
1386− :: SListI elems
1387− => Expression outer grp commons schemas params from (null 'PGjsonb)
1388− -> NP (Expression outer grp commons schemas params from) elems
1389− -> Expression outer grp commons schemas params from (null 'PGjsonb)
1390−jsonbExtractPath x xs =
1391− unsafeVariadicFunction "jsonb_extract_path" (x :* xs)
1392−
1393−-- | Returns JSON value pointed to by the given path (equivalent to #>
1394−-- operator), as text.
1395−jsonExtractPathAsText
1396− :: SListI elems
1397− => Expression outer grp commons schemas params from (null 'PGjson)
1398− -> NP (Expression outer grp commons schemas params from) elems
1399− -> Expression outer grp commons schemas params from (null 'PGjson)
1400−jsonExtractPathAsText x xs =
1401− unsafeVariadicFunction "json_extract_path_text" (x :* xs)
1402−
1403−-- | Returns JSON value pointed to by the given path (equivalent to #>
1404−-- operator), as text.
1405−jsonbExtractPathAsText
1406− :: SListI elems
1407− => Expression outer grp commons schemas params from (null 'PGjsonb)
1408− -> NP (Expression outer grp commons schemas params from) elems
1409− -> Expression outer grp commons schemas params from (null 'PGjsonb)
1410−jsonbExtractPathAsText x xs =
1411− unsafeVariadicFunction "jsonb_extract_path_text" (x :* xs)
1412−
1413−-- | Returns the type of the outermost JSON value as a text string. Possible
1414−-- types are object, array, string, number, boolean, and null.
1415−jsonTypeof :: null 'PGjson :--> null 'PGtext
1416−jsonTypeof = unsafeFunction "json_typeof"
1417−
1418−-- | Returns the type of the outermost binary JSON value as a text string.
1419−-- Possible types are object, array, string, number, boolean, and null.
1420−jsonbTypeof :: null 'PGjsonb :--> null 'PGtext
1421−jsonbTypeof = unsafeFunction "jsonb_typeof"
1422−
1423−-- | Returns its argument with all object fields that have null values omitted.
1424−-- Other null values are untouched.
1425−jsonStripNulls :: null 'PGjson :--> null 'PGjson
1426−jsonStripNulls = unsafeFunction "json_strip_nulls"
1427−
1428−-- | Returns its argument with all object fields that have null values omitted.
1429−-- Other null values are untouched.
1430−jsonbStripNulls :: null 'PGjsonb :--> null 'PGjsonb
1431−jsonbStripNulls = unsafeFunction "jsonb_strip_nulls"
1432−
1433−-- | @ jsonbSet target path new_value create_missing @
1434−--
1435−-- Returns target with the section designated by path replaced by new_value,
1436−-- or with new_value added if create_missing is true ( default is true) and the
1437−-- item designated by path does not exist. As with the path orientated
1438−-- operators, negative integers that appear in path count from the end of JSON
1439−-- arrays.
1440−jsonbSet
1441− :: PGTextArray "jsonbSet" arr
1442− => Expression outer grp commons schemas params from (null 'PGjsonb)
1443− -> Expression outer grp commons schemas params from (null arr)
1444− -> Expression outer grp commons schemas params from (null 'PGjsonb)
1445− -> Maybe (Expression outer grp commons schemas params from (null 'PGbool))
1446− -> Expression outer grp commons schemas params from (null 'PGjsonb)
1447−jsonbSet tgt path val createMissing = case createMissing of
1448− Just m -> unsafeVariadicFunction "jsonb_set" (tgt :* path :* val :* m :* Nil)
1449− Nothing -> unsafeVariadicFunction "jsonb_set" (tgt :* path :* val :* Nil)
1450−
1451−-- | @ jsonbInsert target path new_value insert_after @
1452−--
1453−-- Returns target with new_value inserted. If target section designated by
1454−-- path is in a JSONB array, new_value will be inserted before target or after
1455−-- if insert_after is true (default is false). If target section designated by
1456−-- path is in JSONB object, new_value will be inserted only if target does not
1457−-- exist. As with the path orientated operators, negative integers that appear
1458−-- in path count from the end of JSON arrays.
1459−jsonbInsert
1460− :: PGTextArray "jsonbInsert" arr
1461− => Expression outer grp commons schemas params from (null 'PGjsonb)
1462− -> Expression outer grp commons schemas params from (null arr)
1463− -> Expression outer grp commons schemas params from (null 'PGjsonb)
1464− -> Maybe (Expression outer grp commons schemas params from (null 'PGbool))
1465− -> Expression outer grp commons schemas params from (null 'PGjsonb)
1466−jsonbInsert tgt path val insertAfter = case insertAfter of
1467− Just i -> unsafeVariadicFunction "jsonb_insert" (tgt :* path :* val :* i :* Nil)
1468− Nothing -> unsafeVariadicFunction "jsonb_insert" (tgt :* path :* val :* Nil)
1469−
1470−-- | Returns its argument as indented JSON text.
1471−jsonbPretty :: null 'PGjsonb :--> null 'PGtext
1472−jsonbPretty = unsafeFunction "jsonb_pretty"
1473−
1474−(@@) :: Operator (null 'PGtsvector) (null 'PGtsquery) ('Null 'PGbool)
1475−(@@) = unsafeBinaryOp "@@"
1476−
1477−(.&) :: Operator (null 'PGtsquery) (null 'PGtsquery) (null 'PGtsquery)
1478−(.&) = unsafeBinaryOp "&&"
1479−
1480−(.|) :: Operator (null 'PGtsquery) (null 'PGtsquery) (null 'PGtsquery)
1481−(.|) = unsafeBinaryOp "||"
1482−
1483−(.!) :: null 'PGtsquery :--> null 'PGtsquery
1484−(.!) = unsafeUnaryOpL "!!"
1485−
1486−(<->) :: Operator (null 'PGtsquery) (null 'PGtsquery) (null 'PGtsquery)
1487−(<->) = unsafeBinaryOp "<->"
1488−
1489−arrayToTSvector
1490− :: null ('PGvararray ('NotNull 'PGtext))
1491− :--> null 'PGtsvector
1492−arrayToTSvector = unsafeFunction "array_to_tsvector"
1493−
1494−tsvectorLength :: null 'PGtsvector :--> null 'PGint4
1495−tsvectorLength = unsafeFunction "length"
1496−
1497−numnode :: null 'PGtsquery :--> null 'PGint4
1498−numnode = unsafeFunction "numnode"
1499−
1500−plainToTSquery :: null 'PGtext :--> null 'PGtsquery
1501−plainToTSquery = unsafeFunction "plainto_tsquery"
1502−
1503−phraseToTSquery :: null 'PGtext :--> null 'PGtsquery
1504−phraseToTSquery = unsafeFunction "phraseto_tsquery"
1505−
1506−websearchToTSquery :: null 'PGtext :--> null 'PGtsquery
1507−websearchToTSquery = unsafeFunction "websearch_to_tsquery"
1508−
1509−queryTree :: null 'PGtsquery :--> null 'PGtext
1510−queryTree = unsafeFunction "query_tree"
1511−
1512−toTSquery :: null 'PGtext :--> null 'PGtsquery
1513−toTSquery = unsafeFunction "to_tsquery"
1514−
1515−toTSvector
1516− :: ty `In` '[ 'PGtext, 'PGjson, 'PGjsonb]
1517− => null ty :--> null 'PGtsquery
1518−toTSvector = unsafeFunction "to_tsvector"
1519−
1520−setWeight
1521− :: FunctionHet '[null 'PGtsvector, null ('PGchar 1)] (null 'PGtsvector)
1522−setWeight = unsafeFunctionHet "set_weight"
1523−
1524−litChar :: Char -> Expr (null ('PGchar 1))
1525−litChar chr = UnsafeExpression $
1526− "E\'" <> fromString (escape =<< [chr]) <> "\'"
1527−
1528−strip :: null 'PGtsvector :--> null 'PGtsvector
1529−strip = unsafeFunction "strip"
1530−
1531−jsonToTSvector :: FunctionHet '[null 'PGjson, null 'PGjson] (null 'PGtsvector)
1532−jsonToTSvector = unsafeFunctionHet "json_to_tsvector"
1533−
1534−jsonbToTSvector :: FunctionHet '[null 'PGjsonb, null 'PGjsonb] (null 'PGtsvector)
1535−jsonbToTSvector = unsafeFunctionHet "jsonb_to_tsvector"
1536−
1537−tsDelete :: FunctionHet
1538− '[null 'PGtsvector, null ('PGvararray ('NotNull 'PGtext))]
1539− (null 'PGtsvector)
1540−tsDelete = unsafeFunctionHet "ts_delete"
1541−
1542−tsFilter :: FunctionHet
1543− '[null 'PGtsvector, null ('PGvararray ('NotNull ('PGchar 1)))]
1544− (null 'PGtsvector)
1545−tsFilter = unsafeFunctionHet "ts_filter"
1546−
1547−tsHeadline
1548− :: document `In` '[ 'PGtext, 'PGjson, 'PGjsonb]
1549− => FunctionHet '[null document, null 'PGtsquery] (null 'PGtext)
1550−tsHeadline = unsafeFunctionHet "ts_headline"
1551−{-----------------------------------------
1552−aggregation
1553−-----------------------------------------}
1554−
1555−{- |
1556−`Aggregate` functions compute a single result from a set of input values.
1557−`Aggregate` functions can be used as `GroupedBy` `Expression`s as well
1558−as `WindowFunction`s.
1559−-}
1560−class Aggregate expr1 expr2 aggr
1561− | aggr -> expr1, aggr -> expr2 where
1562−
1563− -- | A special aggregation that does not require an input
1564− --
1565− -- >>> :{
1566− -- let
1567− -- expression :: Expression '[] ('Grouped bys) commons schemas params from ('NotNull 'PGint8)
1568− -- expression = countStar
1569− -- in printSQL expression
1570− -- :}
1571− -- count(*)
1572− countStar :: aggr ('NotNull 'PGint8)
1573−
1574− -- | >>> :{
1575− -- let
1576− -- expression :: Expression '[] ('Grouped bys) commons schemas params '[tab ::: '["col" ::: null ty]] ('NotNull 'PGint8)
1577− -- expression = count (All #col)
1578− -- in printSQL expression
1579− -- :}
1580− -- count(ALL "col")
1581− count
1582− :: expr1 ty
1583− -- ^ what to count
1584− -> aggr ('NotNull 'PGint8)
1585−
1586− -- | >>> :{
1587− -- let
1588− -- expression :: Expression '[] ('Grouped bys) commons schemas params '[tab ::: '["col" ::: 'Null 'PGnumeric]] ('NotNull 'PGnumeric)
1589− -- expression = sum_ (Distinct #col)
1590− -- in printSQL expression
1591− -- :}
1592− -- sum(DISTINCT "col")
1593− sum_
1594− :: ty `In` PGNum
1595− => expr1 (null ty)
1596− -> aggr ('NotNull ty)
1597−
1598− -- | input values, including nulls, concatenated into an array
1599− arrayAgg
1600− :: expr1 ty
1601− -> aggr ('Null ('PGvararray ty))
1602−
1603− -- | aggregates values as a JSON array
1604− jsonAgg
1605− :: expr1 ty
1606− -> aggr ('Null 'PGjson)
1607−
1608− -- | aggregates values as a JSON array
1609− jsonbAgg
1610− :: expr1 ty
1611− -> aggr ('Null 'PGjsonb)
1612−
1613− {- |
1614− the bitwise AND of all non-null input values, or null if none
1615− >>> :{
1616− let
1617− expression :: Expression '[] ('Grouped bys) commons schemas params '[tab ::: '["col" ::: null 'PGint4]] ('Null 'PGint4)
1618− expression = bitAnd (Distinct #col)
1619− in printSQL expression
1620− :}
1621− bit_and(DISTINCT "col")
1622− -}
1623− bitAnd
1624− :: int `In` PGIntegral
1625− => expr1 (null int)
1626− -- ^ what to aggregate
1627− -> aggr ('Null int)
1628−
1629− {- |
1630− the bitwise OR of all non-null input values, or null if none
1631−
1632− >>> :{
1633− let
1634− expression :: Expression '[] ('Grouped bys) commons schemas params '[tab ::: '["col" ::: null 'PGint4]] ('Null 'PGint4)
1635− expression = bitOr (All #col)
1636− in printSQL expression
1637− :}
1638− bit_or(ALL "col")
1639− -}
1640− bitOr
1641− :: int `In` PGIntegral
1642− => expr1 (null int)
1643− -- ^ what to aggregate
1644− -> aggr ('Null int)
1645−
1646− {- |
1647− true if all input values are true, otherwise false
1648−
1649− >>> :{
1650− let
1651− winFun :: WindowFunction '[] 'Ungrouped commons schemas params '[tab ::: '["col" ::: null 'PGbool]] ('Null 'PGbool)
1652− winFun = boolAnd #col
1653− in printSQL winFun
1654− :}
1655− bool_and("col")
1656− -}
1657− boolAnd
1658− :: expr1 (null 'PGbool)
1659− -- ^ what to aggregate
1660− -> aggr ('Null 'PGbool)
1661−
1662− {- |
1663− true if at least one input value is true, otherwise false
1664−
1665− >>> :{
1666− let
1667− expression :: Expression '[] ('Grouped bys) commons schemas params '[tab ::: '["col" ::: null 'PGbool]] ('Null 'PGbool)
1668− expression = boolOr (All #col)
1669− in printSQL expression
1670− :}
1671− bool_or(ALL "col")
1672− -}
1673− boolOr
1674− :: expr1(null 'PGbool)
1675− -- ^ what to aggregate
1676− -> aggr ('Null 'PGbool)
1677−
1678− {- |
1679− equivalent to `boolAnd`
1680−
1681− >>> :{
1682− let
1683− expression :: Expression '[] ('Grouped bys) commons schemas params '[tab ::: '["col" ::: null 'PGbool]] ('Null 'PGbool)
1684− expression = every (Distinct #col)
1685− in printSQL expression
1686− :}
1687− every(DISTINCT "col")
1688− -}
1689− every
1690− :: expr1 (null 'PGbool)
1691− -- ^ what to aggregate
1692− -> aggr ('Null 'PGbool)
1693−
1694− {- |maximum value of expression across all input values-}
1695− max_
1696− :: expr1 (null ty)
1697− -- ^ what to maximize
1698− -> aggr ('Null ty)
1699−
1700− -- | minimum value of expression across all input values
1701− min_
1702− :: expr1 (null ty)
1703− -- ^ what to minimize
1704− -> aggr ('Null ty)
1705−
1706− -- | the average (arithmetic mean) of all input values
1707− avg
1708− :: expr1 (null ty)
1709− -- ^ what to average
1710− -> aggr ('Null (PGAvg ty))
1711−
1712− {- | correlation coefficient
1713− >>> :{
1714− let
1715− expression :: Expression '[] ('Grouped g) c s p '[t ::: '["x" ::: 'NotNull 'PGfloat8, "y" ::: 'NotNull 'PGfloat8]] ('Null 'PGfloat8)
1716− expression = corr (All (#y :*: #x))
1717− in printSQL expression
1718− :}
1719− corr(ALL "y", "x")
1720− -}
1721− corr
1722− :: expr2 (null 'PGfloat8)
1723− -> aggr ('Null 'PGfloat8)
1724−
1725− {- | population covariance
1726− >>> :{
1727− let
1728− expression :: Expression '[] ('Grouped g) c s p '[t ::: '["x" ::: 'NotNull 'PGfloat8, "y" ::: 'NotNull 'PGfloat8]] ('Null 'PGfloat8)
1729− expression = covarPop (All (#y :*: #x))
1730− in printSQL expression
1731− :}
1732− covar_pop(ALL "y", "x")
1733− -}
1734− covarPop
1735− :: expr2 (null 'PGfloat8)
1736− -> aggr ('Null 'PGfloat8)
1737−
1738− {- | sample covariance
1739− >>> :{
1740− let
1741− winFun :: WindowFunction '[] 'Ungrouped c s p '[t ::: '["x" ::: 'NotNull 'PGfloat8, "y" ::: 'NotNull 'PGfloat8]] ('Null 'PGfloat8)
1742− winFun = covarSamp (#y :*: #x)
1743− in printSQL winFun
1744− :}
1745− covar_samp("y", "x")
1746− -}
1747− covarSamp
1748− :: expr2 (null 'PGfloat8)
1749− -> aggr ('Null 'PGfloat8)
1750−
1751− {- | average of the independent variable (sum(X)/N)
1752− >>> :{
1753− let
1754− expression :: Expression '[] ('Grouped g) c s p '[t ::: '["x" ::: 'NotNull 'PGfloat8, "y" ::: 'NotNull 'PGfloat8]] ('Null 'PGfloat8)
1755− expression = regrAvgX (All (#y :*: #x))
1756− in printSQL expression
1757− :}
1758− regr_avgx(ALL "y", "x")
1759− -}
1760− regrAvgX
1761− :: expr2 (null 'PGfloat8)
1762− -> aggr ('Null 'PGfloat8)
1763−
1764− {- | average of the dependent variable (sum(Y)/N)
1765− >>> :{
1766− let
1767− winFun :: WindowFunction '[] 'Ungrouped c s p '[t ::: '["x" ::: 'NotNull 'PGfloat8, "y" ::: 'NotNull 'PGfloat8]] ('Null 'PGfloat8)
1768− winFun = regrAvgY (#y :*: #x)
1769− in printSQL winFun
1770− :}
1771− regr_avgy("y", "x")
1772− -}
1773− regrAvgY
1774− :: expr2 (null 'PGfloat8)
1775− -> aggr ('Null 'PGfloat8)
1776−
1777− {- | number of input rows in which both expressions are nonnull
1778− >>> :{
1779− let
1780− winFun :: WindowFunction '[] 'Ungrouped c s p '[t ::: '["x" ::: 'NotNull 'PGfloat8, "y" ::: 'NotNull 'PGfloat8]] ('Null 'PGint8)
1781− winFun = regrCount (#y :*: #x)
1782− in printSQL winFun
1783− :}
1784− regr_count("y", "x")
1785− -}
1786− regrCount
1787− :: expr2 (null 'PGfloat8)
1788− -> aggr ('Null 'PGint8)
1789−
1790− {- | y-intercept of the least-squares-fit linear equation determined by the (X, Y) pairs
1791− >>> :{
1792− let
1793− expression :: Expression '[] ('Grouped g) c s p '[t ::: '["x" ::: 'NotNull 'PGfloat8, "y" ::: 'NotNull 'PGfloat8]] ('Null 'PGfloat8)
1794− expression = regrIntercept (All (#y :*: #x))
1795− in printSQL expression
1796− :}
1797− regr_intercept(ALL "y", "x")
1798− -}
1799− regrIntercept
1800− :: expr2 (null 'PGfloat8)
1801− -> aggr ('Null 'PGfloat8)
1802−
1803− -- | @regr_r2(Y, X)@, square of the correlation coefficient
1804− regrR2
1805− :: expr2 (null 'PGfloat8)
1806− -> aggr ('Null 'PGfloat8)
1807−
1808− -- | @regr_slope(Y, X)@, slope of the least-squares-fit linear equation
1809− -- determined by the (X, Y) pairs
1810− regrSlope
1811− :: expr2 (null 'PGfloat8)
1812− -> aggr ('Null 'PGfloat8)
1813−
1814− -- | @regr_sxx(Y, X)@, sum(X^2) - sum(X)^2/N
1815− -- (“sum of squares” of the independent variable)
1816− regrSxx
1817− :: expr2 (null 'PGfloat8)
1818− -> aggr ('Null 'PGfloat8)
1819−
1820− -- | @regr_sxy(Y, X)@, sum(X*Y) - sum(X) * sum(Y)/N
1821− -- (“sum of products” of independent times dependent variable)
1822− regrSxy
1823− :: expr2 (null 'PGfloat8)
1824− -> aggr ('Null 'PGfloat8)
1825−
1826− -- | @regr_syy(Y, X)@, sum(Y^2) - sum(Y)^2/N
1827− -- (“sum of squares” of the dependent variable)
1828− regrSyy
1829− :: expr2 (null 'PGfloat8)
1830− -> aggr ('Null 'PGfloat8)
1831−
1832− -- | historical alias for `stddevSamp`
1833− stddev
1834− :: expr1 (null ty)
1835− -> aggr ('Null (PGAvg ty))
1836−
1837− -- | population standard deviation of the input values
1838− stddevPop
1839− :: expr1 (null ty)
1840− -> aggr ('Null (PGAvg ty))
1841−
1842− -- | sample standard deviation of the input values
1843− stddevSamp
1844− :: expr1 (null ty)
1845− -> aggr ('Null (PGAvg ty))
1846−
1847− -- | historical alias for `varSamp`
1848− variance
1849− :: expr1 (null ty)
1850− -> aggr ('Null (PGAvg ty))
1851−
1852− -- | population variance of the input values
1853− -- (square of the population standard deviation)
1854− varPop
1855− :: expr1 (null ty)
1856− -> aggr ('Null (PGAvg ty))
1857−
1858− -- | sample variance of the input values
1859− -- (square of the sample standard deviation)
1860− varSamp
1861− :: expr1 (null ty)
1862− -> aggr ('Null (PGAvg ty))
1863−
1864−{- |
1865−`Distinction`s are used for the input of `Aggregate` `Expression`s.
1866−`All` invokes the aggregate once for each input row.
1867−`Distinct` invokes the aggregate once for each distinct value of the expression
1868−(or distinct set of values, for multiple expressions) found in the input
1869−-}
1870−data Distinction expr ty
1871− = All (expr ty)
1872− | Distinct (expr ty)
1873− deriving (GHC.Generic,Show,Eq,Ord)
1874−instance NFData (Distinction (Expression outer grp commons schemas params from) ty)
1875−instance RenderSQL (Distinction (Expression outer grp commons schemas params from) ty) where
1876− renderSQL = \case
1877− All x -> "ALL" <+> renderSQL x
1878− Distinct x -> "DISTINCT" <+> renderSQL x
1879−instance RenderSQL
1880− (Distinction
1881− ( Expression outer grp commons schemas params from
1882− :*:
1883− Expression outer grp commons schemas params from) xty ) where
1884− renderSQL = \case
1885− All (x :*: x') ->
1886− "ALL" <+> renderSQL x <> ", " <> renderSQL x'
1887− Distinct (x :*: x') ->
1888− "DISTINCT" <+> renderSQL x <> ", " <> renderSQL x'
1889−
1890−instance Aggregate
1891− (Distinction (Expression outer 'Ungrouped commons schemas params from))
1892− (Distinction (Expression outer 'Ungrouped commons schemas params from :*: Expression outer 'Ungrouped commons schemas params from))
1893− (Expression outer ('Grouped bys) commons schemas params from) where
1894− countStar = UnsafeExpression "count(*)"
1895− count = unsafeAggregate1 "count"
1896− sum_ = unsafeAggregate1 "sum"
1897− arrayAgg = unsafeAggregate1 "array_agg"
1898− jsonAgg = unsafeAggregate1 "json_agg"
1899− jsonbAgg = unsafeAggregate1 "jsonb_agg"
1900− bitAnd = unsafeAggregate1 "bit_and"
1901− bitOr = unsafeAggregate1 "bit_or"
1902− boolAnd = unsafeAggregate1 "bool_and"
1903− boolOr = unsafeAggregate1 "bool_or"
1904− every = unsafeAggregate1 "every"
1905− max_ = unsafeAggregate1 "max"
1906− min_ = unsafeAggregate1 "min"
1907− avg = unsafeAggregate1 "avg"
1908− corr = unsafeAggregate2 "corr"
1909− covarPop = unsafeAggregate2 "covar_pop"
1910− covarSamp = unsafeAggregate2 "covar_samp"
1911− regrAvgX = unsafeAggregate2 "regr_avgx"
1912− regrAvgY = unsafeAggregate2 "regr_avgy"
1913− regrCount = unsafeAggregate2 "regr_count"
1914− regrIntercept = unsafeAggregate2 "regr_intercept"
1915− regrR2 = unsafeAggregate2 "regr_r2"
1916− regrSlope = unsafeAggregate2 "regr_slope"
1917− regrSxx = unsafeAggregate2 "regr_sxx"
1918− regrSxy = unsafeAggregate2 "regr_sxy"
1919− regrSyy = unsafeAggregate2 "regr_syy"
1920− stddev = unsafeAggregate1 "stddev"
1921− stddevPop = unsafeAggregate1 "stddev_pop"
1922− stddevSamp = unsafeAggregate1 "stddev_samp"
1923− variance = unsafeAggregate1 "variance"
1924− varPop = unsafeAggregate1 "var_pop"
1925− varSamp = unsafeAggregate1 "var_samp"
1926−instance Aggregate
1927− (Expression outer grp commons schemas params from)
1928− (Expression outer grp commons schemas params from :*: Expression outer grp commons schemas params from)
1929− (WindowFunction outer grp commons schemas params from) where
1930− countStar = UnsafeWindowFunction "count(*)"
1931− count = unsafeWindowFunction1 "count"
1932− sum_ = unsafeWindowFunction1 "sum"
1933− arrayAgg = unsafeWindowFunction1 "array_agg"
1934− jsonAgg = unsafeWindowFunction1 "json_agg"
1935− jsonbAgg = unsafeWindowFunction1 "jsonb_agg"
1936− bitAnd = unsafeWindowFunction1 "bit_and"
1937− bitOr = unsafeWindowFunction1 "bit_or"
1938− boolAnd = unsafeWindowFunction1 "bool_and"
1939− boolOr = unsafeWindowFunction1 "bool_or"
1940− every = unsafeWindowFunction1 "every"
1941− max_ = unsafeWindowFunction1 "max"
1942− min_ = unsafeWindowFunction1 "min"
1943− avg = unsafeWindowFunction1 "avg"
1944− corr = unsafeWindowFunction2 "corr"
1945− covarPop = unsafeWindowFunction2 "covar_pop"
1946− covarSamp = unsafeWindowFunction2 "covar_samp"
1947− regrAvgX = unsafeWindowFunction2 "regr_avgx"
1948− regrAvgY = unsafeWindowFunction2 "regr_avgy"
1949− regrCount = unsafeWindowFunction2 "regr_count"
1950− regrIntercept = unsafeWindowFunction2 "regr_intercept"
1951− regrR2 = unsafeWindowFunction2 "regr_r2"
1952− regrSlope = unsafeWindowFunction2 "regr_slope"
1953− regrSxx = unsafeWindowFunction2 "regr_sxx"
1954− regrSxy = unsafeWindowFunction2 "regr_sxy"
1955− regrSyy = unsafeWindowFunction2 "regr_syy"
1956− stddev = unsafeWindowFunction1 "stddev"
1957− stddevPop = unsafeWindowFunction1 "stddev_pop"
1958− stddevSamp = unsafeWindowFunction1 "stddev_samp"
1959− variance = unsafeWindowFunction1 "variance"
1960− varPop = unsafeWindowFunction1 "var_pop"
1961− varSamp = unsafeWindowFunction1 "var_samp"
1962−
1963−-- | escape hatch to define aggregate functions
1964−unsafeAggregate1
1965− :: ByteString -- ^ aggregate function
1966− -> Distinction (Expression outer 'Ungrouped commons schemas params from) xty
1967− -> Expression outer ('Grouped bys) commons schemas params from yty
1968−unsafeAggregate1 fun x = UnsafeExpression $ mconcat
1969− [fun, "(", renderSQL x, ")"]
1970−
1971−-- | escape hatch to define aggregate binary functions
1972−unsafeAggregate2
1973− :: ByteString -- ^ aggregate function
1974− -> Distinction (Expression outer 'Ungrouped commons schemas params from :*: Expression outer 'Ungrouped commons schemas params from) xty
1975− -> Expression outer ('Grouped bys) commons schemas params from yty
1976−unsafeAggregate2 fun xx = UnsafeExpression $ mconcat
1977− [fun, "(", renderSQL xx, ")"]
1978−
1979−-- | A type family that calculates `PGAvg` type of a `PGType`.
1980−type family PGAvg ty where
1981− PGAvg 'PGint2 = 'PGnumeric
1982− PGAvg 'PGint4 = 'PGnumeric
1983− PGAvg 'PGint8 = 'PGnumeric
1984− PGAvg 'PGnumeric = 'PGnumeric
1985− PGAvg 'PGfloat4 = 'PGfloat8
1986− PGAvg 'PGfloat8 = 'PGfloat8
1987− PGAvg 'PGinterval = 'PGinterval
1988− PGAvg pg = TypeError
1989− ('Text "Squeal type error: No average for " ':<>: 'ShowType pg)
1990−
1991−{-----------------------------------------
1992−type expressions
1993−-----------------------------------------}
1994−
1995−-- | `TypeExpression`s are used in `cast`s and
1996−-- `Squeal.PostgreSQL.Definition.createTable` commands.
1997−newtype TypeExpression (schemas :: SchemasType) (ty :: NullityType)
1998− = UnsafeTypeExpression { renderTypeExpression :: ByteString }
1999− deriving (GHC.Generic,Show,Eq,Ord,NFData)
2000−instance RenderSQL (TypeExpression schemas ty) where
2001− renderSQL = renderTypeExpression
2002−
2003−-- | The enum or composite type in a `Typedef` can be expressed by its alias.
2004−typedef
2005− :: (Has sch schemas schema, Has td schema ('Typedef ty))
2006− => QualifiedAlias sch td
2007− -> TypeExpression schemas (null ty)
2008−typedef = UnsafeTypeExpression . renderSQL
2009−
2010−-- | The composite type corresponding to a `Table` definition can be expressed
2011−-- by its alias.
2012−typetable
2013− :: (Has sch schemas schema, Has tab schema ('Table table))
2014− => QualifiedAlias sch tab
2015− -> TypeExpression schemas (null ('PGcomposite (TableToRow table)))
2016−typetable = UnsafeTypeExpression . renderSQL
2017−
2018−-- | The composite type corresponding to a `View` definition can be expressed
2019−-- by its alias.
2020−typeview
2021− :: (Has sch schemas schema, Has vw schema ('View view))
2022− => QualifiedAlias sch vw
2023− -> TypeExpression schemas (null ('PGcomposite view))
2024−typeview = UnsafeTypeExpression . renderSQL
2025−
2026−-- | logical Boolean (true/false)
2027−bool :: TypeExpression schemas (null 'PGbool)
2028−bool = UnsafeTypeExpression "bool"
2029−-- | signed two-byte integer
2030−int2, smallint :: TypeExpression schemas (null 'PGint2)
2031−int2 = UnsafeTypeExpression "int2"
2032−smallint = UnsafeTypeExpression "smallint"
2033−-- | signed four-byte integer
2034−int4, int, integer :: TypeExpression schemas (null 'PGint4)
2035−int4 = UnsafeTypeExpression "int4"
2036−int = UnsafeTypeExpression "int"
2037−integer = UnsafeTypeExpression "integer"
2038−-- | signed eight-byte integer
2039−int8, bigint :: TypeExpression schemas (null 'PGint8)
2040−int8 = UnsafeTypeExpression "int8"
2041−bigint = UnsafeTypeExpression "bigint"
2042−-- | arbitrary precision numeric type
2043−numeric :: TypeExpression schemas (null 'PGnumeric)
2044−numeric = UnsafeTypeExpression "numeric"
2045−-- | single precision floating-point number (4 bytes)
2046−float4, real :: TypeExpression schemas (null 'PGfloat4)
2047−float4 = UnsafeTypeExpression "float4"
2048−real = UnsafeTypeExpression "real"
2049−-- | double precision floating-point number (8 bytes)
2050−float8, doublePrecision :: TypeExpression schemas (null 'PGfloat8)
2051−float8 = UnsafeTypeExpression "float8"
2052−doublePrecision = UnsafeTypeExpression "double precision"
2053−-- | currency amount
2054−money :: TypeExpression schema (null 'PGmoney)
2055−money = UnsafeTypeExpression "money"
2056−-- | variable-length character string
2057−text :: TypeExpression schemas (null 'PGtext)
2058−text = UnsafeTypeExpression "text"
2059−-- | fixed-length character string
2060−char, character
2061− :: forall n schemas null. (KnownNat n, 1 <= n)
2062− => TypeExpression schemas (null ('PGchar n))
2063−char = UnsafeTypeExpression $ "char(" <> renderNat @n <> ")"
2064−character = UnsafeTypeExpression $ "character(" <> renderNat @n <> ")"
2065−-- | variable-length character string
2066−varchar, characterVarying
2067− :: forall n schemas null. (KnownNat n, 1 <= n)
2068− => TypeExpression schemas (null ('PGvarchar n))
2069−varchar = UnsafeTypeExpression $ "varchar(" <> renderNat @n <> ")"
2070−characterVarying = UnsafeTypeExpression $
2071− "character varying(" <> renderNat @n <> ")"
2072−-- | binary data ("byte array")
2073−bytea :: TypeExpression schemas (null 'PGbytea)
2074−bytea = UnsafeTypeExpression "bytea"
2075−-- | date and time (no time zone)
2076−timestamp :: TypeExpression schemas (null 'PGtimestamp)
2077−timestamp = UnsafeTypeExpression "timestamp"
2078−-- | date and time, including time zone
2079−timestampWithTimeZone :: TypeExpression schemas (null 'PGtimestamptz)
2080−timestampWithTimeZone = UnsafeTypeExpression "timestamp with time zone"
2081−-- | calendar date (year, month, day)
2082−date :: TypeExpression schemas (null 'PGdate)
2083−date = UnsafeTypeExpression "date"
2084−-- | time of day (no time zone)
2085−time :: TypeExpression schemas (null 'PGtime)
2086−time = UnsafeTypeExpression "time"
2087−-- | time of day, including time zone
2088−timeWithTimeZone :: TypeExpression schemas (null 'PGtimetz)
2089−timeWithTimeZone = UnsafeTypeExpression "time with time zone"
2090−-- | time span
2091−interval :: TypeExpression schemas (null 'PGinterval)
2092−interval = UnsafeTypeExpression "interval"
2093−-- | universally unique identifier
2094−uuid :: TypeExpression schemas (null 'PGuuid)
2095−uuid = UnsafeTypeExpression "uuid"
2096−-- | IPv4 or IPv6 host address
2097−inet :: TypeExpression schemas (null 'PGinet)
2098−inet = UnsafeTypeExpression "inet"
2099−-- | textual JSON data
2100−json :: TypeExpression schemas (null 'PGjson)
2101−json = UnsafeTypeExpression "json"
2102−-- | binary JSON data, decomposed
2103−jsonb :: TypeExpression schemas (null 'PGjsonb)
2104−jsonb = UnsafeTypeExpression "jsonb"
2105−-- | variable length array
2106−vararray
2107− :: TypeExpression schemas pg
2108− -> TypeExpression schemas (null ('PGvararray pg))
2109−vararray ty = UnsafeTypeExpression $ renderSQL ty <> "[]"
2110−-- | fixed length array
2111−--
2112−-- >>> renderSQL (fixarray @'[2] json)
2113−-- "json[2]"
2114−fixarray
2115− :: forall dims schemas null pg. SOP.All KnownNat dims
2116− => TypeExpression schemas pg
2117− -> TypeExpression schemas (null ('PGfixarray dims pg))
2118−fixarray ty = UnsafeTypeExpression $
2119− renderSQL ty <> renderDims @dims
2120− where
2121− renderDims :: forall ns. SOP.All KnownNat ns => ByteString
2122− renderDims =
2123− ("[" <>)
2124− . (<> "]")
2125− . ByteString.intercalate "]["
2126− . hcollapse
2127− $ hcmap (SOP.Proxy @KnownNat)
2128− (K . fromString . show . natVal)
2129− (hpure SOP.Proxy :: NP SOP.Proxy ns)
2130−tsvector :: TypeExpression schemas (null 'PGtsvector)
2131−tsvector = UnsafeTypeExpression "tsvector"
2132−tsquery :: TypeExpression schemas (null 'PGtsquery)
2133−tsquery = UnsafeTypeExpression "tsquery"
2134−
2135−-- | `pgtype` is a demoted version of a `PGType`
2136−class PGTyped schemas (ty :: NullityType) where
2137− pgtype :: TypeExpression schemas ty
2138−instance PGTyped schemas (null 'PGbool) where pgtype = bool
2139−instance PGTyped schemas (null 'PGint2) where pgtype = int2
2140−instance PGTyped schemas (null 'PGint4) where pgtype = int4
2141−instance PGTyped schemas (null 'PGint8) where pgtype = int8
2142−instance PGTyped schemas (null 'PGnumeric) where pgtype = numeric
2143−instance PGTyped schemas (null 'PGfloat4) where pgtype = float4
2144−instance PGTyped schemas (null 'PGfloat8) where pgtype = float8
2145−instance PGTyped schemas (null 'PGmoney) where pgtype = money
2146−instance PGTyped schemas (null 'PGtext) where pgtype = text
2147−instance (KnownNat n, 1 <= n)
2148− => PGTyped schemas (null ('PGchar n)) where pgtype = char @n
2149−instance (KnownNat n, 1 <= n)
2150− => PGTyped schemas (null ('PGvarchar n)) where pgtype = varchar @n
2151−instance PGTyped schemas (null 'PGbytea) where pgtype = bytea
2152−instance PGTyped schemas (null 'PGtimestamp) where pgtype = timestamp
2153−instance PGTyped schemas (null 'PGtimestamptz) where pgtype = timestampWithTimeZone
2154−instance PGTyped schemas (null 'PGdate) where pgtype = date
2155−instance PGTyped schemas (null 'PGtime) where pgtype = time
2156−instance PGTyped schemas (null 'PGtimetz) where pgtype = timeWithTimeZone
2157−instance PGTyped schemas (null 'PGinterval) where pgtype = interval
2158−instance PGTyped schemas (null 'PGuuid) where pgtype = uuid
2159−instance PGTyped schemas (null 'PGjson) where pgtype = json
2160−instance PGTyped schemas (null 'PGjsonb) where pgtype = jsonb
2161−instance PGTyped schemas ty
2162− => PGTyped schemas (null ('PGvararray ty)) where
2163− pgtype = vararray (pgtype @schemas @ty)
2164−instance (SOP.All KnownNat dims, PGTyped schemas ty)
2165− => PGTyped schemas (null ('PGfixarray dims ty)) where
2166− pgtype = fixarray @dims (pgtype @schemas @ty)
2167−instance PGTyped schemas (null 'PGtsvector) where pgtype = tsvector
2168−instance PGTyped schemas (null 'PGtsquery) where pgtype = tsquery
2169−
2170−{-----------------------------------------
2171−Sorting
2172−-----------------------------------------}
2173−
2174−-- | `SortExpression`s are used by `orderBy` to optionally sort the results
2175−-- of a `Squeal.PostgreSQL.Query.Query`. `Asc` or `Desc`
2176−-- set the sort direction of a `NotNull` result
2177−-- column to ascending or descending. Ascending order puts smaller values
2178−-- first, where "smaller" is defined in terms of the `.<` operator. Similarly,
2179−-- descending order is determined with the `.>` operator. `AscNullsFirst`,
2180−-- `AscNullsLast`, `DescNullsFirst` and `DescNullsLast` options are used to
2181−-- determine whether nulls appear before or after non-null values in the sort
2182−-- ordering of a `Null` result column.
2183−data SortExpression outer grp commons schemas params from where
2184− Asc
2185− :: Expression outer grp commons schemas params from ('NotNull ty)
2186− -> SortExpression outer grp commons schemas params from
2187− Desc
2188− :: Expression outer grp commons schemas params from ('NotNull ty)
2189− -> SortExpression outer grp commons schemas params from
2190− AscNullsFirst
2191− :: Expression outer grp commons schemas params from ('Null ty)
2192− -> SortExpression outer grp commons schemas params from
2193− AscNullsLast
2194− :: Expression outer grp commons schemas params from ('Null ty)
2195− -> SortExpression outer grp commons schemas params from
2196− DescNullsFirst
2197− :: Expression outer grp commons schemas params from ('Null ty)
2198− -> SortExpression outer grp commons schemas params from
2199− DescNullsLast
2200− :: Expression outer grp commons schemas params from ('Null ty)
2201− -> SortExpression outer grp commons schemas params from
2202−deriving instance Show (SortExpression outer grp commons schemas params from)
2203−
2204−{- |
2205−The `orderBy` clause causes the result rows of a `Squeal.PostgreSQL.Query.TableExpression`
2206−to be sorted according to the specified `SortExpression`(s).
2207−If two rows are equal according to the leftmost expression,
2208−they are compared according to the next expression and so on.
2209−If they are equal according to all specified expressions,
2210−they are returned in an implementation-dependent order.
2211−
2212−You can also control the order in which rows are processed by window functions
2213−using `orderBy` within `Squeal.PostgreSQL.Query.Over`.
2214−-}
2215−class OrderBy expr where
2216− orderBy
2217− :: [SortExpression outer grp commons schemas params from]
2218− -> expr outer grp commons schemas params from
2219− -> expr outer grp commons schemas params from
2220−
2221−-- | Render a `SortExpression`.
2222−instance RenderSQL (SortExpression outer grp commons schemas params from) where
2223− renderSQL = \case
2224− Asc expression -> renderSQL expression <+> "ASC"
2225− Desc expression -> renderSQL expression <+> "DESC"
2226− AscNullsFirst expression -> renderSQL expression
2227− <+> "ASC NULLS FIRST"
2228− DescNullsFirst expression -> renderSQL expression
2229− <+> "DESC NULLS FIRST"
2230− AscNullsLast expression -> renderSQL expression <+> "ASC NULLS LAST"
2231− DescNullsLast expression -> renderSQL expression <+> "DESC NULLS LAST"
2232−
2233−-- | A `WindowDefinition` is a set of table rows that are somehow related
2234−-- to the current row
2235−data WindowDefinition outer grp commons schemas params from where
2236− WindowDefinition
2237− :: SListI bys
2238− => NP (Expression outer grp commons schemas params from) bys
2239− -> [SortExpression outer grp commons schemas params from]
2240− -> WindowDefinition outer grp commons schemas params from
2241−
2242−instance OrderBy WindowDefinition where
2243− orderBy sortsR (WindowDefinition parts sortsL)
2244− = WindowDefinition parts (sortsL ++ sortsR)
2245−
2246−instance RenderSQL (WindowDefinition outer commons schemas from grp params) where
2247− renderSQL (WindowDefinition part ord) =
2248− renderPartitionByClause part <> renderOrderByClause ord
2249− where
2250− renderPartitionByClause = \case
2251− Nil -> ""
2252− parts -> "PARTITION" <+> "BY" <+> renderCommaSeparated renderExpression parts
2253− renderOrderByClause = \case
2254− [] -> ""
2255− srts -> " ORDER" <+> "BY"
2256− <+> commaSeparated (renderSQL <$> srts)
2257−
2258−{- |
2259−The `partitionBy` clause within `Squeal.PostgreSQL.Query.Over` divides the rows into groups,
2260−or partitions, that share the same values of the `partitionBy` `Expression`(s).
2261−For each row, the window function is computed across the rows that fall into
2262−the same partition as the current row.
2263−-}
2264−partitionBy
2265− :: SListI bys
2266− => NP (Expression outer grp commons schemas params from) bys
2267− -> WindowDefinition outer grp commons schemas params from
2268−partitionBy bys = WindowDefinition bys []
2269−
2270−{- |
2271−A window function performs a calculation across a set of table rows
2272−that are somehow related to the current row. This is comparable to the type
2273−of calculation that can be done with an aggregate function.
2274−However, window functions do not cause rows to become grouped into a single
2275−output row like non-window aggregate calls would.
2276−Instead, the rows retain their separate identities.
2277−Behind the scenes, the window function is able to access more than
2278−just the current row of the query result.
2279−-}
2280−newtype WindowFunction
2281− (outer :: FromType)
2282− (grp :: Grouping)
2283− (commons :: FromType)
2284− (schemas :: SchemasType)
2285− (params :: [NullityType])
2286− (from :: FromType)
2287− (ty :: NullityType)
2288− = UnsafeWindowFunction { renderWindowFunction :: ByteString }
2289− deriving (GHC.Generic,Show,Eq,Ord,NFData)
2290−
2291−instance RenderSQL (WindowFunction outer grp commons schemas params from ty) where
2292− renderSQL = renderWindowFunction
2293−
2294−unsafeWindowFunction1
2295− :: ByteString
2296− -> Expression outer grp commons schemas params from ty0
2297− -> WindowFunction outer grp commons schemas params from ty1
2298−unsafeWindowFunction1 fun x
2299− = UnsafeWindowFunction $ fun <> parenthesized (renderSQL x)
2300−
2301−unsafeWindowFunction2
2302− :: ByteString
2303− -> (Expression outer grp commons schemas params from :*: Expression outer grp commons schemas params from) ty0
2304− -> WindowFunction outer grp commons schemas params from ty1
2305−unsafeWindowFunction2 fun (x :*: x')
2306− = UnsafeWindowFunction $ fun <> parenthesized (renderSQL x <> ", " <> renderSQL x')
2307−
2308−{- | rank of the current row with gaps; same as `rowNumber` of its first peer
2309−>>> printSQL rank
2310−rank()
2311−-}
2312−rank :: WindowFunction outer grp commons schemas params from ('NotNull 'PGint8)
2313−rank = UnsafeWindowFunction "rank()"
2314−
2315−{- | number of the current row within its partition, counting from 1
2316−>>> printSQL rowNumber
2317−row_number()
2318−-}
2319−rowNumber :: WindowFunction outer grp commons schemas params from ('NotNull 'PGint8)
2320−rowNumber = UnsafeWindowFunction "row_number()"
2321−
2322−{- | rank of the current row without gaps; this function counts peer groups
2323−>>> printSQL denseRank
2324−dense_rank()
2325−-}
2326−denseRank :: WindowFunction outer grp commons schemas params from ('NotNull 'PGint8)
2327−denseRank = UnsafeWindowFunction "dense_rank()"
2328−
2329−{- | relative rank of the current row: (rank - 1) / (total partition rows - 1)
2330−>>> printSQL percentRank
2331−percent_rank()
2332−-}
2333−percentRank :: WindowFunction outer grp commons schemas params from ('NotNull 'PGfloat8)
2334−percentRank = UnsafeWindowFunction "percent_rank()"
2335−
2336−{- | cumulative distribution: (number of partition rows
2337−preceding or peer with current row) / total partition rows
2338−>>> printSQL cumeDist
2339−cume_dist()
2340−-}
2341−cumeDist :: WindowFunction outer grp commons schemas params from ('NotNull 'PGfloat8)
2342−cumeDist = UnsafeWindowFunction "cume_dist()"
2343−
2344−{- | integer ranging from 1 to the argument value,
2345−dividing the partition as equally as possible
2346−-}
2347−ntile
2348− :: Expression outer grp commons schemas params from ('NotNull 'PGint4)
2349− -- ^ num buckets
2350− -> WindowFunction outer grp commons schemas params from ('NotNull 'PGint4)
2351−ntile = unsafeWindowFunction1 "ntile"
2352−
2353−{- | returns value evaluated at the row that is offset rows before the current
2354−row within the partition; if there is no such row, instead return default
2355−(which must be of the same type as value). Both offset and default are
2356−evaluated with respect to the current row.
2357−-}
2358−lag
2359− :: Expression outer grp commons schemas params from ty
2360− -- ^ value
2361− -> Expression outer grp commons schemas params from ('NotNull 'PGint4)
2362− -- ^ offset
2363− -> Expression outer grp commons schemas params from ty
2364− -- ^ default
2365− -> WindowFunction outer grp commons schemas params from ty
2366−lag value offset def = UnsafeWindowFunction $ "lag"
2367− <> parenthesized
2368− (commaSeparated ([renderSQL value, renderSQL offset, renderSQL def]))
2369−
2370−{- | returns value evaluated at the row that is offset rows after the current
2371−row within the partition; if there is no such row, instead return default
2372−(which must be of the same type as value). Both offset and default are
2373−evaluated with respect to the current row.
2374−-}
2375−lead
2376− :: Expression outer grp commons schemas params from ty
2377− -- ^ value
2378− -> Expression outer grp commons schemas params from ('NotNull 'PGint4)
2379− -- ^ offset
2380− -> Expression outer grp commons schemas params from ty
2381− -- ^ default
2382− -> WindowFunction outer grp commons schemas params from ty
2383−lead value offset def = UnsafeWindowFunction $ "lag"
2384− <> parenthesized
2385− (commaSeparated ([renderSQL value, renderSQL offset, renderSQL def]))
2386−
2387−{- | returns value evaluated at the row that is the
2388−first row of the window frame
2389−-}
2390−firstValue
2391− :: Expression outer grp commons schemas params from ty
2392− -- ^ value
2393− -> WindowFunction outer grp commons schemas params from ty
2394−firstValue = unsafeWindowFunction1 "first_value"
2395−
2396−{- | returns value evaluated at the row that is the
2397−last row of the window frame
2398−-}
2399−lastValue
2400− :: Expression outer grp commons schemas params from ty
2401− -- ^ value
2402− -> WindowFunction outer grp commons schemas params from ty
2403−lastValue = unsafeWindowFunction1 "last_value"
2404−
2405−{- | returns value evaluated at the row that is the nth
2406−row of the window frame (counting from 1); null if no such row
2407−-}
2408−nthValue
2409− :: Expression outer grp commons schemas params from (null ty)
2410− -- ^ value
2411− -> Expression outer grp commons schemas params from ('NotNull 'PGint4)
2412− -- ^ nth
2413− -> WindowFunction outer grp commons schemas params from ('Null ty)
2414−nthValue value nth = UnsafeWindowFunction $ "nth_value"
2415− <> parenthesized (commaSeparated [renderSQL value, renderSQL nth])
2416−
2417−{-|
2418−Create date from year, month and day fields
2419−
2420−>>> printSQL (makeDate (1984 :* 7 *: 3))
2421−make_date(1984, 7, 3)
2422−-}
2423−makeDate :: FunctionHet
2424− '[ null 'PGint4, null 'PGint4, null 'PGint4 ]
2425− ( null 'PGdate )
2426−makeDate = unsafeFunctionHet "make_date"
2427−
2428−{-|
2429−Create time from hour, minute and seconds fields
2430−
2431−>>> printSQL (makeTime (8 :* 15 *: 23.5))
2432−make_time(8, 15, 23.5)
2433−-}
2434−makeTime :: FunctionHet
2435− '[ null 'PGint4, null 'PGint4, null 'PGfloat8 ]
2436− ( null 'PGtime )
2437−makeTime = unsafeFunctionHet "make_time"
2438−
2439−{-|
2440−Create timestamp from year, month, day, hour, minute and seconds fields
2441−
2442−>>> printSQL (makeTimestamp (2013 :* 7 :* 15 :* 8 :* 15 *: 23.5))
2443−make_timestamp(2013, 7, 15, 8, 15, 23.5)
2444−-}
2445−makeTimestamp :: FunctionHet
2446− '[ null 'PGint4, null 'PGint4, null 'PGint4
2447− , null 'PGint4, null 'PGint4, null 'PGfloat8 ]
2448− ( null 'PGtimestamp )
2449−makeTimestamp = unsafeFunctionHet "make_timestamp"
2450−
2451−{-|
2452−Create timestamp with time zone from
2453−year, month, day, hour, minute and seconds fields;
2454−the current time zone is used
2455−
2456−>>> printSQL (makeTimestamptz (2013 :* 7 :* 15 :* 8 :* 15 *: 23.5))
2457−make_timestamptz(2013, 7, 15, 8, 15, 23.5)
2458−-}
2459−makeTimestamptz :: FunctionHet
2460− '[ null 'PGint4, null 'PGint4, null 'PGint4
2461− , null 'PGint4, null 'PGint4, null 'PGfloat8 ]
2462− ( null 'PGtimestamptz )
2463−makeTimestamptz = unsafeFunctionHet "make_timestamptz"
2464−
2465−{-|
2466−Affine space operations on time types.
2467−-}
2468−class TimeOp time diff | time -> diff where
2469− {-|
2470− >>> printSQL (makeDate (1984 :* 7 *: 3) !+ 365)
2471− (make_date(1984, 7, 3) + 365)
2472− -}
2473− (!+) :: Operator (null time) (null diff) (null time)
2474− (!+) = unsafeBinaryOp "+"
2475− {-|
2476− >>> printSQL (365 +! makeDate (1984 :* 7 *: 3))
2477− (365 + make_date(1984, 7, 3))
2478− -}
2479− (+!) :: Operator (null diff) (null time) (null time)
2480− (+!) = unsafeBinaryOp "+"
2481− {-|
2482− >>> printSQL (makeDate (1984 :* 7 *: 3) !- 365)
2483− (make_date(1984, 7, 3) - 365)
2484− -}
2485− (!-) :: Operator (null time) (null diff) (null time)
2486− (!-) = unsafeBinaryOp "-"
2487− {-|
2488− >>> printSQL (makeDate (1984 :* 7 *: 3) !-! currentDate)
2489− (make_date(1984, 7, 3) - CURRENT_DATE)
2490− -}
2491− (!-!) :: Operator (null time) (null time) (null diff)
2492− (!-!) = unsafeBinaryOp "-"
2493−instance TimeOp 'PGtimestamp 'PGinterval
2494−instance TimeOp 'PGtimestamptz 'PGinterval
2495−instance TimeOp 'PGtime 'PGinterval
2496−instance TimeOp 'PGtimetz 'PGinterval
2497−instance TimeOp 'PGinterval 'PGinterval
2498−instance TimeOp 'PGdate 'PGint4
2499−infixl 6 !+
2500−infixl 6 +!
2501−infixl 6 !-
2502−infixl 6 !-!
squeal-postgresql/src/Squeal/PostgreSQL/Expression/Aggregate.hsnew file+462
@@ -0,0 +1,462 @@
1+{-|
2+Module: Squeal.PostgreSQL.Expression.Aggregate
3+Description: Aggregate functions
4+Copyright: (c) Eitan Chatav, 2019
5+Maintainer: eitan@morphism.tech
6+Stability: experimental
7+
8+Aggregate functions
9+-}
10+
11+{-# LANGUAGE
12+ DataKinds
13+ , DeriveGeneric
14+ , FlexibleContexts
15+ , FlexibleInstances
16+ , FunctionalDependencies
17+ , LambdaCase
18+ , MultiParamTypeClasses
19+ , OverloadedStrings
20+ , PolyKinds
21+ , TypeFamilies
22+ , TypeOperators
23+ , UndecidableInstances
24+#-}
25+
26+module Squeal.PostgreSQL.Expression.Aggregate
27+ ( Aggregate (..)
28+ , Distinction (..)
29+ , PGSum
30+ , PGAvg
31+ ) where
32+
33+import Control.DeepSeq
34+import Data.ByteString (ByteString)
35+import Data.Kind
36+import GHC.TypeLits
37+
38+import qualified GHC.Generics as GHC
39+import qualified Generics.SOP as SOP
40+
41+import Squeal.PostgreSQL.Alias
42+import Squeal.PostgreSQL.Expression
43+import Squeal.PostgreSQL.List
44+import Squeal.PostgreSQL.Render
45+import Squeal.PostgreSQL.Schema
46+
47+-- $setup
48+-- >>> import Squeal.PostgreSQL
49+
50+{- |
51+`Aggregate` functions compute a single result from a set of input values.
52+`Aggregate` functions can be used as `GroupedBy` `Expression`s as well
53+as `Squeal.PostgreSQL.Expression.Window.WindowFunction`s.
54+-}
55+class Aggregate expr1 exprN aggr
56+ | aggr -> expr1, aggr -> exprN where
57+
58+ -- | A special aggregation that does not require an input
59+ --
60+ -- >>> :{
61+ -- let
62+ -- expression :: Expression '[] commons ('Grouped bys) schemas params from ('NotNull 'PGint8)
63+ -- expression = countStar
64+ -- in printSQL expression
65+ -- :}
66+ -- count(*)
67+ countStar :: aggr ('NotNull 'PGint8)
68+
69+ -- | >>> :{
70+ -- let
71+ -- expression :: Expression '[] commons ('Grouped bys) schemas params '[tab ::: '["col" ::: null ty]] ('NotNull 'PGint8)
72+ -- expression = count (All #col)
73+ -- in printSQL expression
74+ -- :}
75+ -- count(ALL "col")
76+ count
77+ :: expr1 ty
78+ -- ^ what to count
79+ -> aggr ('NotNull 'PGint8)
80+
81+ -- | >>> :{
82+ -- let
83+ -- expression :: Expression '[] commons ('Grouped bys) schemas params '[tab ::: '["col" ::: 'Null 'PGnumeric]] ('Null 'PGnumeric)
84+ -- expression = sum_ (Distinct #col)
85+ -- in printSQL expression
86+ -- :}
87+ -- sum(DISTINCT "col")
88+ sum_
89+ :: expr1 (null ty)
90+ -> aggr ('Null (PGSum ty))
91+
92+ -- | input values, including nulls, concatenated into an array
93+ arrayAgg
94+ :: expr1 ty
95+ -> aggr ('Null ('PGvararray ty))
96+
97+ -- | aggregates values as a JSON array
98+ jsonAgg
99+ :: expr1 ty
100+ -> aggr ('Null 'PGjson)
101+
102+ -- | aggregates values as a JSON array
103+ jsonbAgg
104+ :: expr1 ty
105+ -> aggr ('Null 'PGjsonb)
106+
107+ {- |
108+ the bitwise AND of all non-null input values, or null if none
109+
110+ >>> :{
111+ let
112+ expression :: Expression '[] commons ('Grouped bys) schemas params '[tab ::: '["col" ::: null 'PGint4]] ('Null 'PGint4)
113+ expression = bitAnd (Distinct #col)
114+ in printSQL expression
115+ :}
116+ bit_and(DISTINCT "col")
117+ -}
118+ bitAnd
119+ :: int `In` PGIntegral
120+ => expr1 (null int)
121+ -- ^ what to aggregate
122+ -> aggr ('Null int)
123+
124+ {- |
125+ the bitwise OR of all non-null input values, or null if none
126+
127+ >>> :{
128+ let
129+ expression :: Expression '[] commons ('Grouped bys) schemas params '[tab ::: '["col" ::: null 'PGint4]] ('Null 'PGint4)
130+ expression = bitOr (All #col)
131+ in printSQL expression
132+ :}
133+ bit_or(ALL "col")
134+ -}
135+ bitOr
136+ :: int `In` PGIntegral
137+ => expr1 (null int)
138+ -- ^ what to aggregate
139+ -> aggr ('Null int)
140+
141+ {- |
142+ true if all input values are true, otherwise false
143+
144+ >>> :{
145+ let
146+ winFun :: WindowFunction '[] commons 'Ungrouped schemas params '[tab ::: '["col" ::: null 'PGbool]] ('Null 'PGbool)
147+ winFun = boolAnd #col
148+ in printSQL winFun
149+ :}
150+ bool_and("col")
151+ -}
152+ boolAnd
153+ :: expr1 (null 'PGbool)
154+ -- ^ what to aggregate
155+ -> aggr ('Null 'PGbool)
156+
157+ {- |
158+ true if at least one input value is true, otherwise false
159+
160+ >>> :{
161+ let
162+ expression :: Expression '[] commons ('Grouped bys) schemas params '[tab ::: '["col" ::: null 'PGbool]] ('Null 'PGbool)
163+ expression = boolOr (All #col)
164+ in printSQL expression
165+ :}
166+ bool_or(ALL "col")
167+ -}
168+ boolOr
169+ :: expr1 (null 'PGbool)
170+ -- ^ what to aggregate
171+ -> aggr ('Null 'PGbool)
172+
173+ {- |
174+ equivalent to `boolAnd`
175+
176+ >>> :{
177+ let
178+ expression :: Expression '[] commons ('Grouped bys) schemas params '[tab ::: '["col" ::: null 'PGbool]] ('Null 'PGbool)
179+ expression = every (Distinct #col)
180+ in printSQL expression
181+ :}
182+ every(DISTINCT "col")
183+ -}
184+ every
185+ :: expr1 (null 'PGbool)
186+ -- ^ what to aggregate
187+ -> aggr ('Null 'PGbool)
188+
189+ {- |maximum value of expression across all input values-}
190+ max_
191+ :: expr1 (null ty)
192+ -- ^ what to maximize
193+ -> aggr ('Null ty)
194+
195+ -- | minimum value of expression across all input values
196+ min_
197+ :: expr1 (null ty)
198+ -- ^ what to minimize
199+ -> aggr ('Null ty)
200+
201+ -- | the average (arithmetic mean) of all input values
202+ avg
203+ :: expr1 (null ty)
204+ -- ^ what to average
205+ -> aggr ('Null (PGAvg ty))
206+
207+ {- | correlation coefficient
208+
209+ >>> :{
210+ let
211+ expression :: Expression '[] c ('Grouped g) s p '[t ::: '["x" ::: 'NotNull 'PGfloat8, "y" ::: 'NotNull 'PGfloat8]] ('Null 'PGfloat8)
212+ expression = corr (All (#y *: #x))
213+ in printSQL expression
214+ :}
215+ corr(ALL "y", "x")
216+ -}
217+ corr
218+ :: exprN '[null 'PGfloat8, null 'PGfloat8]
219+ -> aggr ('Null 'PGfloat8)
220+
221+ {- | population covariance
222+
223+ >>> :{
224+ let
225+ expression :: Expression '[] c ('Grouped g) s p '[t ::: '["x" ::: 'NotNull 'PGfloat8, "y" ::: 'NotNull 'PGfloat8]] ('Null 'PGfloat8)
226+ expression = covarPop (All (#y *: #x))
227+ in printSQL expression
228+ :}
229+ covar_pop(ALL "y", "x")
230+ -}
231+ covarPop
232+ :: exprN '[null 'PGfloat8, null 'PGfloat8]
233+ -> aggr ('Null 'PGfloat8)
234+
235+ {- | sample covariance
236+
237+ >>> :{
238+ let
239+ winFun :: WindowFunction '[] c 'Ungrouped s p '[t ::: '["x" ::: 'NotNull 'PGfloat8, "y" ::: 'NotNull 'PGfloat8]] ('Null 'PGfloat8)
240+ winFun = covarSamp (#y *: #x)
241+ in printSQL winFun
242+ :}
243+ covar_samp("y", "x")
244+ -}
245+ covarSamp
246+ :: exprN '[null 'PGfloat8, null 'PGfloat8]
247+ -> aggr ('Null 'PGfloat8)
248+
249+ {- | average of the independent variable (sum(X)/N)
250+
251+ >>> :{
252+ let
253+ expression :: Expression '[] c ('Grouped g) s p '[t ::: '["x" ::: 'NotNull 'PGfloat8, "y" ::: 'NotNull 'PGfloat8]] ('Null 'PGfloat8)
254+ expression = regrAvgX (All (#y *: #x))
255+ in printSQL expression
256+ :}
257+ regr_avgx(ALL "y", "x")
258+ -}
259+ regrAvgX
260+ :: exprN '[null 'PGfloat8, null 'PGfloat8]
261+ -> aggr ('Null 'PGfloat8)
262+
263+ {- | average of the dependent variable (sum(Y)/N)
264+
265+ >>> :{
266+ let
267+ winFun :: WindowFunction '[] c 'Ungrouped s p '[t ::: '["x" ::: 'NotNull 'PGfloat8, "y" ::: 'NotNull 'PGfloat8]] ('Null 'PGfloat8)
268+ winFun = regrAvgY (#y *: #x)
269+ in printSQL winFun
270+ :}
271+ regr_avgy("y", "x")
272+ -}
273+ regrAvgY
274+ :: exprN '[null 'PGfloat8, null 'PGfloat8]
275+ -> aggr ('Null 'PGfloat8)
276+
277+ {- | number of input rows in which both expressions are nonnull
278+
279+ >>> :{
280+ let
281+ winFun :: WindowFunction '[] c 'Ungrouped s p '[t ::: '["x" ::: 'NotNull 'PGfloat8, "y" ::: 'NotNull 'PGfloat8]] ('Null 'PGint8)
282+ winFun = regrCount (#y *: #x)
283+ in printSQL winFun
284+ :}
285+ regr_count("y", "x")
286+ -}
287+ regrCount
288+ :: exprN '[null 'PGfloat8, null 'PGfloat8]
289+ -> aggr ('Null 'PGint8)
290+
291+ {- | y-intercept of the least-squares-fit linear equation determined by the (X, Y) pairs
292+ >>> :{
293+ let
294+ expression :: Expression '[] c ('Grouped g) s p '[t ::: '["x" ::: 'NotNull 'PGfloat8, "y" ::: 'NotNull 'PGfloat8]] ('Null 'PGfloat8)
295+ expression = regrIntercept (All (#y *: #x))
296+ in printSQL expression
297+ :}
298+ regr_intercept(ALL "y", "x")
299+ -}
300+ regrIntercept
301+ :: exprN '[null 'PGfloat8, null 'PGfloat8]
302+ -> aggr ('Null 'PGfloat8)
303+
304+ -- | @regr_r2(Y, X)@, square of the correlation coefficient
305+ regrR2
306+ :: exprN '[null 'PGfloat8, null 'PGfloat8]
307+ -> aggr ('Null 'PGfloat8)
308+
309+ -- | @regr_slope(Y, X)@, slope of the least-squares-fit linear equation
310+ -- determined by the (X, Y) pairs
311+ regrSlope
312+ :: exprN '[null 'PGfloat8, null 'PGfloat8]
313+ -> aggr ('Null 'PGfloat8)
314+
315+ -- | @regr_sxx(Y, X)@, sum(X^2) - sum(X)^2/N
316+ -- (“sum of squares” of the independent variable)
317+ regrSxx
318+ :: exprN '[null 'PGfloat8, null 'PGfloat8]
319+ -> aggr ('Null 'PGfloat8)
320+
321+ -- | @regr_sxy(Y, X)@, sum(X*Y) - sum(X) * sum(Y)/N
322+ -- (“sum of products” of independent times dependent variable)
323+ regrSxy
324+ :: exprN '[null 'PGfloat8, null 'PGfloat8]
325+ -> aggr ('Null 'PGfloat8)
326+
327+ -- | @regr_syy(Y, X)@, sum(Y^2) - sum(Y)^2/N
328+ -- (“sum of squares” of the dependent variable)
329+ regrSyy
330+ :: exprN '[null 'PGfloat8, null 'PGfloat8]
331+ -> aggr ('Null 'PGfloat8)
332+
333+ -- | historical alias for `stddevSamp`
334+ stddev
335+ :: expr1 (null ty)
336+ -> aggr ('Null (PGAvg ty))
337+
338+ -- | population standard deviation of the input values
339+ stddevPop
340+ :: expr1 (null ty)
341+ -> aggr ('Null (PGAvg ty))
342+
343+ -- | sample standard deviation of the input values
344+ stddevSamp
345+ :: expr1 (null ty)
346+ -> aggr ('Null (PGAvg ty))
347+
348+ -- | historical alias for `varSamp`
349+ variance
350+ :: expr1 (null ty)
351+ -> aggr ('Null (PGAvg ty))
352+
353+ -- | population variance of the input values
354+ -- (square of the population standard deviation)
355+ varPop
356+ :: expr1 (null ty)
357+ -> aggr ('Null (PGAvg ty))
358+
359+ -- | sample variance of the input values
360+ -- (square of the sample standard deviation)
361+ varSamp
362+ :: expr1 (null ty)
363+ -> aggr ('Null (PGAvg ty))
364+
365+{- |
366+`Distinction`s are used for the input of `Aggregate` `Expression`s.
367+`All` invokes the aggregate once for each input row.
368+`Distinct` invokes the aggregate once for each distinct value of the expression
369+(or distinct set of values, for multiple expressions) found in the input
370+-}
371+data Distinction (expr :: kind -> Type) (ty :: kind)
372+ = All (expr ty)
373+ | Distinct (expr ty)
374+ deriving (GHC.Generic,Show,Eq,Ord)
375+instance NFData (Distinction (Expression outer commons grp schemas params from) ty)
376+instance RenderSQL (Distinction (Expression outer commons grp schemas params from) ty) where
377+ renderSQL = \case
378+ All x -> "ALL" <+> renderSQL x
379+ Distinct x -> "DISTINCT" <+> renderSQL x
380+instance SOP.SListI tys => RenderSQL
381+ (Distinction (NP (Expression outer commons grp schemas params from)) tys) where
382+ renderSQL = \case
383+ All xs -> "ALL" <+> renderCommaSeparated renderSQL xs
384+ Distinct xs -> "DISTINCT" <+> renderCommaSeparated renderSQL xs
385+
386+instance Aggregate
387+ (Distinction (Expression outer commons 'Ungrouped schemas params from))
388+ (Distinction (NP (Expression outer commons 'Ungrouped schemas params from)))
389+ (Expression outer commons ('Grouped bys) schemas params from) where
390+ countStar = UnsafeExpression "count(*)"
391+ count = unsafeAggregate1 "count"
392+ sum_ = unsafeAggregate1 "sum"
393+ arrayAgg = unsafeAggregate1 "array_agg"
394+ jsonAgg = unsafeAggregate1 "json_agg"
395+ jsonbAgg = unsafeAggregate1 "jsonb_agg"
396+ bitAnd = unsafeAggregate1 "bit_and"
397+ bitOr = unsafeAggregate1 "bit_or"
398+ boolAnd = unsafeAggregate1 "bool_and"
399+ boolOr = unsafeAggregate1 "bool_or"
400+ every = unsafeAggregate1 "every"
401+ max_ = unsafeAggregate1 "max"
402+ min_ = unsafeAggregate1 "min"
403+ avg = unsafeAggregate1 "avg"
404+ corr = unsafeAggregateN "corr"
405+ covarPop = unsafeAggregateN "covar_pop"
406+ covarSamp = unsafeAggregateN "covar_samp"
407+ regrAvgX = unsafeAggregateN "regr_avgx"
408+ regrAvgY = unsafeAggregateN "regr_avgy"
409+ regrCount = unsafeAggregateN "regr_count"
410+ regrIntercept = unsafeAggregateN "regr_intercept"
411+ regrR2 = unsafeAggregateN "regr_r2"
412+ regrSlope = unsafeAggregateN "regr_slope"
413+ regrSxx = unsafeAggregateN "regr_sxx"
414+ regrSxy = unsafeAggregateN "regr_sxy"
415+ regrSyy = unsafeAggregateN "regr_syy"
416+ stddev = unsafeAggregate1 "stddev"
417+ stddevPop = unsafeAggregate1 "stddev_pop"
418+ stddevSamp = unsafeAggregate1 "stddev_samp"
419+ variance = unsafeAggregate1 "variance"
420+ varPop = unsafeAggregate1 "var_pop"
421+ varSamp = unsafeAggregate1 "var_samp"
422+
423+-- | escape hatch to define aggregate functions
424+unsafeAggregate1
425+ :: ByteString -- ^ aggregate function
426+ -> Distinction (Expression outer commons 'Ungrouped schemas params from) x
427+ -> Expression outer commons ('Grouped bys) schemas params from y
428+unsafeAggregate1 fun x = UnsafeExpression $ fun <> parenthesized (renderSQL x)
429+
430+unsafeAggregateN
431+ :: SOP.SListI xs
432+ => ByteString -- ^ function
433+ -> Distinction (NP (Expression outer commons 'Ungrouped schemas params from)) xs
434+ -> Expression outer commons ('Grouped bys) schemas params from y
435+unsafeAggregateN fun xs = UnsafeExpression $ fun <> parenthesized (renderSQL xs)
436+
437+-- | A type family that calculates `PGSum``PGType` of
438+-- a given argument `PGType`.
439+type family PGSum ty where
440+ PGSum 'PGint2 = 'PGint8
441+ PGSum 'PGint4 = 'PGint8
442+ PGSum 'PGint8 = 'PGnumeric
443+ PGSum 'PGfloat4 = 'PGfloat4
444+ PGSum 'PGfloat8 = 'PGfloat8
445+ PGSum 'PGnumeric = 'PGnumeric
446+ PGSum 'PGinterval = 'PGinterval
447+ PGSum 'PGmoney = 'PGmoney
448+ PGSum pg = TypeError
449+ ( 'Text "Squeal type error: Cannot sum with argument type "
450+ ':<>: 'ShowType pg )
451+
452+-- | A type family that calculates `PGAvg` type of a `PGType`.
453+type family PGAvg ty where
454+ PGAvg 'PGint2 = 'PGnumeric
455+ PGAvg 'PGint4 = 'PGnumeric
456+ PGAvg 'PGint8 = 'PGnumeric
457+ PGAvg 'PGnumeric = 'PGnumeric
458+ PGAvg 'PGfloat4 = 'PGfloat8
459+ PGAvg 'PGfloat8 = 'PGfloat8
460+ PGAvg 'PGinterval = 'PGinterval
461+ PGAvg pg = TypeError
462+ ('Text "Squeal type error: No average for " ':<>: 'ShowType pg)
squeal-postgresql/src/Squeal/PostgreSQL/Expression/Collection.hsnew file+169
@@ -0,0 +1,169 @@
1+{-|
2+Module: Squeal.PostgreSQL.Expression.Collection
3+Description: Array and composite functions
4+Copyright: (c) Eitan Chatav, 2019
5+Maintainer: eitan@morphism.tech
6+Stability: experimental
7+
8+Array and composite functions
9+-}
10+
11+{-# LANGUAGE
12+ AllowAmbiguousTypes
13+ , DataKinds
14+ , FlexibleContexts
15+ , FlexibleInstances
16+ , MultiParamTypeClasses
17+ , OverloadedLabels
18+ , OverloadedStrings
19+ , RankNTypes
20+ , ScopedTypeVariables
21+ , TypeApplications
22+ , TypeFamilies
23+ , TypeOperators
24+ , UndecidableInstances
25+#-}
26+
27+module Squeal.PostgreSQL.Expression.Collection
28+ ( array
29+ , array1
30+ , array2
31+ , cardinality
32+ , index
33+ , unnest
34+ , row
35+ , field
36+ ) where
37+
38+import Data.String
39+import Data.Word (Word64)
40+
41+import qualified Generics.SOP as SOP
42+
43+import Squeal.PostgreSQL.Alias
44+import Squeal.PostgreSQL.Expression
45+import Squeal.PostgreSQL.Expression.Set
46+import Squeal.PostgreSQL.List
47+import Squeal.PostgreSQL.Render
48+import Squeal.PostgreSQL.Schema
49+
50+-- $setup
51+-- >>> import Squeal.PostgreSQL
52+
53+-- | >>> printSQL $ array [null_, false, true]
54+-- ARRAY[NULL, FALSE, TRUE]
55+array
56+ :: [Expression outer commons grp schemas params from ty]
57+ -- ^ array elements
58+ -> Expression outer commons grp schemas params from (null ('PGvararray ty))
59+array xs = UnsafeExpression $ "ARRAY" <>
60+ bracketed (commaSeparated (renderSQL <$> xs))
61+
62+{- | construct a 1-dimensional fixed length array
63+
64+>>> printSQL $ array1 (null_ :* false *: true)
65+ARRAY[NULL, FALSE, TRUE]
66+
67+>>> :type array1 (null_ :* false *: true)
68+array1 (null_ :* false *: true)
69+ :: Expression
70+ outer
71+ commons
72+ grp
73+ schemas
74+ params
75+ from
76+ (null ('PGfixarray '[3] ('Null 'PGbool)))
77+-}
78+array1
79+ :: (n ~ Length tys, SOP.All ((~) ty) tys)
80+ => NP (Expression outer commons grp schemas params from) tys
81+ -> Expression outer commons grp schemas params from (null ('PGfixarray '[n] ty))
82+array1 xs = UnsafeExpression $ "ARRAY" <>
83+ bracketed (renderCommaSeparated renderSQL xs)
84+
85+{- | construct a 2-dimensional fixed length array
86+
87+>>> printSQL $ array2 ((null_ :* false *: true) *: (false :* null_ *: true))
88+ARRAY[[NULL, FALSE, TRUE], [FALSE, NULL, TRUE]]
89+
90+>>> :type array2 ((null_ :* false *: true) *: (false :* null_ *: true))
91+array2 ((null_ :* false *: true) *: (false :* null_ *: true))
92+ :: Expression
93+ outer
94+ commons
95+ grp
96+ schemas
97+ params
98+ from
99+ (null ('PGfixarray '[2, 3] ('Null 'PGbool)))
100+-}
101+array2
102+ :: ( SOP.All ((~) tys) tyss
103+ , SOP.All SOP.SListI tyss
104+ , Length tyss ~ n1
105+ , SOP.All ((~) ty) tys
106+ , Length tys ~ n2 )
107+ => NP (NP (Expression outer commons grp schemas params from)) tyss
108+ -> Expression outer commons grp schemas params from (null ('PGfixarray '[n1,n2] ty))
109+array2 xss = UnsafeExpression $ "ARRAY" <>
110+ bracketed (renderCommaSeparatedConstraint @SOP.SListI (bracketed . renderCommaSeparated renderSQL) xss)
111+
112+-- | >>> printSQL $ cardinality (array [null_, false, true])
113+-- cardinality(ARRAY[NULL, FALSE, TRUE])
114+cardinality :: null ('PGvararray ty) --> null 'PGint8
115+cardinality = unsafeFunction "cardinality"
116+
117+-- | >>> printSQL $ array [null_, false, true] & index 2
118+-- (ARRAY[NULL, FALSE, TRUE])[2]
119+index
120+ :: Word64 -- ^ index
121+ -> null ('PGvararray ty) --> NullifyType ty
122+index n expr = UnsafeExpression $
123+ parenthesized (renderSQL expr) <> "[" <> fromString (show n) <> "]"
124+
125+-- | Expand an array to a set of rows
126+unnest :: SetFunction "unnest" (null ('PGvararray ty)) '["unnest" ::: ty]
127+unnest = unsafeSetFunction
128+
129+-- | A row constructor is an expression that builds a row value
130+-- (also called a composite value) using values for its member fields.
131+--
132+-- >>> :{
133+-- type Complex = 'PGcomposite
134+-- '[ "real" ::: 'NotNull 'PGfloat8
135+-- , "imaginary" ::: 'NotNull 'PGfloat8 ]
136+-- :}
137+--
138+-- >>> let i = row (0 `as` #real :* 1 `as` #imaginary) :: Expression outer commons grp schemas params from ('NotNull Complex)
139+-- >>> printSQL i
140+-- ROW(0, 1)
141+row
142+ :: SOP.SListI row
143+ => NP (Aliased (Expression outer commons grp schemas params from)) row
144+ -- ^ zero or more expressions for the row field values
145+ -> Expression outer commons grp schemas params from (null ('PGcomposite row))
146+row exprs = UnsafeExpression $ "ROW" <> parenthesized
147+ (renderCommaSeparated (\ (expr `As` _) -> renderSQL expr) exprs)
148+
149+-- | >>> :{
150+-- type Complex = 'PGcomposite
151+-- '[ "real" ::: 'NotNull 'PGfloat8
152+-- , "imaginary" ::: 'NotNull 'PGfloat8 ]
153+-- type Schema = '["complex" ::: 'Typedef Complex]
154+-- :}
155+--
156+-- >>> let i = row (0 `as` #real :* 1 `as` #imaginary) :: Expression outer '[] grp (Public Schema) from params ('NotNull Complex)
157+-- >>> printSQL $ i & field #complex #imaginary
158+-- (ROW(0, 1)::"complex")."imaginary"
159+field
160+ :: ( Has sch schemas schema
161+ , Has tydef schema ('Typedef ('PGcomposite row))
162+ , Has field row ty)
163+ => QualifiedAlias sch tydef -- ^ row type
164+ -> Alias field -- ^ field name
165+ -> Expression outer commons grp schemas params from ('NotNull ('PGcomposite row))
166+ -> Expression outer commons grp schemas params from ty
167+field td fld expr = UnsafeExpression $
168+ parenthesized (renderSQL expr <> "::" <> renderSQL td)
169+ <> "." <> renderSQL fld
squeal-postgresql/src/Squeal/PostgreSQL/Expression/Comparison.hsnew file+206
@@ -0,0 +1,206 @@
1+{-|
2+Module: Squeal.PostgreSQL.Expression.Comparison
3+Description: Comparison expressions
4+Copyright: (c) Eitan Chatav, 2019
5+Maintainer: eitan@morphism.tech
6+Stability: experimental
7+
8+Comparison functions and operators
9+-}
10+
11+{-# LANGUAGE
12+ OverloadedStrings
13+ , RankNTypes
14+ , TypeInType
15+ , TypeOperators
16+#-}
17+
18+module Squeal.PostgreSQL.Expression.Comparison
19+ ( (.==)
20+ , (./=)
21+ , (.>=)
22+ , (.<)
23+ , (.<=)
24+ , (.>)
25+ , greatest
26+ , least
27+ , BetweenExpr
28+ , between
29+ , notBetween
30+ , betweenSymmetric
31+ , notBetweenSymmetric
32+ , isDistinctFrom
33+ , isNotDistinctFrom
34+ , isTrue
35+ , isNotTrue
36+ , isFalse
37+ , isNotFalse
38+ , isUnknown
39+ , isNotUnknown
40+ ) where
41+
42+import Data.ByteString
43+
44+import Squeal.PostgreSQL.Expression
45+import Squeal.PostgreSQL.Expression.Logic
46+import Squeal.PostgreSQL.Render
47+import Squeal.PostgreSQL.Schema
48+
49+-- $setup
50+-- >>> import Squeal.PostgreSQL
51+
52+-- | Comparison operations like `.==`, `./=`, `.>`, `.>=`, `.<` and `.<=`
53+-- will produce @NULL@s if one of their arguments is @NULL@.
54+--
55+-- >>> printSQL $ true .== null_
56+-- (TRUE = NULL)
57+(.==) :: Operator (null0 ty) (null1 ty) ('Null 'PGbool)
58+(.==) = unsafeBinaryOp "="
59+infix 4 .==
60+
61+-- | >>> printSQL $ true ./= null_
62+-- (TRUE <> NULL)
63+(./=) :: Operator (null0 ty) (null1 ty) ('Null 'PGbool)
64+(./=) = unsafeBinaryOp "<>"
65+infix 4 ./=
66+
67+-- | >>> printSQL $ true .>= null_
68+-- (TRUE >= NULL)
69+(.>=) :: Operator (null0 ty) (null1 ty) ('Null 'PGbool)
70+(.>=) = unsafeBinaryOp ">="
71+infix 4 .>=
72+
73+-- | >>> printSQL $ true .< null_
74+-- (TRUE < NULL)
75+(.<) :: Operator (null0 ty) (null1 ty) ('Null 'PGbool)
76+(.<) = unsafeBinaryOp "<"
77+infix 4 .<
78+
79+-- | >>> printSQL $ true .<= null_
80+-- (TRUE <= NULL)
81+(.<=) :: Operator (null0 ty) (null1 ty) ('Null 'PGbool)
82+(.<=) = unsafeBinaryOp "<="
83+infix 4 .<=
84+
85+-- | >>> printSQL $ true .> null_
86+-- (TRUE > NULL)
87+(.>) :: Operator (null0 ty) (null1 ty) ('Null 'PGbool)
88+(.>) = unsafeBinaryOp ">"
89+infix 4 .>
90+
91+-- | >>> let expr = greatest [param @1] currentTimestamp :: Expression outer commons grp schemas '[ 'NotNull 'PGtimestamptz] from ('NotNull 'PGtimestamptz)
92+-- >>> printSQL expr
93+-- GREATEST(($1 :: timestamp with time zone), CURRENT_TIMESTAMP)
94+greatest :: FunctionVar ty ty ty
95+greatest = unsafeFunctionVar "GREATEST"
96+
97+-- | >>> printSQL $ least [null_] currentTimestamp
98+-- LEAST(NULL, CURRENT_TIMESTAMP)
99+least :: FunctionVar ty ty ty
100+least = unsafeFunctionVar "LEAST"
101+
102+{- |
103+A @RankNType@ for comparison expressions like `between`.
104+-}
105+type BetweenExpr
106+ = forall outer commons grp schemas params from ty
107+ . Expression outer commons grp schemas params from ty
108+ -> ( Expression outer commons grp schemas params from ty
109+ , Expression outer commons grp schemas params from ty ) -- ^ bounds
110+ -> Condition outer commons grp schemas params from
111+
112+unsafeBetweenExpr :: ByteString -> BetweenExpr
113+unsafeBetweenExpr fun a (x,y) = UnsafeExpression $
114+ renderSQL a <+> fun <+> renderSQL x <+> "AND" <+> renderSQL y
115+
116+{- | >>> printSQL $ true `between` (null_, false)
117+TRUE BETWEEN NULL AND FALSE
118+-}
119+between :: BetweenExpr
120+between = unsafeBetweenExpr "BETWEEN"
121+
122+{- | >>> printSQL $ true `notBetween` (null_, false)
123+TRUE NOT BETWEEN NULL AND FALSE
124+-}
125+notBetween :: BetweenExpr
126+notBetween = unsafeBetweenExpr "NOT BETWEEN"
127+
128+{- | between, after sorting the comparison values
129+
130+>>> printSQL $ true `betweenSymmetric` (null_, false)
131+TRUE BETWEEN SYMMETRIC NULL AND FALSE
132+-}
133+betweenSymmetric :: BetweenExpr
134+betweenSymmetric = unsafeBetweenExpr "BETWEEN SYMMETRIC"
135+
136+{- | not between, after sorting the comparison values
137+
138+>>> printSQL $ true `notBetweenSymmetric` (null_, false)
139+TRUE NOT BETWEEN SYMMETRIC NULL AND FALSE
140+-}
141+notBetweenSymmetric :: BetweenExpr
142+notBetweenSymmetric = unsafeBetweenExpr "NOT BETWEEN SYMMETRIC"
143+
144+{- | not equal, treating null like an ordinary value
145+
146+>>> printSQL $ true `isDistinctFrom` null_
147+(TRUE IS DISTINCT FROM NULL)
148+-}
149+isDistinctFrom :: Operator (null0 ty) (null1 ty) ('Null 'PGbool)
150+isDistinctFrom = unsafeBinaryOp "IS DISTINCT FROM"
151+
152+{- | equal, treating null like an ordinary value
153+
154+>>> printSQL $ true `isNotDistinctFrom` null_
155+(TRUE IS NOT DISTINCT FROM NULL)
156+-}
157+isNotDistinctFrom :: Operator (null0 ty) (null1 ty) ('NotNull 'PGbool)
158+isNotDistinctFrom = unsafeBinaryOp "IS NOT DISTINCT FROM"
159+
160+{- | is true
161+
162+>>> printSQL $ true & isTrue
163+(TRUE IS TRUE)
164+-}
165+isTrue :: null0 'PGbool --> null1 'PGbool
166+isTrue = unsafeRightOp "IS TRUE"
167+
168+{- | is false or unknown
169+
170+>>> printSQL $ true & isNotTrue
171+(TRUE IS NOT TRUE)
172+-}
173+isNotTrue :: null0 'PGbool --> null1 'PGbool
174+isNotTrue = unsafeRightOp "IS NOT TRUE"
175+
176+{- | is false
177+
178+>>> printSQL $ true & isFalse
179+(TRUE IS FALSE)
180+-}
181+isFalse :: null0 'PGbool --> null1 'PGbool
182+isFalse = unsafeRightOp "IS FALSE"
183+
184+{- | is true or unknown
185+
186+>>> printSQL $ true & isNotFalse
187+(TRUE IS NOT FALSE)
188+-}
189+isNotFalse :: null0 'PGbool --> null1 'PGbool
190+isNotFalse = unsafeRightOp "IS NOT FALSE"
191+
192+{- | is unknown
193+
194+>>> printSQL $ true & isUnknown
195+(TRUE IS UNKNOWN)
196+-}
197+isUnknown :: null0 'PGbool --> null1 'PGbool
198+isUnknown = unsafeRightOp "IS UNKNOWN"
199+
200+{- | is true or false
201+
202+>>> printSQL $ true & isNotUnknown
203+(TRUE IS NOT UNKNOWN)
204+-}
205+isNotUnknown :: null0 'PGbool --> null1 'PGbool
206+isNotUnknown = unsafeRightOp "IS NOT UNKNOWN"
squeal-postgresql/src/Squeal/PostgreSQL/Expression/Json.hsnew file+462
@@ -0,0 +1,462 @@
1+{-|
2+Module: Squeal.PostgreSQL.Expression.Json
3+Description: Json and Jsonb functions and operators
4+Copyright: (c) Eitan Chatav, 2019
5+Maintainer: eitan@morphism.tech
6+Stability: experimental
7+
8+Json and Jsonb functions and operators
9+-}
10+
11+{-# LANGUAGE
12+ DataKinds
13+ , FlexibleContexts
14+ , FlexibleInstances
15+ , GADTs
16+ , OverloadedLabels
17+ , OverloadedStrings
18+ , PolyKinds
19+ , RankNTypes
20+ , ScopedTypeVariables
21+ , TypeApplications
22+ , TypeOperators
23+ , UndecidableInstances
24+ , UndecidableSuperClasses
25+#-}
26+
27+module Squeal.PostgreSQL.Expression.Json
28+ ( -- * Json and Jsonb operators
29+ (.->)
30+ , (.->>)
31+ , (.#>)
32+ , (.#>>)
33+ -- * Jsonb operators
34+ , (.?)
35+ , (.?|)
36+ , (.?&)
37+ , (.-.)
38+ , (#-.)
39+ -- * Json and Jsonb functions
40+ , toJson
41+ , toJsonb
42+ , arrayToJson
43+ , rowToJson
44+ , jsonBuildArray
45+ , jsonbBuildArray
46+ , JsonBuildObject (..)
47+ , jsonObject
48+ , jsonbObject
49+ , jsonZipObject
50+ , jsonbZipObject
51+ , jsonArrayLength
52+ , jsonbArrayLength
53+ , jsonTypeof
54+ , jsonbTypeof
55+ , jsonStripNulls
56+ , jsonbStripNulls
57+ , jsonbSet
58+ , jsonbInsert
59+ , jsonbPretty
60+ -- * Json and Jsonb set returning functions
61+ , jsonEach
62+ , jsonbEach
63+ , jsonEachText
64+ , jsonbEachText
65+ , jsonObjectKeys
66+ , jsonbObjectKeys
67+ , JsonPopulateFunction
68+ , jsonPopulateRecord
69+ , jsonbPopulateRecord
70+ , jsonPopulateRecordSet
71+ , jsonbPopulateRecordSet
72+ , JsonToRecordFunction
73+ , jsonToRecord
74+ , jsonbToRecord
75+ , jsonToRecordSet
76+ , jsonbToRecordSet
77+ ) where
78+
79+import Data.ByteString (ByteString)
80+import GHC.TypeLits
81+
82+import Squeal.PostgreSQL.Alias
83+import Squeal.PostgreSQL.Expression
84+import Squeal.PostgreSQL.Expression.Set
85+import Squeal.PostgreSQL.Expression.Type
86+import Squeal.PostgreSQL.List
87+import Squeal.PostgreSQL.Query
88+import Squeal.PostgreSQL.Render
89+import Squeal.PostgreSQL.Schema
90+
91+import qualified Generics.SOP as SOP
92+
93+-- $setup
94+-- >>> import Squeal.PostgreSQL
95+-- >>> import Data.Aeson
96+
97+{-----------------------------------------
98+ -- json and jsonb support
99+
100+See https://www.postgresql.org/docs/10/static/functions-json.html -- most
101+comments lifted directly from this page.
102+
103+Table 9.44: json and jsonb operators
104+-----------------------------------------}
105+
106+-- | Get JSON value (object field or array element) at a key.
107+(.->)
108+ :: (json `In` PGJsonType, key `In` PGJsonKey)
109+ => Operator (null json) (null key) ('Null json)
110+infixl 8 .->
111+(.->) = unsafeBinaryOp "->"
112+
113+-- | Get JSON value (object field or array element) at a key, as text.
114+(.->>)
115+ :: (json `In` PGJsonType, key `In` PGJsonKey)
116+ => Operator (null json) (null key) ('Null 'PGtext)
117+infixl 8 .->>
118+(.->>) = unsafeBinaryOp "->>"
119+
120+-- | Get JSON value at a specified path.
121+(.#>)
122+ :: json `In` PGJsonType
123+ => Operator (null json) (null ('PGvararray ('NotNull 'PGtext))) ('Null json)
124+infixl 8 .#>
125+(.#>) = unsafeBinaryOp "#>"
126+
127+-- | Get JSON value at a specified path as text.
128+(.#>>)
129+ :: json `In` PGJsonType
130+ => Operator (null json) (null ('PGvararray ('NotNull 'PGtext))) ('Null 'PGtext)
131+infixl 8 .#>>
132+(.#>>) = unsafeBinaryOp "#>>"
133+
134+-- Additional jsonb operators
135+
136+-- | Does the string exist as a top-level key within the JSON value?
137+(.?) :: Operator (null 'PGjsonb) (null 'PGtext) ('Null 'PGbool)
138+infixl 9 .?
139+(.?) = unsafeBinaryOp "?"
140+
141+-- | Do any of these array strings exist as top-level keys?
142+(.?|) :: Operator
143+ (null 'PGjsonb)
144+ (null ('PGvararray ('NotNull 'PGtext)))
145+ ('Null 'PGbool)
146+infixl 9 .?|
147+(.?|) = unsafeBinaryOp "?|"
148+
149+-- | Do all of these array strings exist as top-level keys?
150+(.?&) :: Operator
151+ (null 'PGjsonb)
152+ (null ('PGvararray ('NotNull 'PGtext)))
153+ ('Null 'PGbool)
154+infixl 9 .?&
155+(.?&) = unsafeBinaryOp "?&"
156+
157+-- | Delete a key or keys from a JSON object, or remove an array element.
158+--
159+-- If the right operand is
160+--
161+-- @ text @: Delete key / value pair or string element from left operand.
162+-- Key / value pairs are matched based on their key value,
163+--
164+-- @ text[] @: Delete multiple key / value pairs or string elements
165+-- from left operand. Key / value pairs are matched based on their key value,
166+--
167+-- @ integer @: Delete the array element with specified index (Negative integers
168+-- count from the end). Throws an error if top level container is not an array.
169+(.-.)
170+ :: key `In` '[ 'PGtext, 'PGvararray ('NotNull 'PGtext), 'PGint4, 'PGint2 ]
171+ => Operator (null 'PGjsonb) (null key) (null 'PGjsonb)
172+infixl 6 .-.
173+(.-.) = unsafeBinaryOp "-"
174+
175+-- | Delete the field or element with specified path (for JSON arrays, negative
176+-- integers count from the end)
177+(#-.) :: Operator (null 'PGjsonb) (null ('PGvararray ('NotNull 'PGtext))) (null 'PGjsonb)
178+infixl 6 #-.
179+(#-.) = unsafeBinaryOp "#-"
180+
181+{-----------------------------------------
182+Table 9.45: JSON creation functions
183+-----------------------------------------}
184+
185+-- | Returns the value as json. Arrays and composites are converted
186+-- (recursively) to arrays and objects; otherwise, if there is a cast from the
187+-- type to json, the cast function will be used to perform the conversion;
188+-- otherwise, a scalar value is produced. For any scalar type other than a
189+-- number, a Boolean, or a null value, the text representation will be used, in
190+-- such a fashion that it is a valid json value.
191+toJson :: null ty --> null 'PGjson
192+toJson = unsafeFunction "to_json"
193+
194+-- | Returns the value as jsonb. Arrays and composites are converted
195+-- (recursively) to arrays and objects; otherwise, if there is a cast from the
196+-- type to json, the cast function will be used to perform the conversion;
197+-- otherwise, a scalar value is produced. For any scalar type other than a
198+-- number, a Boolean, or a null value, the text representation will be used, in
199+-- such a fashion that it is a valid jsonb value.
200+toJsonb :: null ty --> null 'PGjsonb
201+toJsonb = unsafeFunction "to_jsonb"
202+
203+-- | Returns the array as a JSON array. A PostgreSQL multidimensional array
204+-- becomes a JSON array of arrays.
205+arrayToJson :: null ('PGvararray ty) --> null 'PGjson
206+arrayToJson = unsafeFunction "array_to_json"
207+
208+-- | Returns the row as a JSON object.
209+rowToJson :: null ('PGcomposite ty) --> null 'PGjson
210+rowToJson = unsafeFunction "row_to_json"
211+
212+-- | Builds a possibly-heterogeneously-typed JSON array out of a variadic
213+-- argument list.
214+jsonBuildArray :: SOP.SListI tuple => tuple ---> null 'PGjson
215+jsonBuildArray = unsafeFunctionN "json_build_array"
216+
217+-- | Builds a possibly-heterogeneously-typed (binary) JSON array out of a
218+-- variadic argument list.
219+jsonbBuildArray :: SOP.SListI tuple => tuple ---> null 'PGjsonb
220+jsonbBuildArray = unsafeFunctionN "jsonb_build_array"
221+
222+-- | Builds a possibly-heterogeneously-typed JSON object out of a variadic
223+-- argument list. The elements of the argument list must alternate between text
224+-- and values.
225+class SOP.SListI tys => JsonBuildObject tys where
226+
227+ jsonBuildObject :: tys ---> null 'PGjson
228+ jsonBuildObject = unsafeFunctionN "json_build_object"
229+
230+ jsonbBuildObject :: tys ---> null 'PGjsonb
231+ jsonbBuildObject = unsafeFunctionN "jsonb_build_object"
232+
233+instance JsonBuildObject '[]
234+instance (JsonBuildObject tys, key `In` PGJsonKey)
235+ => JsonBuildObject ('NotNull key ': value ': tys)
236+
237+-- | Builds a JSON object out of a text array.
238+-- The array must have two dimensions
239+-- such that each inner array has exactly two elements,
240+-- which are taken as a key/value pair.
241+jsonObject
242+ :: null ('PGfixarray '[n,2] ('NotNull 'PGtext))
243+ --> null 'PGjson
244+jsonObject = unsafeFunction "json_object"
245+
246+-- | Builds a binary JSON object out of a text array.
247+-- The array must have two dimensions
248+-- such that each inner array has exactly two elements,
249+-- which are taken as a key/value pair.
250+jsonbObject
251+ :: null ('PGfixarray '[n,2] ('NotNull 'PGtext))
252+ --> null 'PGjsonb
253+jsonbObject = unsafeFunction "jsonb_object"
254+
255+-- | This is an alternate form of 'jsonObject' that takes two arrays; one for
256+-- keys and one for values, that are zipped pairwise to create a JSON object.
257+jsonZipObject ::
258+ '[ null ('PGvararray ('NotNull 'PGtext))
259+ , null ('PGvararray ('NotNull 'PGtext)) ]
260+ ---> null 'PGjson
261+jsonZipObject = unsafeFunctionN "json_object"
262+
263+-- | This is an alternate form of 'jsonbObject' that takes two arrays; one for
264+-- keys and one for values, that are zipped pairwise to create a binary JSON
265+-- object.
266+jsonbZipObject ::
267+ '[ null ('PGvararray ('NotNull 'PGtext))
268+ , null ('PGvararray ('NotNull 'PGtext)) ]
269+ ---> null 'PGjsonb
270+jsonbZipObject = unsafeFunctionN "jsonb_object"
271+
272+{-----------------------------------------
273+Table 9.46: JSON processing functions
274+-----------------------------------------}
275+
276+-- | Returns the number of elements in the outermost JSON array.
277+jsonArrayLength :: null 'PGjson --> null 'PGint4
278+jsonArrayLength = unsafeFunction "json_array_length"
279+
280+-- | Returns the number of elements in the outermost binary JSON array.
281+jsonbArrayLength :: null 'PGjsonb --> null 'PGint4
282+jsonbArrayLength = unsafeFunction "jsonb_array_length"
283+
284+-- | Returns the type of the outermost JSON value as a text string. Possible
285+-- types are object, array, string, number, boolean, and null.
286+jsonTypeof :: null 'PGjson --> null 'PGtext
287+jsonTypeof = unsafeFunction "json_typeof"
288+
289+-- | Returns the type of the outermost binary JSON value as a text string.
290+-- Possible types are object, array, string, number, boolean, and null.
291+jsonbTypeof :: null 'PGjsonb --> null 'PGtext
292+jsonbTypeof = unsafeFunction "jsonb_typeof"
293+
294+-- | Returns its argument with all object fields that have null values omitted.
295+-- Other null values are untouched.
296+jsonStripNulls :: null 'PGjson --> null 'PGjson
297+jsonStripNulls = unsafeFunction "json_strip_nulls"
298+
299+-- | Returns its argument with all object fields that have null values omitted.
300+-- Other null values are untouched.
301+jsonbStripNulls :: null 'PGjsonb --> null 'PGjsonb
302+jsonbStripNulls = unsafeFunction "jsonb_strip_nulls"
303+
304+-- | @ jsonbSet target path new_value create_missing @
305+--
306+-- Returns target with the section designated by path replaced by @new_value@,
307+-- or with @new_value@ added if create_missing is
308+-- `Squeal.PostgreSQL.Expression.Logic.true` and the
309+-- item designated by path does not exist. As with the path orientated
310+-- operators, negative integers that appear in path count from the end of JSON
311+-- arrays.
312+jsonbSet ::
313+ '[ null 'PGjsonb, null ('PGvararray ('NotNull 'PGtext))
314+ , null 'PGjsonb, null 'PGbool ] ---> null 'PGjsonb
315+jsonbSet = unsafeFunctionN "jsonbSet"
316+
317+-- | @ jsonbInsert target path new_value insert_after @
318+--
319+-- Returns target with @new_value@ inserted. If target section designated by
320+-- path is in a JSONB array, @new_value@ will be inserted before target or after
321+-- if @insert_after@ is `Squeal.PostgreSQL.Expression.Logic.true`.
322+-- If target section designated by
323+-- path is in JSONB object, @new_value@ will be inserted only if target does not
324+-- exist. As with the path orientated operators, negative integers that appear
325+-- in path count from the end of JSON arrays.
326+jsonbInsert ::
327+ '[ null 'PGjsonb, null ('PGvararray ('NotNull 'PGtext))
328+ , null 'PGjsonb, null 'PGbool ] ---> null 'PGjsonb
329+jsonbInsert = unsafeFunctionN "jsonb_insert"
330+
331+-- | Returns its argument as indented JSON text.
332+jsonbPretty :: null 'PGjsonb --> null 'PGtext
333+jsonbPretty = unsafeFunction "jsonb_pretty"
334+
335+{- | Expands the outermost JSON object into a set of key/value pairs.
336+
337+>>> printSQL (select Star (from (jsonEach (literal (Json (object ["a" .= "foo", "b" .= "bar"]))))))
338+SELECT * FROM json_each(('{"a":"foo","b":"bar"}' :: json))
339+-}
340+jsonEach :: SetFunction "json_each" (null 'PGjson)
341+ '["key" ::: 'NotNull 'PGtext, "value" ::: 'NotNull 'PGjson]
342+jsonEach = unsafeSetFunction
343+
344+{- | Expands the outermost binary JSON object into a set of key/value pairs.
345+
346+>>> printSQL (select Star (from (jsonbEach (literal (Jsonb (object ["a" .= "foo", "b" .= "bar"]))))))
347+SELECT * FROM jsonb_each(('{"a":"foo","b":"bar"}' :: jsonb))
348+-}
349+jsonbEach
350+ :: SetFunction "jsonb_each" (nullity 'PGjsonb)
351+ '["key" ::: 'NotNull 'PGtext, "value" ::: 'NotNull 'PGjson]
352+jsonbEach = unsafeSetFunction
353+
354+{- | Expands the outermost JSON object into a set of key/value pairs.
355+
356+>>> printSQL (select Star (from (jsonEachText (literal (Json (object ["a" .= "foo", "b" .= "bar"]))))))
357+SELECT * FROM json_each_text(('{"a":"foo","b":"bar"}' :: json))
358+-}
359+jsonEachText
360+ :: SetFunction "json_each_text" (null 'PGjson)
361+ '["key" ::: 'NotNull 'PGtext, "value" ::: 'NotNull 'PGtext]
362+jsonEachText = unsafeSetFunction
363+
364+{- | Expands the outermost binary JSON object into a set of key/value pairs.
365+
366+>>> printSQL (select Star (from (jsonbEachText (literal (Jsonb (object ["a" .= "foo", "b" .= "bar"]))))))
367+SELECT * FROM jsonb_each_text(('{"a":"foo","b":"bar"}' :: jsonb))
368+-}
369+jsonbEachText
370+ :: SetFunction "jsonb_each_text" (null 'PGjsonb)
371+ '["key" ::: 'NotNull 'PGtext, "value" ::: 'NotNull 'PGtext]
372+jsonbEachText = unsafeSetFunction
373+
374+{- | Returns set of keys in the outermost JSON object.
375+
376+>>> printSQL (jsonObjectKeys (literal (Json (object ["a" .= "foo", "b" .= "bar"]))))
377+json_object_keys(('{"a":"foo","b":"bar"}' :: json))
378+-}
379+jsonObjectKeys
380+ :: SetFunction "json_object_keys" (nullity 'PGjson)
381+ '["json_object_keys" ::: 'NotNull 'PGtext]
382+jsonObjectKeys = unsafeSetFunction
383+
384+{- | Returns set of keys in the outermost JSON object.
385+
386+>>> printSQL (jsonbObjectKeys (literal (Jsonb (object ["a" .= "foo", "b" .= "bar"]))))
387+jsonb_object_keys(('{"a":"foo","b":"bar"}' :: jsonb))
388+-}
389+jsonbObjectKeys
390+ :: SetFunction "jsonb_object_keys" (null 'PGjsonb)
391+ '["jsonb_object_keys" ::: 'NotNull 'PGtext]
392+jsonbObjectKeys = unsafeSetFunction
393+
394+-- | Build rows from Json types.
395+type JsonPopulateFunction fun json
396+ = forall schemas row outer commons params
397+ . json `In` PGJsonType
398+ => TypeExpression schemas ('NotNull ('PGcomposite row)) -- ^ row type
399+ -> Expression outer commons 'Ungrouped schemas params '[] ('NotNull json)
400+ -- ^ json type
401+ -> FromClause outer commons schemas params '[fun ::: row]
402+
403+unsafePopulateFunction
404+ :: forall fun ty
405+ . KnownSymbol fun => Alias fun -> JsonPopulateFunction fun ty
406+unsafePopulateFunction _fun ty expr = UnsafeFromClause $ renderSymbol @fun
407+ <> parenthesized ("null::" <> renderSQL ty <> ", " <> renderSQL expr)
408+
409+-- | Expands the JSON expression to a row whose columns match the record
410+-- type defined by the given table.
411+jsonPopulateRecord :: JsonPopulateFunction "json_populate_record" 'PGjson
412+jsonPopulateRecord = unsafePopulateFunction #json_populate_record
413+
414+-- | Expands the binary JSON expression to a row whose columns match the record
415+-- type defined by the given table.
416+jsonbPopulateRecord :: JsonPopulateFunction "jsonb_populate_record" 'PGjsonb
417+jsonbPopulateRecord = unsafePopulateFunction #jsonb_populate_record
418+
419+-- | Expands the outermost array of objects in the given JSON expression to a
420+-- set of rows whose columns match the record type defined by the given table.
421+jsonPopulateRecordSet :: JsonPopulateFunction "json_populate_record_set" 'PGjson
422+jsonPopulateRecordSet = unsafePopulateFunction #json_populate_record_set
423+
424+-- | Expands the outermost array of objects in the given binary JSON expression
425+-- to a set of rows whose columns match the record type defined by the given
426+-- table.
427+jsonbPopulateRecordSet :: JsonPopulateFunction "jsonb_populate_record_set" 'PGjsonb
428+jsonbPopulateRecordSet = unsafePopulateFunction #jsonb_populate_record_set
429+
430+-- | Build rows from Json types.
431+type JsonToRecordFunction json
432+ = forall outer commons schemas params tab row
433+ . (SOP.SListI row, json `In` PGJsonType)
434+ => Expression outer commons 'Ungrouped schemas params '[] ('NotNull json)
435+ -- ^ json type
436+ -> Aliased (NP (Aliased (TypeExpression schemas))) (tab ::: row)
437+ -- ^ row type
438+ -> FromClause outer commons schemas params '[tab ::: row]
439+
440+unsafeRecordFunction :: ByteString -> JsonToRecordFunction json
441+unsafeRecordFunction fun expr (types `As` tab) = UnsafeFromClause $
442+ fun <> parenthesized (renderSQL expr) <+> "AS" <+> renderSQL tab
443+ <> parenthesized (renderCommaSeparated renderTy types)
444+ where
445+ renderTy :: Aliased (TypeExpression schemas) ty -> ByteString
446+ renderTy (ty `As` alias) = renderSQL alias <+> renderSQL ty
447+
448+-- | Builds an arbitrary record from a JSON object.
449+jsonToRecord :: JsonToRecordFunction 'PGjson
450+jsonToRecord = unsafeRecordFunction "json_to_record"
451+
452+-- | Builds an arbitrary record from a binary JSON object.
453+jsonbToRecord :: JsonToRecordFunction 'PGjsonb
454+jsonbToRecord = unsafeRecordFunction "jsonb_to_record"
455+
456+-- | Builds an arbitrary set of records from a JSON array of objects.
457+jsonToRecordSet :: JsonToRecordFunction 'PGjson
458+jsonToRecordSet = unsafeRecordFunction "json_to_record_set"
459+
460+-- | Builds an arbitrary set of records from a binary JSON array of objects.
461+jsonbToRecordSet :: JsonToRecordFunction 'PGjsonb
462+jsonbToRecordSet = unsafeRecordFunction "jsonb_to_record_set"
squeal-postgresql/src/Squeal/PostgreSQL/Expression/Literal.hsnew file+87
@@ -0,0 +1,87 @@
1+{-|
2+Module: Squeal.PostgreSQL.Expression.Literal
3+Description: Literal expressions
4+Copyright: (c) Eitan Chatav, 2019
5+Maintainer: eitan@morphism.tech
6+Stability: experimental
7+
8+Literal expressions
9+-}
10+
11+{-# LANGUAGE
12+ FlexibleContexts
13+ , FlexibleInstances
14+ , LambdaCase
15+ , OverloadedStrings
16+ , RankNTypes
17+ , ScopedTypeVariables
18+ , TypeApplications
19+ , TypeSynonymInstances
20+ , UndecidableInstances
21+#-}
22+
23+module Squeal.PostgreSQL.Expression.Literal (Literal (..)) where
24+
25+import ByteString.StrictBuilder (builderBytes)
26+import Data.ByteString.Lazy (toStrict)
27+import Data.Int
28+import Data.String
29+import Data.Text (Text)
30+
31+import qualified Data.Aeson as JSON
32+import qualified Data.Text as Text
33+import qualified Data.Text.Lazy as Lazy (Text)
34+import qualified Data.Text.Lazy as Lazy.Text
35+
36+import Squeal.PostgreSQL.Binary
37+import Squeal.PostgreSQL.Expression
38+import Squeal.PostgreSQL.Expression.Logic
39+import Squeal.PostgreSQL.PG
40+import Squeal.PostgreSQL.Render
41+
42+{- |
43+The `Literal` class allows embedding a Haskell value directly
44+as an `Expression` using `literal`.
45+
46+>>> printSQL (literal 'a')
47+E'a'
48+
49+>>> printSQL (literal (1 :: Double))
50+1.0
51+
52+>>> printSQL (literal (Json [1 :: Double, 2]))
53+('[1.0,2.0]' :: json)
54+
55+>>> printSQL (literal (Enumerated GT))
56+'GT'
57+-}
58+class Literal hask where literal :: hask -> Expr (null (PG hask))
59+instance Literal Bool where
60+ literal = \case
61+ True -> true
62+ False -> false
63+instance JSON.ToJSON hask => Literal (Json hask) where
64+ literal = UnsafeExpression . parenthesized . (<> " :: json")
65+ . singleQuotedUtf8 . toStrict . JSON.encode . getJson
66+instance JSON.ToJSON hask => Literal (Jsonb hask) where
67+ literal = UnsafeExpression . parenthesized . (<> " :: jsonb")
68+ . singleQuotedUtf8 . toStrict . JSON.encode . getJsonb
69+instance Literal Char where
70+ literal chr = UnsafeExpression $
71+ "E\'" <> fromString (escape chr) <> "\'"
72+instance Literal String where literal = fromString
73+instance Literal Int16 where literal = fromIntegral
74+instance Literal Int32 where literal = fromIntegral
75+instance Literal Int64 where literal = fromIntegral
76+instance Literal Float where literal = fromRational . toRational
77+instance Literal Double where literal = fromRational . toRational
78+instance Literal Text where literal = fromString . Text.unpack
79+instance Literal Lazy.Text where literal = fromString . Lazy.Text.unpack
80+instance ToParam (Enumerated enum) (PG (Enumerated enum))
81+ => Literal (Enumerated enum) where
82+ literal
83+ = UnsafeExpression
84+ . singleQuotedUtf8
85+ . builderBytes
86+ . unK
87+ . toParam @(Enumerated enum) @(PG (Enumerated enum))
squeal-postgresql/src/Squeal/PostgreSQL/Expression/Logic.hsnew file+105
@@ -0,0 +1,105 @@
1+{-|
2+Module: Squeal.PostgreSQL.Expression.Logic
3+Description: Logical expressions
4+Copyright: (c) Eitan Chatav, 2019
5+Maintainer: eitan@morphism.tech
6+Stability: experimental
7+
8+Logical expressions and operators
9+-}
10+
11+{-# LANGUAGE
12+ DataKinds
13+ , OverloadedStrings
14+ , TypeOperators
15+#-}
16+
17+module Squeal.PostgreSQL.Expression.Logic
18+ ( Condition
19+ , true
20+ , false
21+ , not_
22+ , (.&&)
23+ , (.||)
24+ , caseWhenThenElse
25+ , ifThenElse
26+ ) where
27+
28+import Squeal.PostgreSQL.Expression
29+import Squeal.PostgreSQL.Render
30+import Squeal.PostgreSQL.Schema
31+
32+-- | A `Condition` is an `Expression`, which can evaluate
33+-- to `true`, `false` or `Squeal.PostgreSQL.Null.null_`. This is because SQL uses
34+-- a three valued logic.
35+type Condition outer commons grp schemas params from =
36+ Expression outer commons grp schemas params from ('Null 'PGbool)
37+
38+-- | >>> printSQL true
39+-- TRUE
40+true :: Expr (null 'PGbool)
41+true = UnsafeExpression "TRUE"
42+
43+-- | >>> printSQL false
44+-- FALSE
45+false :: Expr (null 'PGbool)
46+false = UnsafeExpression "FALSE"
47+
48+-- | >>> printSQL $ not_ true
49+-- (NOT TRUE)
50+not_ :: null 'PGbool --> null 'PGbool
51+not_ = unsafeLeftOp "NOT"
52+
53+-- | >>> printSQL $ true .&& false
54+-- (TRUE AND FALSE)
55+(.&&) :: Operator (null 'PGbool) (null 'PGbool) (null 'PGbool)
56+infixr 3 .&&
57+(.&&) = unsafeBinaryOp "AND"
58+
59+-- | >>> printSQL $ true .|| false
60+-- (TRUE OR FALSE)
61+(.||) :: Operator (null 'PGbool) (null 'PGbool) (null 'PGbool)
62+infixr 2 .||
63+(.||) = unsafeBinaryOp "OR"
64+
65+-- | >>> :{
66+-- let
67+-- expression :: Expression outer commons grp schemas params from (null 'PGint2)
68+-- expression = caseWhenThenElse [(true, 1), (false, 2)] 3
69+-- in printSQL expression
70+-- :}
71+-- CASE WHEN TRUE THEN 1 WHEN FALSE THEN 2 ELSE 3 END
72+caseWhenThenElse
73+ :: [ ( Condition outer commons grp schemas params from
74+ , Expression outer commons grp schemas params from ty
75+ ) ]
76+ -- ^ whens and thens
77+ -> Expression outer commons grp schemas params from ty
78+ -- ^ else
79+ -> Expression outer commons grp schemas params from ty
80+caseWhenThenElse whenThens else_ = UnsafeExpression $ mconcat
81+ [ "CASE"
82+ , mconcat
83+ [ mconcat
84+ [ " WHEN ", renderSQL when_
85+ , " THEN ", renderSQL then_
86+ ]
87+ | (when_,then_) <- whenThens
88+ ]
89+ , " ELSE ", renderSQL else_
90+ , " END"
91+ ]
92+
93+-- | >>> :{
94+-- let
95+-- expression :: Expression outer commons grp schemas params from (null 'PGint2)
96+-- expression = ifThenElse true 1 0
97+-- in printSQL expression
98+-- :}
99+-- CASE WHEN TRUE THEN 1 ELSE 0 END
100+ifThenElse
101+ :: Condition outer commons grp schemas params from
102+ -> Expression outer commons grp schemas params from ty -- ^ then
103+ -> Expression outer commons grp schemas params from ty -- ^ else
104+ -> Expression outer commons grp schemas params from ty
105+ifThenElse if_ then_ else_ = caseWhenThenElse [(if_,then_)] else_
squeal-postgresql/src/Squeal/PostgreSQL/Expression/Math.hsnew file+100
@@ -0,0 +1,100 @@
1+{-|
2+Module: Squeal.PostgreSQL.Expression.Math
3+Description: Math expressions
4+Copyright: (c) Eitan Chatav, 2019
5+Maintainer: eitan@morphism.tech
6+Stability: experimental
7+
8+Mathematical functions and operators
9+-}
10+
11+{-# LANGUAGE
12+ DataKinds
13+ , OverloadedStrings
14+ , TypeOperators
15+#-}
16+
17+module Squeal.PostgreSQL.Expression.Math
18+ ( atan2_
19+ , quot_
20+ , rem_
21+ , trunc
22+ , round_
23+ , ceiling_
24+ ) where
25+
26+import Squeal.PostgreSQL.Expression
27+import Squeal.PostgreSQL.List
28+import Squeal.PostgreSQL.Schema
29+
30+-- $setup
31+-- >>> import Squeal.PostgreSQL
32+
33+-- | >>> :{
34+-- let
35+-- expression :: Expr (null 'PGfloat4)
36+-- expression = atan2_ (pi *: 2)
37+-- in printSQL expression
38+-- :}
39+-- atan2(pi(), 2)
40+atan2_ :: float `In` PGFloating => '[ null float, null float] ---> null float
41+atan2_ = unsafeFunctionN "atan2"
42+
43+
44+-- | integer division, truncates the result
45+--
46+-- >>> :{
47+-- let
48+-- expression :: Expression outer commons grp schemas params from (null 'PGint2)
49+-- expression = 5 `quot_` 2
50+-- in printSQL expression
51+-- :}
52+-- (5 / 2)
53+quot_
54+ :: int `In` PGIntegral
55+ => Operator (null int) (null int) (null int)
56+quot_ = unsafeBinaryOp "/"
57+
58+-- | remainder upon integer division
59+--
60+-- >>> :{
61+-- let
62+-- expression :: Expression outer commons grp schemas params from (null 'PGint2)
63+-- expression = 5 `rem_` 2
64+-- in printSQL expression
65+-- :}
66+-- (5 % 2)
67+rem_
68+ :: int `In` PGIntegral
69+ => Operator (null int) (null int) (null int)
70+rem_ = unsafeBinaryOp "%"
71+
72+-- | >>> :{
73+-- let
74+-- expression :: Expression outer commons grp schemas params from (null 'PGfloat4)
75+-- expression = trunc pi
76+-- in printSQL expression
77+-- :}
78+-- trunc(pi())
79+trunc :: frac `In` PGFloating => null frac --> null frac
80+trunc = unsafeFunction "trunc"
81+
82+-- | >>> :{
83+-- let
84+-- expression :: Expression outer commons grp schemas params from (null 'PGfloat4)
85+-- expression = round_ pi
86+-- in printSQL expression
87+-- :}
88+-- round(pi())
89+round_ :: frac `In` PGFloating => null frac --> null frac
90+round_ = unsafeFunction "round"
91+
92+-- | >>> :{
93+-- let
94+-- expression :: Expression outer commons grp schemas params from (null 'PGfloat4)
95+-- expression = ceiling_ pi
96+-- in printSQL expression
97+-- :}
98+-- ceiling(pi())
99+ceiling_ :: frac `In` PGFloating => null frac --> null frac
100+ceiling_ = unsafeFunction "ceiling"
squeal-postgresql/src/Squeal/PostgreSQL/Expression/Null.hsnew file+104
@@ -0,0 +1,104 @@
1+{-|
2+Module: Squeal.PostgreSQL.Expression.Null
3+Description: Null
4+Copyright: (c) Eitan Chatav, 2019
5+Maintainer: eitan@morphism.tech
6+Stability: experimental
7+
8+Null values and null handling functions
9+-}
10+
11+{-# LANGUAGE
12+ DataKinds
13+ , OverloadedStrings
14+ , TypeOperators
15+#-}
16+
17+module Squeal.PostgreSQL.Expression.Null
18+ ( null_
19+ , notNull
20+ , coalesce
21+ , fromNull
22+ , isNull
23+ , isNotNull
24+ , matchNull
25+ , nullIf
26+ ) where
27+
28+import Squeal.PostgreSQL.Expression
29+import Squeal.PostgreSQL.Expression.Logic
30+import Squeal.PostgreSQL.Render
31+import Squeal.PostgreSQL.Schema
32+
33+-- $setup
34+-- >>> import Squeal.PostgreSQL
35+
36+-- | analagous to `Nothing`
37+--
38+-- >>> printSQL null_
39+-- NULL
40+null_ :: Expr ('Null ty)
41+null_ = UnsafeExpression "NULL"
42+
43+-- | analagous to `Just`
44+--
45+-- >>> printSQL $ notNull true
46+-- TRUE
47+notNull :: 'NotNull ty --> 'Null ty
48+notNull = UnsafeExpression . renderSQL
49+
50+-- | return the leftmost value which is not NULL
51+--
52+-- >>> printSQL $ coalesce [null_, true] false
53+-- COALESCE(NULL, TRUE, FALSE)
54+coalesce :: FunctionVar ('Null ty) ('NotNull ty) ('NotNull ty)
55+coalesce nullxs notNullx = UnsafeExpression $
56+ "COALESCE" <> parenthesized (commaSeparated
57+ ((renderSQL <$> nullxs) <> [renderSQL notNullx]))
58+
59+-- | analagous to `Data.Maybe.fromMaybe` using @COALESCE@
60+--
61+-- >>> printSQL $ fromNull true null_
62+-- COALESCE(NULL, TRUE)
63+fromNull
64+ :: Expression outer commons grp schemas params from ('NotNull ty)
65+ -- ^ what to convert @NULL@ to
66+ -> Expression outer commons grp schemas params from ('Null ty)
67+ -> Expression outer commons grp schemas params from ('NotNull ty)
68+fromNull notNullx nullx = coalesce [nullx] notNullx
69+
70+-- | >>> printSQL $ null_ & isNull
71+-- NULL IS NULL
72+isNull :: 'Null ty --> null 'PGbool
73+isNull x = UnsafeExpression $ renderSQL x <+> "IS NULL"
74+
75+-- | >>> printSQL $ null_ & isNotNull
76+-- NULL IS NOT NULL
77+isNotNull :: 'Null ty --> null 'PGbool
78+isNotNull x = UnsafeExpression $ renderSQL x <+> "IS NOT NULL"
79+
80+-- | analagous to `maybe` using @IS NULL@
81+--
82+-- >>> printSQL $ matchNull true not_ null_
83+-- CASE WHEN NULL IS NULL THEN TRUE ELSE (NOT NULL) END
84+matchNull
85+ :: Expression outer commons grp schemas params from (nullty)
86+ -- ^ what to convert @NULL@ to
87+ -> ( Expression outer commons grp schemas params from ('NotNull ty)
88+ -> Expression outer commons grp schemas params from (nullty) )
89+ -- ^ function to perform when @NULL@ is absent
90+ -> Expression outer commons grp schemas params from ('Null ty)
91+ -> Expression outer commons grp schemas params from (nullty)
92+matchNull y f x = ifThenElse (isNull x) y
93+ (f (UnsafeExpression (renderSQL x)))
94+
95+{-| right inverse to `fromNull`, if its arguments are equal then
96+`nullIf` gives @NULL@.
97+
98+>>> :set -XTypeApplications -XDataKinds
99+>>> let expr = nullIf (false *: param @1) :: Expression outer commons grp schemas '[ 'NotNull 'PGbool] from ('Null 'PGbool)
100+>>> printSQL expr
101+NULLIF(FALSE, ($1 :: bool))
102+-}
103+nullIf :: '[ 'NotNull ty, 'NotNull ty] ---> 'Null ty
104+nullIf = unsafeFunctionN "NULLIF"
squeal-postgresql/src/Squeal/PostgreSQL/Expression/Parameter.hsnew file+80
@@ -0,0 +1,80 @@
1+{-|
2+Module: Squeal.PostgreSQL.Expression.Parameter
3+Description: Parameters
4+Copyright: (c) Eitan Chatav, 2019
5+Maintainer: eitan@morphism.tech
6+Stability: experimental
7+
8+Parameters, out-of-line data values
9+-}
10+
11+{-# LANGUAGE
12+ AllowAmbiguousTypes
13+ , DataKinds
14+ , FlexibleContexts
15+ , FlexibleInstances
16+ , FunctionalDependencies
17+ , KindSignatures
18+ , MultiParamTypeClasses
19+ , OverloadedStrings
20+ , RankNTypes
21+ , ScopedTypeVariables
22+ , TypeApplications
23+ , TypeOperators
24+ , UndecidableInstances
25+#-}
26+
27+module Squeal.PostgreSQL.Expression.Parameter
28+ ( HasParameter (parameter)
29+ , param
30+ ) where
31+
32+import GHC.TypeLits
33+
34+import Squeal.PostgreSQL.Expression
35+import Squeal.PostgreSQL.Expression.Type
36+import Squeal.PostgreSQL.Render
37+import Squeal.PostgreSQL.Schema
38+
39+-- $setup
40+-- >>> import Squeal.PostgreSQL
41+
42+{- | A `HasParameter` constraint is used to indicate a value that is
43+supplied externally to a SQL statement.
44+`Squeal.PostgreSQL.PQ.manipulateParams`,
45+`Squeal.PostgreSQL.PQ.queryParams` and
46+`Squeal.PostgreSQL.PQ.traversePrepared` support specifying data values
47+separately from the SQL command string, in which case `param`s are used to
48+refer to the out-of-line data values.
49+-}
50+class KnownNat n => HasParameter
51+ (n :: Nat)
52+ (params :: [NullityType])
53+ (ty :: NullityType)
54+ | n params -> ty where
55+ -- | `parameter` takes a `Nat` using type application and a `TypeExpression`.
56+ --
57+ -- >>> let expr = parameter @1 int4 :: Expression outer '[] grp schemas '[ 'Null 'PGint4] from ('Null 'PGint4)
58+ -- >>> printSQL expr
59+ -- ($1 :: int4)
60+ parameter
61+ :: TypeExpression schemas ty
62+ -> Expression outer commons grp schemas params from ty
63+ parameter ty = UnsafeExpression $ parenthesized $
64+ "$" <> renderNat @n <+> "::"
65+ <+> renderSQL ty
66+instance {-# OVERLAPPING #-} HasParameter 1 (ty1:tys) ty1
67+instance {-# OVERLAPPABLE #-} (KnownNat n, HasParameter (n-1) params ty)
68+ => HasParameter n (ty' : params) ty
69+
70+-- | `param` takes a `Nat` using type application and for basic types,
71+-- infers a `TypeExpression`.
72+--
73+-- >>> let expr = param @1 :: Expression outer commons grp schemas '[ 'Null 'PGint4] from ('Null 'PGint4)
74+-- >>> printSQL expr
75+-- ($1 :: int4)
76+param
77+ :: forall n outer commons schemas params from grp ty
78+ . (PGTyped schemas ty, HasParameter n params ty)
79+ => Expression outer commons grp schemas params from ty -- ^ param
80+param = parameter @n (pgtype @schemas)
squeal-postgresql/src/Squeal/PostgreSQL/Expression/Range.hsnew file+230
@@ -0,0 +1,230 @@
1+{-|
2+Module: Squeal.PostgreSQL.Expression.Range
3+Description: range types and functions
4+Copyright: (c) Eitan Chatav, 2019
5+Maintainer: eitan@morphism.tech
6+Stability: experimental
7+
8+Range types and functions
9+-}
10+
11+{-# LANGUAGE
12+ AllowAmbiguousTypes
13+ , DataKinds
14+ , DeriveAnyClass
15+ , DeriveGeneric
16+ , DeriveFoldable
17+ , DerivingStrategies
18+ , DeriveTraversable
19+ , FlexibleContexts
20+ , FlexibleInstances
21+ , LambdaCase
22+ , MultiParamTypeClasses
23+ , OverloadedLabels
24+ , OverloadedStrings
25+ , PatternSynonyms
26+ , RankNTypes
27+ , ScopedTypeVariables
28+ , TypeApplications
29+ , TypeFamilies
30+ , TypeOperators
31+ , UndecidableInstances
32+#-}
33+
34+module Squeal.PostgreSQL.Expression.Range
35+ ( range
36+ , Range (..)
37+ , (<=..<=), (<..<), (<=..<), (<..<=)
38+ , moreThan, atLeast, lessThan, atMost
39+ , singleton, whole
40+ , Bound (..)
41+ , (.<@)
42+ , (@>.)
43+ , (<<@)
44+ , (@>>)
45+ , (&<)
46+ , (&>)
47+ , (-|-)
48+ , (@+)
49+ , (@*)
50+ , (@-)
51+ , lowerBound
52+ , upperBound
53+ , isEmpty
54+ , lowerInc
55+ , lowerInf
56+ , upperInc
57+ , upperInf
58+ , rangeMerge
59+ ) where
60+
61+import BinaryParser
62+import ByteString.StrictBuilder
63+import Data.Bits
64+import qualified GHC.Generics as GHC
65+import qualified Generics.SOP as SOP
66+import qualified PostgreSQL.Binary.Decoding as Decoding
67+
68+import Squeal.PostgreSQL.Binary
69+import Squeal.PostgreSQL.Expression
70+import Squeal.PostgreSQL.Expression.Type hiding (bool)
71+import Squeal.PostgreSQL.PG
72+import Squeal.PostgreSQL.Render
73+import Squeal.PostgreSQL.Schema
74+
75+-- $setup
76+-- >>> import Squeal.PostgreSQL
77+
78+-- | Construct a `range`
79+--
80+-- >>> printSQL $ range tstzrange (atLeast now)
81+-- tstzrange(now(), NULL, '[)')
82+-- >>> printSQL $ range numrange (0 <=..< 2*pi)
83+-- numrange(0, (2 * pi()), '[)')
84+-- >>> printSQL $ range int4range Empty
85+-- ('empty' :: int4range)
86+range
87+ :: TypeExpression schemas (null ('PGrange ty))
88+ -> Range (Expression outer commons grp schemas params from ('NotNull ty))
89+ -> Expression outer commons grp schemas params from (null ('PGrange ty))
90+range ty = \case
91+ Empty -> UnsafeExpression $ parenthesized
92+ (emp <+> "::" <+> renderSQL ty)
93+ NonEmpty l u -> UnsafeExpression $ renderSQL ty <> parenthesized
94+ (commaSeparated (args l u))
95+ where
96+ emp = singleQuote <> "empty" <> singleQuote
97+ args l u = [arg l, arg u, singleQuote <> bra l <> ket u <> singleQuote]
98+ singleQuote = "\'"
99+ arg = \case
100+ Infinite -> "NULL"; Closed x -> renderSQL x; Open x -> renderSQL x
101+ bra = \case Infinite -> "("; Closed _ -> "["; Open _ -> "("
102+ ket = \case Infinite -> ")"; Closed _ -> "]"; Open _ -> ")"
103+
104+data Bound x = Infinite | Closed x | Open x
105+ deriving
106+ ( Eq, Ord, Show, Read, GHC.Generic
107+ , Functor, Foldable, Traversable )
108+
109+data Range x = Empty | NonEmpty (Bound x) (Bound x)
110+ deriving
111+ ( Eq, Ord, Show, Read, GHC.Generic
112+ , Functor, Foldable, Traversable )
113+ deriving anyclass (SOP.Generic, SOP.HasDatatypeInfo)
114+type instance PG (Range x) = 'PGrange (PG x)
115+instance ToParam x pg => ToParam (Range x) ('PGrange pg) where
116+ toParam rng = K $
117+ word8 (setFlags rng 0) <>
118+ case rng of
119+ Empty -> mempty
120+ NonEmpty lower upper -> putBound lower <> putBound upper
121+ where
122+ putBound = \case
123+ Infinite -> mempty
124+ Closed value -> putValue (unK (toParam @x @pg value))
125+ Open value -> putValue (unK (toParam @x @pg value))
126+ putValue value = int32BE (fromIntegral (builderLength value)) <> value
127+ setFlags = \case
128+ Empty -> (`setBit` 0)
129+ NonEmpty lower upper ->
130+ setLowerFlags lower . setUpperFlags upper
131+ setLowerFlags = \case
132+ Infinite -> (`setBit` 3)
133+ Closed _ -> (`setBit` 1)
134+ Open _ -> id
135+ setUpperFlags = \case
136+ Infinite -> (`setBit` 4)
137+ Closed _ -> (`setBit` 2)
138+ Open _ -> id
139+instance FromValue pg y => FromValue ('PGrange pg) (Range y) where
140+ fromValue = do
141+ flag <- byte
142+ if testBit flag 0 then return Empty else do
143+ lower <-
144+ if testBit flag 3
145+ then return Infinite
146+ else do
147+ len <- sized 4 Decoding.int
148+ l <- sized len (fromValue @pg)
149+ return $ if testBit flag 1 then Closed l else Open l
150+ upper <-
151+ if testBit flag 4
152+ then return Infinite
153+ else do
154+ len <- sized 4 Decoding.int
155+ l <- sized len (fromValue @pg)
156+ return $ if testBit flag 2 then Closed l else Open l
157+ return $ NonEmpty lower upper
158+
159+(<=..<=), (<..<), (<=..<), (<..<=) :: x -> x -> Range x
160+infix 4 <=..<=, <..<, <=..<, <..<=
161+x <=..<= y = NonEmpty (Closed x) (Closed y)
162+x <..< y = NonEmpty (Open x) (Open y)
163+x <=..< y = NonEmpty (Closed x) (Open y)
164+x <..<= y = NonEmpty (Open x) (Closed y)
165+
166+moreThan, atLeast, lessThan, atMost :: x -> Range x
167+moreThan x = NonEmpty (Open x) Infinite
168+atLeast x = NonEmpty (Closed x) Infinite
169+lessThan x = NonEmpty Infinite (Open x)
170+atMost x = NonEmpty Infinite (Closed x)
171+
172+singleton :: x -> Range x
173+singleton x = x <=..<= x
174+
175+whole :: Range x
176+whole = NonEmpty Infinite Infinite
177+
178+(.<@) :: Operator ('NotNull ty) (null ('PGrange ty)) ('Null 'PGbool)
179+(.<@) = unsafeBinaryOp "<@"
180+
181+(@>.) :: Operator (null ('PGrange ty)) ('NotNull ty) ('Null 'PGbool)
182+(@>.) = unsafeBinaryOp "<@"
183+
184+(<<@) :: Operator (null ('PGrange ty)) (null ('PGrange ty)) ('Null 'PGbool)
185+(<<@) = unsafeBinaryOp "<<"
186+
187+(@>>) :: Operator (null ('PGrange ty)) (null ('PGrange ty)) ('Null 'PGbool)
188+(@>>) = unsafeBinaryOp ">>"
189+
190+(&<) :: Operator (null ('PGrange ty)) (null ('PGrange ty)) ('Null 'PGbool)
191+(&<) = unsafeBinaryOp "&<"
192+
193+(&>) :: Operator (null ('PGrange ty)) (null ('PGrange ty)) ('Null 'PGbool)
194+(&>) = unsafeBinaryOp "&>"
195+
196+(-|-) :: Operator (null ('PGrange ty)) (null ('PGrange ty)) ('Null 'PGbool)
197+(-|-) = unsafeBinaryOp "-|-"
198+
199+(@+) :: Operator (null ('PGrange ty)) (null ('PGrange ty)) (null ('PGrange ty))
200+(@+) = unsafeBinaryOp "+"
201+
202+(@*) :: Operator (null ('PGrange ty)) (null ('PGrange ty)) (null ('PGrange ty))
203+(@*) = unsafeBinaryOp "*"
204+
205+(@-) :: Operator (null ('PGrange ty)) (null ('PGrange ty)) (null ('PGrange ty))
206+(@-) = unsafeBinaryOp "-"
207+
208+lowerBound :: null ('PGrange ty) --> 'Null ty
209+lowerBound = unsafeFunction "lower"
210+
211+upperBound :: null ('PGrange ty) --> 'Null ty
212+upperBound = unsafeFunction "upper"
213+
214+isEmpty :: null ('PGrange ty) --> 'Null 'PGbool
215+isEmpty = unsafeFunction "isempty"
216+
217+lowerInc :: null ('PGrange ty) --> 'Null 'PGbool
218+lowerInc = unsafeFunction "lower_inc"
219+
220+lowerInf :: null ('PGrange ty) --> 'Null 'PGbool
221+lowerInf = unsafeFunction "lower_inf"
222+
223+upperInc :: null ('PGrange ty) --> 'Null 'PGbool
224+upperInc = unsafeFunction "upper_inc"
225+
226+upperInf :: null ('PGrange ty) --> 'Null 'PGbool
227+upperInf = unsafeFunction "upper_inf"
228+
229+rangeMerge :: '[null ('PGrange ty), null ('PGrange ty)] ---> null ('PGrange ty)
230+rangeMerge = unsafeFunctionN "range_merge"
squeal-postgresql/src/Squeal/PostgreSQL/Expression/Set.hsnew file+139
@@ -0,0 +1,139 @@
1+{-|
2+Module: Squeal.PostgreSQL.Expression.Set
3+Description: Set returning functions
4+Copyright: (c) Eitan Chatav, 2019
5+Maintainer: eitan@morphism.tech
6+Stability: experimental
7+
8+Set returning functions
9+-}
10+
11+{-# LANGUAGE
12+ AllowAmbiguousTypes
13+ , DataKinds
14+ , FlexibleContexts
15+ , OverloadedStrings
16+ , PolyKinds
17+ , RankNTypes
18+ , ScopedTypeVariables
19+ , TypeApplications
20+ , TypeOperators
21+#-}
22+
23+module Squeal.PostgreSQL.Expression.Set
24+ ( generateSeries
25+ , generateSeriesStep
26+ , generateSeriesTimestamp
27+ , SetFunction
28+ , unsafeSetFunction
29+ , SetFunctionDB
30+ , setFunction
31+ , SetFunctionN
32+ , unsafeSetFunctionN
33+ , SetFunctionNDB
34+ , setFunctionN
35+ ) where
36+
37+import GHC.TypeLits
38+
39+import qualified Generics.SOP as SOP
40+
41+import Squeal.PostgreSQL.Alias
42+import Squeal.PostgreSQL.Expression
43+import Squeal.PostgreSQL.List
44+import Squeal.PostgreSQL.Render
45+import Squeal.PostgreSQL.Query
46+import Squeal.PostgreSQL.Schema
47+
48+{- |
49+A @RankNType@ for set returning functions with 1 argument.
50+-}
51+type SetFunction fun ty row
52+ = forall outer commons schemas params
53+ . Expression outer commons 'Ungrouped schemas params '[] ty
54+ -- ^ input
55+ -> FromClause outer commons schemas params '[fun ::: row]
56+ -- ^ output
57+
58+type SetFunctionDB fun schemas ty row
59+ = forall outer commons params
60+ . Expression outer commons 'Ungrouped schemas params '[] ty
61+ -- ^ input
62+ -> FromClause outer commons schemas params '[fun ::: row]
63+ -- ^ output
64+
65+-- | Escape hatch for a set returning function with 1 argument.
66+unsafeSetFunction
67+ :: forall fun ty row. KnownSymbol fun
68+ => SetFunction fun ty row -- ^ set returning function
69+unsafeSetFunction x = UnsafeFromClause $
70+ renderSymbol @fun <> parenthesized (renderSQL x)
71+
72+setFunction
73+ :: ( Has sch schemas schema
74+ , Has fun schema ('Function ('[ty] :=> 'ReturnsTable row)) )
75+ => QualifiedAlias sch fun
76+ -> SetFunctionDB fun schemas ty row
77+setFunction _ = unsafeSetFunction
78+
79+{- |
80+A @RankNType@ for set returning functions with multiple argument.
81+-}
82+type SetFunctionN fun tys row
83+ = forall outer commons schemas params
84+ . NP (Expression outer commons 'Ungrouped schemas params '[]) tys
85+ -- ^ inputs
86+ -> FromClause outer commons schemas params '[fun ::: row]
87+ -- ^ output
88+
89+-- | Escape hatch for a set returning function with multiple argument.
90+unsafeSetFunctionN
91+ :: forall fun tys row. (SOP.SListI tys, KnownSymbol fun)
92+ => SetFunctionN fun tys row -- ^ set returning function
93+unsafeSetFunctionN xs = UnsafeFromClause $
94+ renderSymbol @fun <> parenthesized (renderCommaSeparated renderSQL xs)
95+
96+type SetFunctionNDB fun schemas tys row
97+ = forall outer commons params
98+ . NP (Expression outer commons 'Ungrouped schemas params '[]) tys
99+ -- ^ inputs
100+ -> FromClause outer commons schemas params '[fun ::: row]
101+ -- ^ output
102+
103+setFunctionN
104+ :: ( Has sch schemas schema
105+ , Has fun schema ('Function (tys :=> 'ReturnsTable row))
106+ , SOP.SListI tys )
107+ => QualifiedAlias sch fun
108+ -> SetFunctionNDB fun schemas tys row
109+setFunctionN _ = unsafeSetFunctionN
110+
111+{- | @generateSeries (start *: stop)@
112+
113+Generate a series of values, from @start@ to @stop@ with a step size of one
114+-}
115+generateSeries
116+ :: ty `In` '[ 'PGint4, 'PGint8, 'PGnumeric]
117+ => SetFunctionN "generate_series" '[ null ty, null ty]
118+ '["generate_series" ::: null ty] -- ^ set returning function
119+generateSeries = unsafeSetFunctionN
120+
121+{- | @generateSeries (start :* stop *: step)@
122+
123+Generate a series of values, from @start@ to @stop@ with a step size of @step@
124+-}
125+generateSeriesStep
126+ :: ty `In` '[ 'PGint4, 'PGint8, 'PGnumeric]
127+ => SetFunctionN "generate_series" '[null ty, null ty, null ty]
128+ '["generate_series" ::: null ty] -- ^ set returning function
129+generateSeriesStep = unsafeSetFunctionN
130+
131+{- | @generateSeries (start :* stop *: step)@
132+
133+Generate a series of values, from @start@ to @stop@ with a step size of @step@
134+-}
135+generateSeriesTimestamp
136+ :: ty `In` '[ 'PGtimestamp, 'PGtimestamptz]
137+ => SetFunctionN "generate_series" '[null ty, null ty, null 'PGinterval]
138+ '["generate_series" ::: null ty] -- ^ set returning function
139+generateSeriesTimestamp = unsafeSetFunctionN
squeal-postgresql/src/Squeal/PostgreSQL/Expression/Sort.hsnew file+85
@@ -0,0 +1,85 @@
1+{-|
2+Module: Squeal.PostgreSQL.Expression.Sort
3+Description: Sort expressions
4+Copyright: (c) Eitan Chatav, 2019
5+Maintainer: eitan@morphism.tech
6+Stability: experimental
7+
8+Sort expressions
9+-}
10+
11+{-# LANGUAGE
12+ DataKinds
13+ , GADTs
14+ , LambdaCase
15+ , OverloadedStrings
16+ , StandaloneDeriving
17+#-}
18+
19+module Squeal.PostgreSQL.Expression.Sort
20+ ( SortExpression (..)
21+ , OrderBy (..)
22+ ) where
23+
24+import Squeal.PostgreSQL.Expression
25+import Squeal.PostgreSQL.Render
26+import Squeal.PostgreSQL.Schema
27+
28+-- | `SortExpression`s are used by `orderBy` to optionally sort the results
29+-- of a `Squeal.PostgreSQL.Query.Query`. `Asc` or `Desc`
30+-- set the sort direction of a `NotNull` result
31+-- column to ascending or descending. Ascending order puts smaller values
32+-- first, where "smaller" is defined in terms of the
33+-- `Squeal.PostgreSQL.Expression.Comparison..<` operator. Similarly,
34+-- descending order is determined with the
35+-- `Squeal.PostgreSQL.Expression.Comparison..>` operator. `AscNullsFirst`,
36+-- `AscNullsLast`, `DescNullsFirst` and `DescNullsLast` options are used to
37+-- determine whether nulls appear before or after non-null values in the sort
38+-- ordering of a `Null` result column.
39+data SortExpression outer commons grp schemas params from where
40+ Asc
41+ :: Expression outer commons grp schemas params from ('NotNull ty)
42+ -> SortExpression outer commons grp schemas params from
43+ Desc
44+ :: Expression outer commons grp schemas params from ('NotNull ty)
45+ -> SortExpression outer commons grp schemas params from
46+ AscNullsFirst
47+ :: Expression outer commons grp schemas params from ('Null ty)
48+ -> SortExpression outer commons grp schemas params from
49+ AscNullsLast
50+ :: Expression outer commons grp schemas params from ('Null ty)
51+ -> SortExpression outer commons grp schemas params from
52+ DescNullsFirst
53+ :: Expression outer commons grp schemas params from ('Null ty)
54+ -> SortExpression outer commons grp schemas params from
55+ DescNullsLast
56+ :: Expression outer commons grp schemas params from ('Null ty)
57+ -> SortExpression outer commons grp schemas params from
58+deriving instance Show (SortExpression outer commons grp schemas params from)
59+instance RenderSQL (SortExpression outer commons grp schemas params from) where
60+ renderSQL = \case
61+ Asc expression -> renderSQL expression <+> "ASC"
62+ Desc expression -> renderSQL expression <+> "DESC"
63+ AscNullsFirst expression -> renderSQL expression
64+ <+> "ASC NULLS FIRST"
65+ DescNullsFirst expression -> renderSQL expression
66+ <+> "DESC NULLS FIRST"
67+ AscNullsLast expression -> renderSQL expression <+> "ASC NULLS LAST"
68+ DescNullsLast expression -> renderSQL expression <+> "DESC NULLS LAST"
69+
70+{- |
71+The `orderBy` clause causes the result rows of a `Squeal.PostgreSQL.Query.TableExpression`
72+to be sorted according to the specified `SortExpression`(s).
73+If two rows are equal according to the leftmost expression,
74+they are compared according to the next expression and so on.
75+If they are equal according to all specified expressions,
76+they are returned in an implementation-dependent order.
77+
78+You can also control the order in which rows are processed by window functions
79+using `orderBy` within `Squeal.PostgreSQL.Query.Over`.
80+-}
81+class OrderBy expr where
82+ orderBy
83+ :: [SortExpression outer commons grp schemas params from]
84+ -> expr outer commons grp schemas params from
85+ -> expr outer commons grp schemas params from
squeal-postgresql/src/Squeal/PostgreSQL/Expression/Subquery.hsnew file+120
@@ -0,0 +1,120 @@
1+{-|
2+Module: Squeal.PostgreSQL.Expression.Subquery
3+Description: Subquery expressions
4+Copyright: (c) Eitan Chatav, 2019
5+Maintainer: eitan@morphism.tech
6+Stability: experimental
7+
8+Subquery expressions
9+-}
10+
11+{-# LANGUAGE
12+ DataKinds
13+ , OverloadedStrings
14+ , RankNTypes
15+ , TypeOperators
16+#-}
17+
18+module Squeal.PostgreSQL.Expression.Subquery
19+ ( exists
20+ , in_
21+ , notIn
22+ , subAll
23+ , subAny
24+ ) where
25+
26+import Squeal.PostgreSQL.Alias
27+import Squeal.PostgreSQL.Expression
28+import Squeal.PostgreSQL.Expression.Logic
29+import Squeal.PostgreSQL.List
30+import Squeal.PostgreSQL.Query
31+import Squeal.PostgreSQL.Render
32+import Squeal.PostgreSQL.Schema
33+
34+-- $setup
35+-- >>> import Squeal.PostgreSQL
36+
37+{- |
38+The argument of `exists` is an arbitrary subquery. The subquery is evaluated
39+to determine whether it returns any rows. If it returns at least one row,
40+the result of `exists` is `true`; if the subquery returns no rows,
41+the result of `exists` is `false`.
42+
43+The subquery can refer to variables from the surrounding query,
44+which will act as constants during any one evaluation of the subquery.
45+
46+The subquery will generally only be executed long enough to determine whether
47+at least one row is returned, not all the way to completion.
48+-}
49+exists
50+ :: Query (Join outer from) commons schemas params row
51+ -> Condition outer commons grp schemas params from
52+exists query = UnsafeExpression $ "EXISTS" <+> parenthesized (renderSQL query)
53+
54+{- |
55+The right-hand side is a parenthesized subquery, which must return
56+exactly one column. The left-hand expression is evaluated and compared to each
57+row of the subquery result using the given `Operator`,
58+which must yield a Boolean result. The result of `subAll` is `true`
59+if all rows yield true (including the case where the subquery returns no rows).
60+The result is `false` if any `false` result is found.
61+The result is `Squeal.PostgreSQL.Expression.Null.null_` if
62+ no comparison with a subquery row returns `false`,
63+and at least one comparison returns `Squeal.PostgreSQL.Expression.Null.null_`.
64+
65+>>> printSQL $ subAll true (.==) (values_ (true `as` #foo))
66+(TRUE = ALL (SELECT * FROM (VALUES (TRUE)) AS t ("foo")))
67+-}
68+subAll
69+ :: Expression outer commons grp schemas params from ty1 -- ^ expression
70+ -> Operator ty1 ty2 ('Null 'PGbool) -- ^ operator
71+ -> Query (Join outer from) commons schemas params '[col ::: ty2] -- ^ subquery
72+ -> Condition outer commons grp schemas params from
73+subAll expr (?) qry = expr ?
74+ (UnsafeExpression $ "ALL" <+> parenthesized (renderSQL qry))
75+
76+{- |
77+The right-hand side is a parenthesized subquery, which must return exactly one column.
78+The left-hand expression is evaluated and compared to each row of the subquery result
79+using the given `Operator`, which must yield a Boolean result. The result of `subAny` is `true`
80+if any `true` result is obtained. The result is `false` if no true result is found
81+(including the case where the subquery returns no rows).
82+
83+>>> printSQL $ subAny "foo" like (values_ ("foobar" `as` #foo))
84+(E'foo' LIKE ANY (SELECT * FROM (VALUES (E'foobar')) AS t ("foo")))
85+-}
86+subAny
87+ :: Expression outer commons grp schemas params from ty1 -- ^ expression
88+ -> Operator ty1 ty2 ('Null 'PGbool) -- ^ operator
89+ -> Query (Join outer from) commons schemas params '[col ::: ty2] -- ^ subquery
90+ -> Condition outer commons grp schemas params from
91+subAny expr (?) qry = expr ?
92+ (UnsafeExpression $ "ANY" <+> parenthesized (renderSQL qry))
93+
94+{- |
95+The result is `true` if the left-hand expression's result is equal
96+to any of the right-hand expressions.
97+
98+>>> printSQL $ true `in_` [true, false, null_]
99+TRUE IN (TRUE, FALSE, NULL)
100+-}
101+in_
102+ :: Expression outer commons grp schemas params from ty -- ^ expression
103+ -> [Expression outer commons grp schemas params from ty]
104+ -> Condition outer commons grp schemas params from
105+expr `in_` exprs = UnsafeExpression $ renderSQL expr <+> "IN"
106+ <+> parenthesized (commaSeparated (renderSQL <$> exprs))
107+
108+{- |
109+The result is `true` if the left-hand expression's result is not equal
110+to any of the right-hand expressions.
111+
112+>>> printSQL $ true `notIn` [false, null_]
113+TRUE NOT IN (FALSE, NULL)
114+-}
115+notIn
116+ :: Expression outer commons grp schemas params from ty -- ^ expression
117+ -> [Expression outer commons grp schemas params from ty]
118+ -> Condition outer commons grp schemas params from
119+expr `notIn` exprs = UnsafeExpression $ renderSQL expr <+> "NOT IN"
120+ <+> parenthesized (commaSeparated (renderSQL <$> exprs))
squeal-postgresql/src/Squeal/PostgreSQL/Expression/Text.hsnew file+64
@@ -0,0 +1,64 @@
1+{-|
2+Module: Squeal.PostgreSQL.Expression.Text
3+Description: Text expressions
4+Copyright: (c) Eitan Chatav, 2019
5+Maintainer: eitan@morphism.tech
6+Stability: experimental
7+
8+String functions and operators
9+-}
10+
11+{-# LANGUAGE
12+ DataKinds
13+ , OverloadedStrings
14+ , TypeOperators
15+#-}
16+
17+module Squeal.PostgreSQL.Expression.Text
18+ ( lower
19+ , upper
20+ , charLength
21+ , like
22+ , ilike
23+ ) where
24+
25+import Squeal.PostgreSQL.Expression
26+import Squeal.PostgreSQL.Schema
27+
28+-- $setup
29+-- >>> import Squeal.PostgreSQL
30+
31+-- | >>> printSQL $ lower "ARRRGGG"
32+-- lower(E'ARRRGGG')
33+lower :: null 'PGtext --> null 'PGtext
34+lower = unsafeFunction "lower"
35+
36+-- | >>> printSQL $ upper "eeee"
37+-- upper(E'eeee')
38+upper :: null 'PGtext --> null 'PGtext
39+upper = unsafeFunction "upper"
40+
41+-- | >>> printSQL $ charLength "four"
42+-- char_length(E'four')
43+charLength :: null 'PGtext --> null 'PGint4
44+charLength = unsafeFunction "char_length"
45+
46+-- | The `like` expression returns true if the @string@ matches
47+-- the supplied @pattern@. If @pattern@ does not contain percent signs
48+-- or underscores, then the pattern only represents the string itself;
49+-- in that case `like` acts like the equals operator. An underscore (_)
50+-- in pattern stands for (matches) any single character; a percent sign (%)
51+-- matches any sequence of zero or more characters.
52+--
53+-- >>> printSQL $ "abc" `like` "a%"
54+-- (E'abc' LIKE E'a%')
55+like :: Operator (null 'PGtext) (null 'PGtext) ('Null 'PGbool)
56+like = unsafeBinaryOp "LIKE"
57+
58+-- | The key word ILIKE can be used instead of LIKE to make the
59+-- match case-insensitive according to the active locale.
60+--
61+-- >>> printSQL $ "abc" `ilike` "a%"
62+-- (E'abc' ILIKE E'a%')
63+ilike :: Operator (null 'PGtext) (null 'PGtext) ('Null 'PGbool)
64+ilike = unsafeBinaryOp "ILIKE"
squeal-postgresql/src/Squeal/PostgreSQL/Expression/TextSearch.hsnew file+157
@@ -0,0 +1,157 @@
1+{-|
2+Module: Squeal.PostgreSQL.Expression.TextSearch
3+Description: Text search expressions
4+Copyright: (c) Eitan Chatav, 2019
5+Maintainer: eitan@morphism.tech
6+Stability: experimental
7+
8+Text search functions and operators
9+-}
10+
11+{-# LANGUAGE
12+ DataKinds
13+ , OverloadedStrings
14+ , TypeOperators
15+#-}
16+
17+module Squeal.PostgreSQL.Expression.TextSearch
18+ ( (@@)
19+ , (.&)
20+ , (.|)
21+ , (.!)
22+ , (<->)
23+ , arrayToTSvector
24+ , tsvectorLength
25+ , numnode
26+ , plainToTSquery
27+ , phraseToTSquery
28+ , websearchToTSquery
29+ , queryTree
30+ , toTSquery
31+ , toTSvector
32+ , setWeight
33+ , strip
34+ , jsonToTSvector
35+ , jsonbToTSvector
36+ , tsDelete
37+ , tsFilter
38+ , tsHeadline
39+ ) where
40+
41+import Squeal.PostgreSQL.Expression
42+import Squeal.PostgreSQL.List
43+import Squeal.PostgreSQL.Schema
44+
45+-- | `Squeal.PostgreSQL.Expression.Type.tsvector` matches tsquery ?
46+(@@) :: Operator (null 'PGtsvector) (null 'PGtsquery) ('Null 'PGbool)
47+(@@) = unsafeBinaryOp "@@"
48+
49+-- | AND `Squeal.PostgreSQL.Expression.Type.tsquery`s together
50+(.&) :: Operator (null 'PGtsquery) (null 'PGtsquery) (null 'PGtsquery)
51+(.&) = unsafeBinaryOp "&&"
52+
53+-- | OR `Squeal.PostgreSQL.Expression.Type.tsquery`s together
54+(.|) :: Operator (null 'PGtsquery) (null 'PGtsquery) (null 'PGtsquery)
55+(.|) = unsafeBinaryOp "||"
56+
57+-- | negate a `Squeal.PostgreSQL.Expression.Type.tsquery`
58+(.!) :: null 'PGtsquery --> null 'PGtsquery
59+(.!) = unsafeLeftOp "!!"
60+
61+-- | `Squeal.PostgreSQL.Expression.Type.tsquery` followed by
62+-- `Squeal.PostgreSQL.Expression.Type.tsquery`
63+(<->) :: Operator (null 'PGtsquery) (null 'PGtsquery) (null 'PGtsquery)
64+(<->) = unsafeBinaryOp "<->"
65+
66+-- | convert array of lexemes to `Squeal.PostgreSQL.Expression.Type.tsvector`
67+arrayToTSvector
68+ :: null ('PGvararray ('NotNull 'PGtext))
69+ --> null 'PGtsvector
70+arrayToTSvector = unsafeFunction "array_to_tsvector"
71+
72+-- | number of lexemes in `Squeal.PostgreSQL.Expression.Type.tsvector`
73+tsvectorLength :: null 'PGtsvector --> null 'PGint4
74+tsvectorLength = unsafeFunction "length"
75+
76+-- | number of lexemes plus operators in `Squeal.PostgreSQL.Expression.Type.tsquery`
77+numnode :: null 'PGtsquery --> null 'PGint4
78+numnode = unsafeFunction "numnode"
79+
80+-- | produce `Squeal.PostgreSQL.Expression.Type.tsquery` ignoring punctuation
81+plainToTSquery :: null 'PGtext --> null 'PGtsquery
82+plainToTSquery = unsafeFunction "plainto_tsquery"
83+
84+-- | produce `Squeal.PostgreSQL.Expression.Type.tsquery` that searches for a phrase,
85+-- ignoring punctuation
86+phraseToTSquery :: null 'PGtext --> null 'PGtsquery
87+phraseToTSquery = unsafeFunction "phraseto_tsquery"
88+
89+-- | produce `Squeal.PostgreSQL.Expression.Type.tsquery` from a web search style query
90+websearchToTSquery :: null 'PGtext --> null 'PGtsquery
91+websearchToTSquery = unsafeFunction "websearch_to_tsquery"
92+
93+-- | get indexable part of a `Squeal.PostgreSQL.Expression.Type.tsquery`
94+queryTree :: null 'PGtsquery --> null 'PGtext
95+queryTree = unsafeFunction "query_tree"
96+
97+-- | normalize words and convert to `Squeal.PostgreSQL.Expression.Type.tsquery`
98+toTSquery :: null 'PGtext --> null 'PGtsquery
99+toTSquery = unsafeFunction "to_tsquery"
100+
101+-- | reduce document text to `Squeal.PostgreSQL.Expression.Type.tsvector`
102+toTSvector
103+ :: ty `In` '[ 'PGtext, 'PGjson, 'PGjsonb]
104+ => null ty --> null 'PGtsvector
105+toTSvector = unsafeFunction "to_tsvector"
106+
107+-- | assign weight to each element of `Squeal.PostgreSQL.Expression.Type.tsvector`
108+setWeight :: '[null 'PGtsvector, null ('PGchar 1)] ---> null 'PGtsvector
109+setWeight = unsafeFunctionN "set_weight"
110+
111+-- | remove positions and weights from `Squeal.PostgreSQL.Expression.Type.tsvector`
112+strip :: null 'PGtsvector --> null 'PGtsvector
113+strip = unsafeFunction "strip"
114+
115+-- | @jsonToTSvector (document *: filter)@
116+-- reduce each value in the document, specified by filter to a `Squeal.PostgreSQL.Expression.Type.tsvector`,
117+-- and then concatenate those in document order to produce a single `Squeal.PostgreSQL.Expression.Type.tsvector`.
118+-- filter is a `Squeal.PostgreSQL.Expression.Type.json` array, that enumerates what kind of elements
119+-- need to be included into the resulting `Squeal.PostgreSQL.Expression.Type.tsvector`.
120+-- Possible values for filter are "string" (to include all string values),
121+-- "numeric" (to include all numeric values in the string format),
122+-- "boolean" (to include all Boolean values in the string format "true"/"false"),
123+-- "key" (to include all keys) or "all" (to include all above).
124+-- These values can be combined together to include, e.g. all string and numeric values.
125+jsonToTSvector :: '[null 'PGjson, null 'PGjson] ---> null 'PGtsvector
126+jsonToTSvector = unsafeFunctionN "json_to_tsvector"
127+
128+-- | @jsonbToTSvector (document *: filter)@
129+-- reduce each value in the document, specified by filter to a `Squeal.PostgreSQL.Expression.Type.tsvector`,
130+-- and then concatenate those in document order to produce a single `Squeal.PostgreSQL.Expression.Type.tsvector`.
131+-- filter is a `Squeal.PostgreSQL.Expression.Type.jsonb` array, that enumerates what kind of elements
132+-- need to be included into the resulting `Squeal.PostgreSQL.Expression.Type.tsvector`.
133+-- Possible values for filter are "string" (to include all string values),
134+-- "numeric" (to include all numeric values in the string format),
135+-- "boolean" (to include all Boolean values in the string format "true"/"false"),
136+-- "key" (to include all keys) or "all" (to include all above).
137+-- These values can be combined together to include, e.g. all string and numeric values.
138+jsonbToTSvector :: '[null 'PGjsonb, null 'PGjsonb] ---> null 'PGtsvector
139+jsonbToTSvector = unsafeFunctionN "jsonb_to_tsvector"
140+
141+-- | remove given lexeme from `Squeal.PostgreSQL.Expression.Type.tsvector`
142+tsDelete ::
143+ '[null 'PGtsvector, null ('PGvararray ('NotNull 'PGtext))]
144+ ---> null 'PGtsvector
145+tsDelete = unsafeFunctionN "ts_delete"
146+
147+-- | select only elements with given weights from `Squeal.PostgreSQL.Expression.Type.tsvector`
148+tsFilter ::
149+ '[null 'PGtsvector, null ('PGvararray ('NotNull ('PGchar 1)))]
150+ ---> null 'PGtsvector
151+tsFilter = unsafeFunctionN "ts_filter"
152+
153+-- | display a `Squeal.PostgreSQL.Expression.Type.tsquery` match
154+tsHeadline
155+ :: document `In` '[ 'PGtext, 'PGjson, 'PGjsonb]
156+ => '[null document, null 'PGtsquery] ---> null 'PGtext
157+tsHeadline = unsafeFunctionN "ts_headline"
squeal-postgresql/src/Squeal/PostgreSQL/Expression/Time.hsnew file+192
@@ -0,0 +1,192 @@
1+{-|
2+Module: Squeal.PostgreSQL.Expression.Time
3+Description: Date/Time expressions
4+Copyright: (c) Eitan Chatav, 2019
5+Maintainer: eitan@morphism.tech
6+Stability: experimental
7+
8+Date/Time functions and operators
9+-}
10+
11+{-# LANGUAGE
12+ DataKinds
13+ , DeriveGeneric
14+ , FunctionalDependencies
15+ , LambdaCase
16+ , MultiParamTypeClasses
17+ , OverloadedStrings
18+ , PolyKinds
19+ , RankNTypes
20+ , TypeOperators
21+#-}
22+
23+module Squeal.PostgreSQL.Expression.Time
24+ ( TimeOp (..)
25+ , currentDate
26+ , currentTime
27+ , currentTimestamp
28+ , localTime
29+ , localTimestamp
30+ , now
31+ , makeDate
32+ , makeTime
33+ , makeTimestamp
34+ , makeTimestamptz
35+ , interval_
36+ , TimeUnit (..)
37+ ) where
38+
39+import Data.String
40+
41+import qualified GHC.Generics as GHC
42+import qualified Generics.SOP as SOP
43+
44+import Squeal.PostgreSQL.Expression
45+import Squeal.PostgreSQL.Render
46+import Squeal.PostgreSQL.Schema
47+
48+-- $setup
49+-- >>> import Squeal.PostgreSQL
50+
51+-- | >>> printSQL currentDate
52+-- CURRENT_DATE
53+currentDate :: Expr (null 'PGdate)
54+currentDate = UnsafeExpression "CURRENT_DATE"
55+
56+-- | >>> printSQL currentTime
57+-- CURRENT_TIME
58+currentTime :: Expr (null 'PGtimetz)
59+currentTime = UnsafeExpression "CURRENT_TIME"
60+
61+-- | >>> printSQL currentTimestamp
62+-- CURRENT_TIMESTAMP
63+currentTimestamp :: Expr (null 'PGtimestamptz)
64+currentTimestamp = UnsafeExpression "CURRENT_TIMESTAMP"
65+
66+-- | >>> printSQL localTime
67+-- LOCALTIME
68+localTime :: Expr (null 'PGtime)
69+localTime = UnsafeExpression "LOCALTIME"
70+
71+-- | >>> printSQL localTimestamp
72+-- LOCALTIMESTAMP
73+localTimestamp :: Expr (null 'PGtimestamp)
74+localTimestamp = UnsafeExpression "LOCALTIMESTAMP"
75+
76+-- | Current date and time (equivalent to `currentTimestamp`)
77+--
78+-- >>> printSQL now
79+-- now()
80+now :: Expr (null 'PGtimestamptz)
81+now = UnsafeExpression "now()"
82+
83+{-|
84+Create date from year, month and day fields
85+
86+>>> printSQL (makeDate (1984 :* 7 *: 3))
87+make_date(1984, 7, 3)
88+-}
89+makeDate :: '[ null 'PGint4, null 'PGint4, null 'PGint4 ] ---> null 'PGdate
90+makeDate = unsafeFunctionN "make_date"
91+
92+{-|
93+Create time from hour, minute and seconds fields
94+
95+>>> printSQL (makeTime (8 :* 15 *: 23.5))
96+make_time(8, 15, 23.5)
97+-}
98+makeTime :: '[ null 'PGint4, null 'PGint4, null 'PGfloat8 ] ---> null 'PGtime
99+makeTime = unsafeFunctionN "make_time"
100+
101+{-|
102+Create timestamp from year, month, day, hour, minute and seconds fields
103+
104+>>> printSQL (makeTimestamp (2013 :* 7 :* 15 :* 8 :* 15 *: 23.5))
105+make_timestamp(2013, 7, 15, 8, 15, 23.5)
106+-}
107+makeTimestamp ::
108+ '[ null 'PGint4, null 'PGint4, null 'PGint4
109+ , null 'PGint4, null 'PGint4, null 'PGfloat8 ] ---> null 'PGtimestamp
110+makeTimestamp = unsafeFunctionN "make_timestamp"
111+
112+{-|
113+Create timestamp with time zone from
114+year, month, day, hour, minute and seconds fields;
115+the current time zone is used
116+
117+>>> printSQL (makeTimestamptz (2013 :* 7 :* 15 :* 8 :* 15 *: 23.5))
118+make_timestamptz(2013, 7, 15, 8, 15, 23.5)
119+-}
120+makeTimestamptz ::
121+ '[ null 'PGint4, null 'PGint4, null 'PGint4
122+ , null 'PGint4, null 'PGint4, null 'PGfloat8 ] ---> null 'PGtimestamptz
123+makeTimestamptz = unsafeFunctionN "make_timestamptz"
124+
125+{-|
126+Affine space operations on time types.
127+-}
128+class TimeOp time diff | time -> diff where
129+ {-|
130+ >>> printSQL (makeDate (1984 :* 7 *: 3) !+ 365)
131+ (make_date(1984, 7, 3) + 365)
132+ -}
133+ (!+) :: Operator (null time) (null diff) (null time)
134+ (!+) = unsafeBinaryOp "+"
135+ {-|
136+ >>> printSQL (365 +! makeDate (1984 :* 7 *: 3))
137+ (365 + make_date(1984, 7, 3))
138+ -}
139+ (+!) :: Operator (null diff) (null time) (null time)
140+ (+!) = unsafeBinaryOp "+"
141+ {-|
142+ >>> printSQL (makeDate (1984 :* 7 *: 3) !- 365)
143+ (make_date(1984, 7, 3) - 365)
144+ -}
145+ (!-) :: Operator (null time) (null diff) (null time)
146+ (!-) = unsafeBinaryOp "-"
147+ {-|
148+ >>> printSQL (makeDate (1984 :* 7 *: 3) !-! currentDate)
149+ (make_date(1984, 7, 3) - CURRENT_DATE)
150+ -}
151+ (!-!) :: Operator (null time) (null time) (null diff)
152+ (!-!) = unsafeBinaryOp "-"
153+instance TimeOp 'PGtimestamp 'PGinterval
154+instance TimeOp 'PGtimestamptz 'PGinterval
155+instance TimeOp 'PGtime 'PGinterval
156+instance TimeOp 'PGtimetz 'PGinterval
157+instance TimeOp 'PGinterval 'PGinterval
158+instance TimeOp 'PGdate 'PGint4
159+infixl 6 !+
160+infixl 6 +!
161+infixl 6 !-
162+infixl 6 !-!
163+
164+-- | A `TimeUnit` to use in `interval_` construction.
165+data TimeUnit
166+ = Years | Months | Weeks | Days
167+ | Hours | Minutes | Seconds
168+ | Microseconds | Milliseconds
169+ | Decades | Centuries | Millennia
170+ deriving (Eq, Ord, Show, Read, Enum, GHC.Generic)
171+instance SOP.Generic TimeUnit
172+instance SOP.HasDatatypeInfo TimeUnit
173+instance RenderSQL TimeUnit where
174+ renderSQL = \case
175+ Years -> "years"
176+ Months -> "months"
177+ Weeks -> "weeks"
178+ Days -> "days"
179+ Hours -> "hours"
180+ Minutes -> "minutes"
181+ Seconds -> "seconds"
182+ Microseconds -> "microseconds"
183+ Milliseconds -> "milliseconds"
184+ Decades -> "decades"
185+ Centuries -> "centuries"
186+ Millennia -> "millennia"
187+
188+-- | >>> printSQL $ interval_ 7 Days
189+-- (INTERVAL '7.0 days')
190+interval_ :: Double -> TimeUnit -> Expr (null 'PGinterval)
191+interval_ num unit = UnsafeExpression . parenthesized $ "INTERVAL" <+>
192+ "'" <> fromString (show num) <+> renderSQL unit <> "'"
squeal-postgresql/src/Squeal/PostgreSQL/Expression/Type.hsnew file+446
@@ -0,0 +1,446 @@
1+{-|
2+Module: Squeal.PostgreSQL.Expression
3+Description: Type expressions
4+Copyright: (c) Eitan Chatav, 2019
5+Maintainer: eitan@morphism.tech
6+Stability: experimental
7+
8+Type expressions.
9+-}
10+
11+{-# LANGUAGE
12+ AllowAmbiguousTypes
13+ , DataKinds
14+ , DeriveGeneric
15+ , FlexibleContexts
16+ , FlexibleInstances
17+ , GADTs
18+ , GeneralizedNewtypeDeriving
19+ , KindSignatures
20+ , MultiParamTypeClasses
21+ , OverloadedStrings
22+ , RankNTypes
23+ , ScopedTypeVariables
24+ , TypeApplications
25+ , TypeOperators
26+ , UndecidableInstances
27+#-}
28+
29+module Squeal.PostgreSQL.Expression.Type
30+ ( -- * type casting
31+ cast
32+ , astype
33+ , inferredtype
34+ -- * type expressions
35+ , TypeExpression (..)
36+ , typedef
37+ , typetable
38+ , typeview
39+ , bool
40+ , int2
41+ , smallint
42+ , int4
43+ , int
44+ , integer
45+ , int8
46+ , bigint
47+ , numeric
48+ , float4
49+ , real
50+ , float8
51+ , doublePrecision
52+ , money
53+ , text
54+ , char
55+ , character
56+ , varchar
57+ , characterVarying
58+ , bytea
59+ , timestamp
60+ , timestampWithTimeZone
61+ , timestamptz
62+ , date
63+ , time
64+ , timeWithTimeZone
65+ , timetz
66+ , interval
67+ , uuid
68+ , inet
69+ , json
70+ , jsonb
71+ , vararray
72+ , fixarray
73+ , tsvector
74+ , tsquery
75+ , oid
76+ , int4range
77+ , int8range
78+ , numrange
79+ , tsrange
80+ , tstzrange
81+ , daterange
82+ -- * column type definitions
83+ , ColumnTypeExpression (..)
84+ , nullable
85+ , notNullable
86+ , default_
87+ , serial2
88+ , smallserial
89+ , serial4
90+ , serial
91+ , serial8
92+ , bigserial
93+ , hask
94+ -- * type inference
95+ , PGTyped (..)
96+ , PGNullityTyped (..)
97+ , FieldTyped (..)
98+ ) where
99+
100+import Control.DeepSeq
101+import Data.ByteString
102+import Data.String
103+import GHC.TypeLits
104+
105+import qualified Data.ByteString as ByteString
106+import qualified GHC.Generics as GHC
107+import qualified Generics.SOP as SOP
108+
109+import Squeal.PostgreSQL.Alias
110+import Squeal.PostgreSQL.Expression
111+import Squeal.PostgreSQL.PG
112+import Squeal.PostgreSQL.Render
113+import Squeal.PostgreSQL.Schema
114+
115+-- $setup
116+-- >>> import Squeal.PostgreSQL
117+
118+-- When a `cast` is applied to an `Expression` of a known type, it
119+-- represents a run-time type conversion. The cast will succeed only if a
120+-- suitable type conversion operation has been defined.
121+--
122+-- | >>> printSQL $ true & cast int4
123+-- (TRUE :: int4)
124+cast
125+ :: TypeExpression schemas ty1
126+ -- ^ type to cast as
127+ -> Expression outer commons grp schemas params from ty0
128+ -- ^ value to convert
129+ -> Expression outer commons grp schemas params from ty1
130+cast ty x = UnsafeExpression $ parenthesized $
131+ renderSQL x <+> "::" <+> renderSQL ty
132+
133+-- | A safe version of `cast` which just matches a value with its type.
134+--
135+-- >>> printSQL (1 & astype int)
136+-- (1 :: int)
137+astype
138+ :: TypeExpression schemas ty
139+ -- ^ type to specify as
140+ -> Expression outer commons grp schemas params from ty
141+ -- ^ value
142+ -> Expression outer commons grp schemas params from ty
143+astype = cast
144+
145+-- | `inferredtype` will add a type annotation to an `Expression`
146+-- which can be useful for fixing the storage type of a value.
147+--
148+-- >>> printSQL (inferredtype true)
149+-- (TRUE :: bool)
150+inferredtype
151+ :: PGTyped schemas ty
152+ => Expression outer common grp schemas params from ty
153+ -- ^ value
154+ -> Expression outer common grp schemas params from ty
155+inferredtype = astype pgtype
156+
157+{-----------------------------------------
158+type expressions
159+-----------------------------------------}
160+
161+-- | `TypeExpression`s are used in `cast`s and
162+-- `Squeal.PostgreSQL.Definition.createTable` commands.
163+newtype TypeExpression (schemas :: SchemasType) (ty :: NullityType)
164+ = UnsafeTypeExpression { renderTypeExpression :: ByteString }
165+ deriving (GHC.Generic,Show,Eq,Ord,NFData)
166+instance RenderSQL (TypeExpression schemas ty) where
167+ renderSQL = renderTypeExpression
168+
169+-- | The enum or composite type in a `Typedef` can be expressed by its alias.
170+typedef
171+ :: (Has sch schemas schema, Has td schema ('Typedef ty))
172+ => QualifiedAlias sch td
173+ -- ^ type alias
174+ -> TypeExpression schemas (null ty)
175+typedef = UnsafeTypeExpression . renderSQL
176+
177+-- | The composite type corresponding to a `Table` definition can be expressed
178+-- by its alias.
179+typetable
180+ :: (Has sch schemas schema, Has tab schema ('Table table))
181+ => QualifiedAlias sch tab
182+ -- ^ table alias
183+ -> TypeExpression schemas (null ('PGcomposite (TableToRow table)))
184+typetable = UnsafeTypeExpression . renderSQL
185+
186+-- | The composite type corresponding to a `View` definition can be expressed
187+-- by its alias.
188+typeview
189+ :: (Has sch schemas schema, Has vw schema ('View view))
190+ => QualifiedAlias sch vw
191+ -- ^ view alias
192+ -> TypeExpression schemas (null ('PGcomposite view))
193+typeview = UnsafeTypeExpression . renderSQL
194+
195+-- | logical Boolean (true/false)
196+bool :: TypeExpression schemas (null 'PGbool)
197+bool = UnsafeTypeExpression "bool"
198+-- | signed two-byte integer
199+int2, smallint :: TypeExpression schemas (null 'PGint2)
200+int2 = UnsafeTypeExpression "int2"
201+smallint = UnsafeTypeExpression "smallint"
202+-- | signed four-byte integer
203+int4, int, integer :: TypeExpression schemas (null 'PGint4)
204+int4 = UnsafeTypeExpression "int4"
205+int = UnsafeTypeExpression "int"
206+integer = UnsafeTypeExpression "integer"
207+-- | signed eight-byte integer
208+int8, bigint :: TypeExpression schemas (null 'PGint8)
209+int8 = UnsafeTypeExpression "int8"
210+bigint = UnsafeTypeExpression "bigint"
211+-- | arbitrary precision numeric type
212+numeric :: TypeExpression schemas (null 'PGnumeric)
213+numeric = UnsafeTypeExpression "numeric"
214+-- | single precision floating-point number (4 bytes)
215+float4, real :: TypeExpression schemas (null 'PGfloat4)
216+float4 = UnsafeTypeExpression "float4"
217+real = UnsafeTypeExpression "real"
218+-- | double precision floating-point number (8 bytes)
219+float8, doublePrecision :: TypeExpression schemas (null 'PGfloat8)
220+float8 = UnsafeTypeExpression "float8"
221+doublePrecision = UnsafeTypeExpression "double precision"
222+-- | currency amount
223+money :: TypeExpression schema (null 'PGmoney)
224+money = UnsafeTypeExpression "money"
225+-- | variable-length character string
226+text :: TypeExpression schemas (null 'PGtext)
227+text = UnsafeTypeExpression "text"
228+-- | fixed-length character string
229+char, character
230+ :: forall n schemas null. (KnownNat n, 1 <= n)
231+ => TypeExpression schemas (null ('PGchar n))
232+char = UnsafeTypeExpression $ "char(" <> renderNat @n <> ")"
233+character = UnsafeTypeExpression $ "character(" <> renderNat @n <> ")"
234+-- | variable-length character string
235+varchar, characterVarying
236+ :: forall n schemas null. (KnownNat n, 1 <= n)
237+ => TypeExpression schemas (null ('PGvarchar n))
238+varchar = UnsafeTypeExpression $ "varchar(" <> renderNat @n <> ")"
239+characterVarying = UnsafeTypeExpression $
240+ "character varying(" <> renderNat @n <> ")"
241+-- | binary data ("byte array")
242+bytea :: TypeExpression schemas (null 'PGbytea)
243+bytea = UnsafeTypeExpression "bytea"
244+-- | date and time (no time zone)
245+timestamp :: TypeExpression schemas (null 'PGtimestamp)
246+timestamp = UnsafeTypeExpression "timestamp"
247+-- | date and time, including time zone
248+timestampWithTimeZone, timestamptz :: TypeExpression schemas (null 'PGtimestamptz)
249+timestampWithTimeZone = UnsafeTypeExpression "timestamp with time zone"
250+timestamptz = UnsafeTypeExpression "timestamptz"
251+-- | calendar date (year, month, day)
252+date :: TypeExpression schemas (null 'PGdate)
253+date = UnsafeTypeExpression "date"
254+-- | time of day (no time zone)
255+time :: TypeExpression schemas (null 'PGtime)
256+time = UnsafeTypeExpression "time"
257+-- | time of day, including time zone
258+timeWithTimeZone, timetz :: TypeExpression schemas (null 'PGtimetz)
259+timeWithTimeZone = UnsafeTypeExpression "time with time zone"
260+timetz = UnsafeTypeExpression "timetz"
261+-- | time span
262+interval :: TypeExpression schemas (null 'PGinterval)
263+interval = UnsafeTypeExpression "interval"
264+-- | universally unique identifier
265+uuid :: TypeExpression schemas (null 'PGuuid)
266+uuid = UnsafeTypeExpression "uuid"
267+-- | IPv4 or IPv6 host address
268+inet :: TypeExpression schemas (null 'PGinet)
269+inet = UnsafeTypeExpression "inet"
270+-- | textual JSON data
271+json :: TypeExpression schemas (null 'PGjson)
272+json = UnsafeTypeExpression "json"
273+-- | binary JSON data, decomposed
274+jsonb :: TypeExpression schemas (null 'PGjsonb)
275+jsonb = UnsafeTypeExpression "jsonb"
276+-- | variable length array
277+vararray
278+ :: TypeExpression schemas pg
279+ -> TypeExpression schemas (null ('PGvararray pg))
280+vararray ty = UnsafeTypeExpression $ renderSQL ty <> "[]"
281+-- | fixed length array
282+--
283+-- >>> renderSQL (fixarray @'[2] json)
284+-- "json[2]"
285+fixarray
286+ :: forall dims schemas null pg. SOP.All KnownNat dims
287+ => TypeExpression schemas pg
288+ -> TypeExpression schemas (null ('PGfixarray dims pg))
289+fixarray ty = UnsafeTypeExpression $
290+ renderSQL ty <> renderDims @dims
291+ where
292+ renderDims :: forall ns. SOP.All KnownNat ns => ByteString
293+ renderDims =
294+ ("[" <>)
295+ . (<> "]")
296+ . ByteString.intercalate "]["
297+ . SOP.hcollapse
298+ $ SOP.hcmap (SOP.Proxy @KnownNat)
299+ (K . fromString . show . natVal)
300+ (SOP.hpure SOP.Proxy :: SOP.NP SOP.Proxy ns)
301+-- | text search query
302+tsvector :: TypeExpression schemas (null 'PGtsvector)
303+tsvector = UnsafeTypeExpression "tsvector"
304+-- | text search document
305+tsquery :: TypeExpression schemas (null 'PGtsquery)
306+tsquery = UnsafeTypeExpression "tsquery"
307+-- | Object identifiers (OIDs) are used internally by PostgreSQL
308+-- as primary keys for various system tables.
309+oid :: TypeExpression schemas (null 'PGoid)
310+oid = UnsafeTypeExpression "oid"
311+-- | Range of integer
312+int4range :: TypeExpression schemas (null ('PGrange 'PGint4))
313+int4range = UnsafeTypeExpression "int4range"
314+-- | Range of bigint
315+int8range :: TypeExpression schemas (null ('PGrange 'PGint8))
316+int8range = UnsafeTypeExpression "int8range"
317+-- | Range of numeric
318+numrange :: TypeExpression schemas (null ('PGrange 'PGnumeric))
319+numrange = UnsafeTypeExpression "numrange"
320+-- | Range of timestamp without time zone
321+tsrange :: TypeExpression schemas (null ('PGrange 'PGtimestamp))
322+tsrange = UnsafeTypeExpression "tsrange"
323+-- | Range of timestamp with time zone
324+tstzrange :: TypeExpression schemas (null ('PGrange 'PGtimestamptz))
325+tstzrange = UnsafeTypeExpression "tstzrange"
326+-- | Range of date
327+daterange :: TypeExpression schemas (null ('PGrange 'PGdate))
328+daterange = UnsafeTypeExpression "daterange"
329+
330+-- | `pgtype` is a demoted version of a `PGType`
331+class PGTyped schemas (ty :: NullityType) where
332+ pgtype :: TypeExpression schemas ty
333+instance PGTyped schemas (null 'PGbool) where pgtype = bool
334+instance PGTyped schemas (null 'PGint2) where pgtype = int2
335+instance PGTyped schemas (null 'PGint4) where pgtype = int4
336+instance PGTyped schemas (null 'PGint8) where pgtype = int8
337+instance PGTyped schemas (null 'PGnumeric) where pgtype = numeric
338+instance PGTyped schemas (null 'PGfloat4) where pgtype = float4
339+instance PGTyped schemas (null 'PGfloat8) where pgtype = float8
340+instance PGTyped schemas (null 'PGmoney) where pgtype = money
341+instance PGTyped schemas (null 'PGtext) where pgtype = text
342+instance (KnownNat n, 1 <= n)
343+ => PGTyped schemas (null ('PGchar n)) where pgtype = char @n
344+instance (KnownNat n, 1 <= n)
345+ => PGTyped schemas (null ('PGvarchar n)) where pgtype = varchar @n
346+instance PGTyped schemas (null 'PGbytea) where pgtype = bytea
347+instance PGTyped schemas (null 'PGtimestamp) where pgtype = timestamp
348+instance PGTyped schemas (null 'PGtimestamptz) where pgtype = timestampWithTimeZone
349+instance PGTyped schemas (null 'PGdate) where pgtype = date
350+instance PGTyped schemas (null 'PGtime) where pgtype = time
351+instance PGTyped schemas (null 'PGtimetz) where pgtype = timeWithTimeZone
352+instance PGTyped schemas (null 'PGinterval) where pgtype = interval
353+instance PGTyped schemas (null 'PGuuid) where pgtype = uuid
354+instance PGTyped schemas (null 'PGjson) where pgtype = json
355+instance PGTyped schemas (null 'PGjsonb) where pgtype = jsonb
356+instance PGTyped schemas ty
357+ => PGTyped schemas (null ('PGvararray ty)) where
358+ pgtype = vararray (pgtype @schemas @ty)
359+instance (SOP.All KnownNat dims, PGTyped schemas ty)
360+ => PGTyped schemas (null ('PGfixarray dims ty)) where
361+ pgtype = fixarray @dims (pgtype @schemas @ty)
362+instance PGTyped schemas (null 'PGtsvector) where pgtype = tsvector
363+instance PGTyped schemas (null 'PGtsquery) where pgtype = tsquery
364+instance PGTyped schemas (null 'PGoid) where pgtype = oid
365+instance PGTyped schemas (null ('PGrange 'PGint4)) where pgtype = int4range
366+instance PGTyped schemas (null ('PGrange 'PGint8)) where pgtype = int8range
367+instance PGTyped schemas (null ('PGrange 'PGnumeric)) where pgtype = numrange
368+instance PGTyped schemas (null ('PGrange 'PGtimestamp)) where pgtype = tsrange
369+instance PGTyped schemas (null ('PGrange 'PGtimestamptz)) where pgtype = tstzrange
370+instance PGTyped schemas (null ('PGrange 'PGdate)) where pgtype = daterange
371+
372+-- | Lift `PGTyped` to a field
373+class FieldTyped schemas ty where
374+ fieldtype :: Aliased (TypeExpression schemas) ty
375+instance (KnownSymbol alias, PGTyped schemas ty)
376+ => FieldTyped schemas (alias ::: ty) where
377+ fieldtype = pgtype `As` Alias
378+
379+-- | `ColumnTypeExpression`s are used in `createTable` commands.
380+newtype ColumnTypeExpression (schemas :: SchemasType) (ty :: ColumnType)
381+ = UnsafeColumnTypeExpression { renderColumnTypeExpression :: ByteString }
382+ deriving (GHC.Generic,Show,Eq,Ord,NFData)
383+instance RenderSQL (ColumnTypeExpression schemas ty) where
384+ renderSQL = renderColumnTypeExpression
385+
386+-- | used in `createTable` commands as a column constraint to note that
387+-- @NULL@ may be present in a column
388+nullable
389+ :: TypeExpression schemas (nullity ty)
390+ -> ColumnTypeExpression schemas ('NoDef :=> 'Null ty)
391+nullable ty = UnsafeColumnTypeExpression $ renderSQL ty <+> "NULL"
392+
393+-- | used in `createTable` commands as a column constraint to ensure
394+-- @NULL@ is not present in a column
395+notNullable
396+ :: TypeExpression schemas (nullity ty)
397+ -> ColumnTypeExpression schemas ('NoDef :=> 'NotNull ty)
398+notNullable ty = UnsafeColumnTypeExpression $ renderSQL ty <+> "NOT NULL"
399+
400+-- | used in `createTable` commands as a column constraint to give a default
401+default_
402+ :: Expression '[] '[] 'Ungrouped schemas '[] '[] ty
403+ -> ColumnTypeExpression schemas ('NoDef :=> ty)
404+ -> ColumnTypeExpression schemas ('Def :=> ty)
405+default_ x ty = UnsafeColumnTypeExpression $
406+ renderSQL ty <+> "DEFAULT" <+> renderExpression x
407+
408+-- | not a true type, but merely a notational convenience for creating
409+-- unique identifier columns with type `PGint2`
410+serial2, smallserial
411+ :: ColumnTypeExpression schemas ('Def :=> 'NotNull 'PGint2)
412+serial2 = UnsafeColumnTypeExpression "serial2"
413+smallserial = UnsafeColumnTypeExpression "smallserial"
414+-- | not a true type, but merely a notational convenience for creating
415+-- unique identifier columns with type `PGint4`
416+serial4, serial
417+ :: ColumnTypeExpression schemas ('Def :=> 'NotNull 'PGint4)
418+serial4 = UnsafeColumnTypeExpression "serial4"
419+serial = UnsafeColumnTypeExpression "serial"
420+-- | not a true type, but merely a notational convenience for creating
421+-- unique identifier columns with type `PGint8`
422+serial8, bigserial
423+ :: ColumnTypeExpression schemas ('Def :=> 'NotNull 'PGint8)
424+serial8 = UnsafeColumnTypeExpression "serial8"
425+bigserial = UnsafeColumnTypeExpression "bigserial"
426+
427+-- | Like @PGTyped@ but also accounts for nullity.
428+class PGNullityTyped schemas (nullty :: NullityType) where
429+ pgNullityType :: ColumnTypeExpression schemas ('NoDef :=> nullty)
430+
431+instance PGTyped schemas ('Null ty) => PGNullityTyped schemas ('Null ty) where
432+ pgNullityType = nullable (pgtype @_ @('Null ty))
433+
434+instance PGTyped schemas ('NotNull ty) => PGNullityTyped schemas ('NotNull ty) where
435+ pgNullityType = notNullable (pgtype @_ @('NotNull ty))
436+
437+-- | Allow you to specify pg column types in relation to haskell types.
438+-- >>> printSQL $ hask @(Maybe String)
439+-- text NULL
440+--
441+-- >>> printSQL $ hask @Double
442+-- float8 NOT NULL
443+hask
444+ :: forall hask schemas. PGNullityTyped schemas (NullPG hask)
445+ => ColumnTypeExpression schemas ('NoDef :=> NullPG hask)
446+hask = pgNullityType
squeal-postgresql/src/Squeal/PostgreSQL/Expression/Window.hsnew file+284
@@ -0,0 +1,284 @@
1+{-|
2+Module: Squeal.PostgreSQL.Expression.Window
3+Description: Window functions
4+Copyright: (c) Eitan Chatav, 2019
5+Maintainer: eitan@morphism.tech
6+Stability: experimental
7+
8+Window functions and definitions
9+-}
10+
11+{-# LANGUAGE
12+ DataKinds
13+ , DeriveGeneric
14+ , FlexibleContexts
15+ , FlexibleInstances
16+ , GADTs
17+ , GeneralizedNewtypeDeriving
18+ , LambdaCase
19+ , MultiParamTypeClasses
20+ , OverloadedStrings
21+ , RankNTypes
22+ , KindSignatures
23+#-}
24+
25+module Squeal.PostgreSQL.Expression.Window
26+ ( -- * functions
27+ partitionBy
28+ , rank
29+ , rowNumber
30+ , denseRank
31+ , percentRank
32+ , cumeDist
33+ , ntile
34+ , lag
35+ , lead
36+ , firstValue
37+ , lastValue
38+ , nthValue
39+ , unsafeWindowFunction1
40+ , unsafeWindowFunctionN
41+ -- * types
42+ , WindowFunction (..)
43+ , WindowDefinition (..)
44+ , WinFun0
45+ , WinFun1
46+ , WinFunN
47+ ) where
48+
49+import Control.DeepSeq
50+import Data.ByteString
51+
52+import qualified GHC.Generics as GHC
53+import qualified Generics.SOP as SOP
54+
55+import Squeal.PostgreSQL.Alias
56+import Squeal.PostgreSQL.Expression
57+import Squeal.PostgreSQL.Expression.Aggregate
58+import Squeal.PostgreSQL.Expression.Sort
59+import Squeal.PostgreSQL.List
60+import Squeal.PostgreSQL.Render
61+import Squeal.PostgreSQL.Schema
62+
63+instance Aggregate
64+ (Expression outer commons grp schemas params from)
65+ (NP (Expression outer commons grp schemas params from))
66+ (WindowFunction outer commons grp schemas params from) where
67+ countStar = UnsafeWindowFunction "count(*)"
68+ count = unsafeWindowFunction1 "count"
69+ sum_ = unsafeWindowFunction1 "sum"
70+ arrayAgg = unsafeWindowFunction1 "array_agg"
71+ jsonAgg = unsafeWindowFunction1 "json_agg"
72+ jsonbAgg = unsafeWindowFunction1 "jsonb_agg"
73+ bitAnd = unsafeWindowFunction1 "bit_and"
74+ bitOr = unsafeWindowFunction1 "bit_or"
75+ boolAnd = unsafeWindowFunction1 "bool_and"
76+ boolOr = unsafeWindowFunction1 "bool_or"
77+ every = unsafeWindowFunction1 "every"
78+ max_ = unsafeWindowFunction1 "max"
79+ min_ = unsafeWindowFunction1 "min"
80+ avg = unsafeWindowFunction1 "avg"
81+ corr = unsafeWindowFunctionN "corr"
82+ covarPop = unsafeWindowFunctionN "covar_pop"
83+ covarSamp = unsafeWindowFunctionN "covar_samp"
84+ regrAvgX = unsafeWindowFunctionN "regr_avgx"
85+ regrAvgY = unsafeWindowFunctionN "regr_avgy"
86+ regrCount = unsafeWindowFunctionN "regr_count"
87+ regrIntercept = unsafeWindowFunctionN "regr_intercept"
88+ regrR2 = unsafeWindowFunctionN "regr_r2"
89+ regrSlope = unsafeWindowFunctionN "regr_slope"
90+ regrSxx = unsafeWindowFunctionN "regr_sxx"
91+ regrSxy = unsafeWindowFunctionN "regr_sxy"
92+ regrSyy = unsafeWindowFunctionN "regr_syy"
93+ stddev = unsafeWindowFunction1 "stddev"
94+ stddevPop = unsafeWindowFunction1 "stddev_pop"
95+ stddevSamp = unsafeWindowFunction1 "stddev_samp"
96+ variance = unsafeWindowFunction1 "variance"
97+ varPop = unsafeWindowFunction1 "var_pop"
98+ varSamp = unsafeWindowFunction1 "var_samp"
99+
100+-- | A `WindowDefinition` is a set of table rows that are somehow related
101+-- to the current row
102+data WindowDefinition outer commons grp schemas params from where
103+ WindowDefinition
104+ :: SOP.SListI bys
105+ => NP (Expression outer commons grp schemas params from) bys
106+ -- ^ `partitionBy` clause
107+ -> [SortExpression outer commons grp schemas params from]
108+ -- ^ `Squeal.PostgreSQL.Expression.Sort.orderBy` clause
109+ -> WindowDefinition outer commons grp schemas params from
110+
111+instance OrderBy WindowDefinition where
112+ orderBy sortsR (WindowDefinition parts sortsL)
113+ = WindowDefinition parts (sortsL ++ sortsR)
114+
115+instance RenderSQL (WindowDefinition outer commons schemas from grp params) where
116+ renderSQL (WindowDefinition part ord) =
117+ renderPartitionByClause part <> renderOrderByClause ord
118+ where
119+ renderPartitionByClause = \case
120+ Nil -> ""
121+ parts -> "PARTITION" <+> "BY" <+> renderCommaSeparated renderExpression parts
122+ renderOrderByClause = \case
123+ [] -> ""
124+ srts -> " ORDER" <+> "BY"
125+ <+> commaSeparated (renderSQL <$> srts)
126+
127+{- |
128+The `partitionBy` clause within `Squeal.PostgreSQL.Query.Over` divides the rows into groups,
129+or partitions, that share the same values of the `partitionBy` `Expression`(s).
130+For each row, the window function is computed across the rows that fall into
131+the same partition as the current row.
132+-}
133+partitionBy
134+ :: SOP.SListI bys
135+ => NP (Expression outer commons grp schemas params from) bys -- ^ partitions
136+ -> WindowDefinition outer commons grp schemas params from
137+partitionBy bys = WindowDefinition bys []
138+
139+{- |
140+A window function performs a calculation across a set of table rows
141+that are somehow related to the current row. This is comparable to the type
142+of calculation that can be done with an aggregate function.
143+However, window functions do not cause rows to become grouped into a single
144+output row like non-window aggregate calls would.
145+Instead, the rows retain their separate identities.
146+Behind the scenes, the window function is able to access more than
147+just the current row of the query result.
148+-}
149+newtype WindowFunction
150+ (outer :: FromType)
151+ (commons :: FromType)
152+ (grp :: Grouping)
153+ (schemas :: SchemasType)
154+ (params :: [NullityType])
155+ (from :: FromType)
156+ (ty :: NullityType)
157+ = UnsafeWindowFunction { renderWindowFunction :: ByteString }
158+ deriving (GHC.Generic,Show,Eq,Ord,NFData)
159+
160+instance RenderSQL (WindowFunction outer commons grp schemas params from ty) where
161+ renderSQL = renderWindowFunction
162+
163+{- |
164+A @RankNType@ for window functions with no arguments.
165+-}
166+type WinFun0 x
167+ = forall outer commons grp schemas params from
168+ . WindowFunction outer commons grp schemas params from x
169+ -- ^ cannot reference aliases
170+
171+{- |
172+A @RankNType@ for window functions with 1 argument.
173+-}
174+type WinFun1 x y
175+ = forall outer commons grp schemas params from
176+ . Expression outer commons grp schemas params from x
177+ -- ^ input
178+ -> WindowFunction outer commons grp schemas params from y
179+ -- ^ output
180+
181+{- | A @RankNType@ for window functions with a fixed-length
182+list of heterogeneous arguments.
183+Use the `*:` operator to end your argument lists.
184+-}
185+type WinFunN xs y
186+ = forall outer commons grp schemas params from
187+ . NP (Expression outer commons grp schemas params from) xs
188+ -- ^ inputs
189+ -> WindowFunction outer commons grp schemas params from y
190+ -- ^ output
191+
192+-- | escape hatch for defining window functions
193+unsafeWindowFunction1 :: ByteString -> WinFun1 x y
194+unsafeWindowFunction1 fun x
195+ = UnsafeWindowFunction $ fun <> parenthesized (renderSQL x)
196+
197+-- | escape hatch for defining multi-argument window functions
198+unsafeWindowFunctionN :: SOP.SListI xs => ByteString -> WinFunN xs y
199+unsafeWindowFunctionN fun xs = UnsafeWindowFunction $ fun <>
200+ parenthesized (renderCommaSeparated renderSQL xs)
201+
202+{- | rank of the current row with gaps; same as `rowNumber` of its first peer
203+
204+>>> printSQL rank
205+rank()
206+-}
207+rank :: WinFun0 ('NotNull 'PGint8)
208+rank = UnsafeWindowFunction "rank()"
209+
210+{- | number of the current row within its partition, counting from 1
211+
212+>>> printSQL rowNumber
213+row_number()
214+-}
215+rowNumber :: WinFun0 ('NotNull 'PGint8)
216+rowNumber = UnsafeWindowFunction "row_number()"
217+
218+{- | rank of the current row without gaps; this function counts peer groups
219+
220+>>> printSQL denseRank
221+dense_rank()
222+-}
223+denseRank :: WinFun0 ('NotNull 'PGint8)
224+denseRank = UnsafeWindowFunction "dense_rank()"
225+
226+{- | relative rank of the current row: (rank - 1) / (total partition rows - 1)
227+
228+>>> printSQL percentRank
229+percent_rank()
230+-}
231+percentRank :: WinFun0 ('NotNull 'PGfloat8)
232+percentRank = UnsafeWindowFunction "percent_rank()"
233+
234+{- | cumulative distribution: (number of partition rows
235+preceding or peer with current row) / total partition rows
236+
237+>>> printSQL cumeDist
238+cume_dist()
239+-}
240+cumeDist :: WinFun0 ('NotNull 'PGfloat8)
241+cumeDist = UnsafeWindowFunction "cume_dist()"
242+
243+{- | integer ranging from 1 to the argument value,
244+dividing the partition as equally as possible
245+
246+>>> printSQL $ ntile 5
247+ntile(5)
248+-}
249+ntile :: WinFun1 ('NotNull 'PGint4) ('NotNull 'PGint4)
250+ntile = unsafeWindowFunction1 "ntile"
251+
252+{- | returns value evaluated at the row that is offset rows before the current
253+row within the partition; if there is no such row, instead return default
254+(which must be of the same type as value). Both offset and default are
255+evaluated with respect to the current row.
256+-}
257+lag :: WinFunN '[ty, 'NotNull 'PGint4, ty] ty
258+lag = unsafeWindowFunctionN "lag"
259+
260+{- | returns value evaluated at the row that is offset rows after the current
261+row within the partition; if there is no such row, instead return default
262+(which must be of the same type as value). Both offset and default are
263+evaluated with respect to the current row.
264+-}
265+lead :: WinFunN '[ty, 'NotNull 'PGint4, ty] ty
266+lead = unsafeWindowFunctionN "lead"
267+
268+{- | returns value evaluated at the row that is the
269+first row of the window frame
270+-}
271+firstValue :: WinFun1 ty ty
272+firstValue = unsafeWindowFunction1 "first_value"
273+
274+{- | returns value evaluated at the row that is the
275+last row of the window frame
276+-}
277+lastValue :: WinFun1 ty ty
278+lastValue = unsafeWindowFunction1 "last_value"
279+
280+{- | returns value evaluated at the row that is the nth
281+row of the window frame (counting from 1); null if no such row
282+-}
283+nthValue :: WinFunN '[null ty, 'NotNull 'PGint4] ('Null ty)
284+nthValue = unsafeWindowFunctionN "nth_value"
squeal-postgresql/src/Squeal/PostgreSQL/List.hsnew file+112
@@ -0,0 +1,112 @@
1+{-|
2+Module: Squeal.PostgreSQL.List
3+Description: List related types and functions
4+Copyright: (c) Eitan Chatav, 2019
5+Maintainer: eitan@morphism.tech
6+Stability: experimental
7+
8+Haskell singly-linked lists are very powerful. This module
9+provides functionality for type-level lists, heterogeneous
10+lists and type aligned lists.
11+-}
12+
13+{-# LANGUAGE
14+ DataKinds
15+ , FlexibleContexts
16+ , GADTs
17+ , LambdaCase
18+ , MultiParamTypeClasses
19+ , OverloadedStrings
20+ , PolyKinds
21+ , QuantifiedConstraints
22+ , RankNTypes
23+ , ScopedTypeVariables
24+ , TypeApplications
25+ , TypeFamilies
26+ , TypeOperators
27+ , UndecidableInstances
28+#-}
29+
30+module Squeal.PostgreSQL.List
31+ ( SOP.NP (..)
32+ , (*:)
33+ , Join
34+ , disjoin
35+ , Additional (..)
36+ , Path (..)
37+ , CFunctor (..)
38+ , CFoldable (..)
39+ , CFree (..)
40+ , Elem
41+ , In
42+ , Length
43+ ) where
44+
45+import Control.Category.Free
46+import Data.Function ((&))
47+import Data.Kind
48+import Data.Type.Bool
49+import GHC.TypeLits
50+
51+import Generics.SOP as SOP
52+
53+-- | `Join` is simply promoted `++` and is used in @JOIN@s in
54+-- `Squeal.PostgreSQL.Query.FromClause`s.
55+type family Join xs ys where
56+ Join '[] ys = ys
57+ Join (x ': xs) ys = x ': Join xs ys
58+
59+-- | `disjoin` is a utility function for splitting an `NP` list into pieces.
60+disjoin
61+ :: forall xs ys expr. SListI xs
62+ => NP expr (Join xs ys)
63+ -> (NP expr xs, NP expr ys)
64+disjoin = case sList @xs of
65+ SNil -> \ys -> (Nil, ys)
66+ SCons -> \(x :* xsys) ->
67+ case disjoin xsys of (xs,ys) -> (x :* xs, ys)
68+
69+-- | The `Additional` class is for appending
70+-- type-level list parameterized constructors such as `NP`,
71+-- `Squeal.PostgreSQL.Query.Selection`, and `Squeal.PostgreSQL.Query.FromClause`.
72+class Additional expr where
73+ also :: expr ys -> expr xs -> expr (Join xs ys)
74+instance Additional (NP expr) where
75+ also ys = \case
76+ Nil -> ys
77+ x :* xs -> x :* (xs & also ys)
78+
79+-- | A useful operator for ending an `NP` list of length at least 2 without `Nil`.
80+(*:) :: f x -> f y -> NP f '[x,y]
81+x *: y = x :* y :* Nil
82+infixl 9 *:
83+
84+-- | @Elem@ is a promoted `Data.List.elem`.
85+type family Elem x xs where
86+ Elem x '[] = 'False
87+ Elem x (x ': _) = 'True
88+ Elem x (_ ': x ': _) = 'True
89+ Elem x (_ ': _ ': x ': _) = 'True
90+ Elem x (_ ': _ ': _ ': x ': _) = 'True
91+ Elem x (_ ': _ ': _ ': _ ': x ': _) = 'True
92+ Elem x (_ ': _ ': _ ': _ ': _ ': x ': _) = 'True
93+ Elem x (_ ': xs) = Elem x xs
94+
95+-- | @In x xs@ is a constraint that proves that @x@ is in @xs@.
96+type family In x xs :: Constraint where
97+ In x xs = If (Elem x xs) (() :: Constraint)
98+ (TypeError ('ShowType x ':<>: 'Text " is not in " ':<>: 'ShowType xs))
99+
100+{- | Calculate the `Length` of a type level list
101+
102+>>> :kind! Length '[Char,String,Bool,Double]
103+Length '[Char,String,Bool,Double] :: Nat
104+= 4
105+-}
106+type family Length (xs :: [k]) :: Nat where
107+ Length (_ ': _ ': _ ': _ ': _ : xs) = 5 + Length xs
108+ Length (_ ': _ ': _ ': _ : xs) = 4 + Length xs
109+ Length (_ ': _ ': _ : xs) = 3 + Length xs
110+ Length (_ ': _ : xs) = 2 + Length xs
111+ Length (_ : xs) = 1 + Length xs
112+ Length '[] = 0
squeal-postgresql/src/Squeal/PostgreSQL/Manipulation.hs+170−177
@@ -18,6 +18,7 @@ Squeal data manipulation language.
18 , MultiParamTypeClasses
18 , MultiParamTypeClasses
19 , OverloadedStrings
19 , OverloadedStrings
20 , PatternSynonyms
20 , PatternSynonyms
21+ , QuantifiedConstraints
21 , RankNTypes
22 , RankNTypes
22 , ScopedTypeVariables
23 , ScopedTypeVariables
23 , TypeApplications
24 , TypeApplications
@@ -29,19 +30,9 @@ Squeal data manipulation language.
29
30
30module Squeal.PostgreSQL.Manipulation
31module Squeal.PostgreSQL.Manipulation
31 ( -- * Manipulation
32 ( -- * Manipulation
33+ Manipulation_
32− Manipulation (..)
34+ , Manipulation (..)
33− , Manipulation_
34 , queryStatement
35 , queryStatement
35− , QueryClause (..)
36− , pattern Values_
37− , DefaultAliasable (..)
38− , ColumnExpression (..)
39− , ReturningClause (..)
40− , pattern Returning_
41− , ConflictClause (..)
42− , ConflictTarget (..)
43− , ConflictAction (..)
44− , UsingClause (..)
45 -- * Insert
36 -- * Insert
46 , insertInto
37 , insertInto
47 , insertInto_
38 , insertInto_
@@ -51,37 +42,95 @@ module Squeal.PostgreSQL.Manipulation
51 -- * Delete
42 -- * Delete
52 , deleteFrom
43 , deleteFrom
53 , deleteFrom_
44 , deleteFrom_
54− , also
45+ -- * Clauses
46+ , Optional (..)
47+ , QueryClause (..)
48+ , pattern Values_
49+ , ReturningClause (..)
50+ , pattern Returning_
51+ , ConflictClause (..)
52+ , ConflictTarget (..)
53+ , ConflictAction (..)
54+ , UsingClause (..)
55 ) where
55 ) where
56
56
57import Control.DeepSeq
57import Control.DeepSeq
58import Data.ByteString hiding (foldr)
58import Data.ByteString hiding (foldr)
59import Data.Kind (Type)
59import Data.Kind (Type)
60−import GHC.TypeLits (KnownSymbol)
61
60
62import qualified Generics.SOP as SOP
61import qualified Generics.SOP as SOP
63import qualified GHC.Generics as GHC
62import qualified GHC.Generics as GHC
64
63
65−import Squeal.PostgreSQL.Binary
64+import Squeal.PostgreSQL.Alias
66import Squeal.PostgreSQL.Expression
65import Squeal.PostgreSQL.Expression
66+import Squeal.PostgreSQL.Expression.Logic
67+import Squeal.PostgreSQL.List
68+import Squeal.PostgreSQL.PG
67import Squeal.PostgreSQL.Render
69import Squeal.PostgreSQL.Render
68import Squeal.PostgreSQL.Query
70import Squeal.PostgreSQL.Query
69import Squeal.PostgreSQL.Schema
71import Squeal.PostgreSQL.Schema
70
72
73+-- $setup
74+-- >>> import Squeal.PostgreSQL
75+-- >>> import Data.Int
76+-- >>> import Data.Time
77+
71{- |
78{- |
72A `Manipulation` is a statement which may modify data in the database,
79A `Manipulation` is a statement which may modify data in the database,
73but does not alter its schemas. Examples are inserts, updates and deletes.
80but does not alter its schemas. Examples are inserts, updates and deletes.
74A `Query` is also considered a `Manipulation` even though it does not modify data.
81A `Query` is also considered a `Manipulation` even though it does not modify data.
75
82
83+The general `Manipulation` type is parameterized by
84+
85+* @commons :: FromType@ - scope for all `common` table expressions,
86+* @schemas :: SchemasType@ - scope for all `table`s and `view`s,
87+* @params :: [NullityType]@ - scope for all `Squeal.Expression.Parameter.parameter`s,
88+* @row :: RowType@ - return type of the `Query`.
89+-}
90+newtype Manipulation
91+ (commons :: FromType)
92+ (schemas :: SchemasType)
93+ (params :: [NullityType])
94+ (columns :: RowType)
95+ = UnsafeManipulation { renderManipulation :: ByteString }
96+ deriving (GHC.Generic,Show,Eq,Ord,NFData)
97+instance RenderSQL (Manipulation commons schemas params columns) where
98+ renderSQL = renderManipulation
99+instance With Manipulation where
100+ with Done manip = manip
101+ with ctes manip = UnsafeManipulation $
102+ "WITH" <+> commaSeparated (ctoList renderSQL ctes) <+> renderSQL manip
103+
104+{- |
105+The top level `Manipulation_` type is parameterized by a @schemas@ `SchemasType`,
106+against which the query is type-checked, an input @parameters@ Haskell `Type`,
107+and an ouput row Haskell `Type`.
108+
109+A top-level `Manipulation_` can be run
110+using `Squeal.PostgreSQL.PQ.manipulateParams`, or if @parameters = ()@
111+using `Squeal.PostgreSQL.PQ.manipulate`.
112+
113+Generally, @parameters@ will be a Haskell tuple or record whose entries
114+may be referenced using positional
115+`Squeal.PostgreSQL.Expression.Parameter.parameter`s and @row@ will be a
116+Haskell record, whose entries will be targeted using overloaded labels.
117+
118+>>> :set -XDeriveAnyClass -XDerivingStrategies
119+>>> :{
120+data Row a b = Row { col1 :: a, col2 :: b }
121+ deriving stock (GHC.Generic)
122+ deriving anyclass (SOP.Generic, SOP.HasDatatypeInfo)
123+:}
124+
76simple insert:
125simple insert:
77
126
78>>> type Columns = '["col1" ::: 'NoDef :=> 'Null 'PGint4, "col2" ::: 'Def :=> 'NotNull 'PGint4]
127>>> type Columns = '["col1" ::: 'NoDef :=> 'Null 'PGint4, "col2" ::: 'Def :=> 'NotNull 'PGint4]
79>>> type Schema = '["tab" ::: 'Table ('[] :=> Columns)]
128>>> type Schema = '["tab" ::: 'Table ('[] :=> Columns)]
80>>> :{
129>>> :{
81let
130let
82− manipulation :: Manipulation '[] (Public Schema) '[] '[]
131+ manipulation :: Manipulation_ (Public Schema) () ()
83 manipulation =
132 manipulation =
84− insertInto_ #tab (Values_ (2 `as` #col1 :* defaultAs #col2))
133+ insertInto_ #tab (Values_ (Set 2 `as` #col1 :* Default `as` #col2))
85in printSQL manipulation
134in printSQL manipulation
86:}
135:}
87INSERT INTO "tab" ("col1", "col2") VALUES (2, DEFAULT)
136INSERT INTO "tab" ("col1", "col2") VALUES (2, DEFAULT)
@@ -92,9 +141,9 @@ parameterized insert:
92>>> type Schema = '["tab" ::: 'Table ('[] :=> Columns)]
141>>> type Schema = '["tab" ::: 'Table ('[] :=> Columns)]
93>>> :{
142>>> :{
94let
143let
95− manipulation :: Manipulation '[] (Public Schema) '[ 'NotNull 'PGint4, 'NotNull 'PGint4 ] '[]
144+ manipulation :: Manipulation_ (Public Schema) (Int32, Int32) ()
96 manipulation =
145 manipulation =
97− insertInto_ #tab (Values_ (param @1 `as` #col1 :* param @2 `as` #col2))
146+ insertInto_ #tab (Values_ (Set (param @1) `as` #col1 :* Set (param @2) `as` #col2))
98in printSQL manipulation
147in printSQL manipulation
99:}
148:}
100INSERT INTO "tab" ("col1", "col2") VALUES (($1 :: int4), ($2 :: int4))
149INSERT INTO "tab" ("col1", "col2") VALUES (($1 :: int4), ($2 :: int4))
@@ -103,9 +152,9 @@ returning insert:
103
152
104>>> :{
153>>> :{
105let
154let
106− manipulation :: Manipulation '[] (Public Schema) '[] '["fromOnly" ::: 'NotNull 'PGint4]
155+ manipulation :: Manipulation_ (Public Schema) () (Only Int32)
107 manipulation =
156 manipulation =
108− insertInto #tab (Values_ (2 `as` #col1 :* 3 `as` #col2))
157+ insertInto #tab (Values_ (Set 2 `as` #col1 :* Set 3 `as` #col2))
109 OnConflictDoRaise (Returning (#col1 `as` #fromOnly))
158 OnConflictDoRaise (Returning (#col1 `as` #fromOnly))
110in printSQL manipulation
159in printSQL manipulation
111:}
160:}
@@ -118,12 +167,12 @@ upsert:
118>>> type CustomersSchema = '["customers" ::: 'Table (CustomersConstraints :=> CustomersColumns)]
167>>> type CustomersSchema = '["customers" ::: 'Table (CustomersConstraints :=> CustomersColumns)]
119>>> :{
168>>> :{
120let
169let
121− manipulation :: Manipulation '[] (Public CustomersSchema) '[] '[]
170+ manipulation :: Manipulation_ (Public CustomersSchema) () ()
122 manipulation =
171 manipulation =
123 insertInto #customers
172 insertInto #customers
124− (Values_ ("John Smith" `as` #name :* "john@smith.com" `as` #email))
173+ (Values_ (Set "John Smith" `as` #name :* Set "john@smith.com" `as` #email))
125 (OnConflict (OnConstraint #uq)
174 (OnConflict (OnConstraint #uq)
126− (DoUpdate (((#excluded ! #email) <> "; " <> (#customers ! #email)) `as` #email) []))
175+ (DoUpdate (Set (#excluded ! #email <> "; " <> #customers ! #email) `as` #email) []))
127 (Returning_ Nil)
176 (Returning_ Nil)
128in printSQL manipulation
177in printSQL manipulation
129:}
178:}
@@ -133,7 +182,7 @@ query insert:
133
182
134>>> :{
183>>> :{
135let
184let
136− manipulation :: Manipulation '[] (Public Schema) '[] '[]
185+ manipulation :: Manipulation_ (Public Schema) () ()
137 manipulation = insertInto_ #tab (Subquery (select Star (from (table #tab))))
186 manipulation = insertInto_ #tab (Subquery (select Star (from (table #tab))))
138in printSQL manipulation
187in printSQL manipulation
139:}
188:}
@@ -143,8 +192,8 @@ update:
143
192
144>>> :{
193>>> :{
145let
194let
146− manipulation :: Manipulation '[] (Public Schema) '[] '[]
195+ manipulation :: Manipulation_ (Public Schema) () ()
147− manipulation = update_ #tab (2 `as` #col1) (#col1 ./= #col2)
196+ manipulation = update_ #tab (Set 2 `as` #col1) (#col1 ./= #col2)
148in printSQL manipulation
197in printSQL manipulation
149:}
198:}
150UPDATE "tab" SET "col1" = 2 WHERE ("col1" <> "col2")
199UPDATE "tab" SET "col1" = 2 WHERE ("col1" <> "col2")
@@ -153,9 +202,7 @@ delete:
153
202
154>>> :{
203>>> :{
155let
204let
156− manipulation :: Manipulation '[] (Public Schema) '[]
205+ manipulation :: Manipulation_ (Public Schema) () (Row Int32 Int32)
157− '[ "col1" ::: 'NotNull 'PGint4
158− , "col2" ::: 'NotNull 'PGint4 ]
159 manipulation = deleteFrom #tab NoUsing (#col1 .== #col2) (Returning Star)
206 manipulation = deleteFrom #tab NoUsing (#col1 .== #col2) (Returning Star)
160in printSQL manipulation
207in printSQL manipulation
161:}
208:}
@@ -166,13 +213,13 @@ delete and using clause:
166>>> :{
213>>> :{
167type Schema3 =
214type Schema3 =
168 '[ "tab" ::: 'Table ('[] :=> Columns)
215 '[ "tab" ::: 'Table ('[] :=> Columns)
169− , "other_tab" ::: 'Table ('[] :=> Columns)
216+ , "other_tab" ::: 'Table ('[] :=> Columns)
170− , "third_tab" ::: 'Table ('[] :=> Columns) ]
217+ , "third_tab" ::: 'Table ('[] :=> Columns) ]
171:}
218:}
172
219
173>>> :{
220>>> :{
174let
221let
175− manipulation :: Manipulation '[] (Public Schema3) '[] '[]
222+ manipulation :: Manipulation_ (Public Schema3) () ()
176 manipulation =
223 manipulation =
177 deleteFrom #tab (Using (table #other_tab & also (table #third_tab)))
224 deleteFrom #tab (Using (table #other_tab & also (table #third_tab)))
178 ( (#tab ! #col2 .== #other_tab ! #col2)
225 ( (#tab ! #col2 .== #other_tab ! #col2)
@@ -188,7 +235,7 @@ with manipulation:
188>>> type ProductsSchema = '["products" ::: 'Table ('[] :=> ProductsColumns), "products_deleted" ::: 'Table ('[] :=> ProductsColumns)]
235>>> type ProductsSchema = '["products" ::: 'Table ('[] :=> ProductsColumns), "products_deleted" ::: 'Table ('[] :=> ProductsColumns)]
189>>> :{
236>>> :{
190let
237let
191− manipulation :: Manipulation '[] (Public ProductsSchema) '[ 'NotNull 'PGdate] '[]
238+ manipulation :: Manipulation_ (Public ProductsSchema) (Only Day) ()
192 manipulation = with
239 manipulation = with
193 (deleteFrom #products NoUsing (#date .< param @1) (Returning Star) `as` #del)
240 (deleteFrom #products NoUsing (#date .< param @1) (Returning Star) `as` #del)
194 (insertInto_ #products_deleted (Subquery (select Star (from (common #del)))))
241 (insertInto_ #products_deleted (Subquery (select Star (from (common #del)))))
@@ -196,26 +243,13 @@ in printSQL manipulation
196:}
243:}
197WITH "del" AS (DELETE FROM "products" WHERE ("date" < ($1 :: date)) RETURNING *) INSERT INTO "products_deleted" SELECT * FROM "del" AS "del"
244WITH "del" AS (DELETE FROM "products" WHERE ("date" < ($1 :: date)) RETURNING *) INSERT INTO "products_deleted" SELECT * FROM "del" AS "del"
198-}
245-}
199−newtype Manipulation
200− (commons :: FromType)
201− (schemas :: SchemasType)
202− (params :: [NullityType])
203− (columns :: RowType)
204− = UnsafeManipulation { renderManipulation :: ByteString }
205− deriving (GHC.Generic,Show,Eq,Ord,NFData)
206−instance RenderSQL (Manipulation commons schemas params columns) where
207− renderSQL = renderManipulation
208−instance With Manipulation where
209− with Done manip = manip
210− with ctes manip = UnsafeManipulation $
211− "WITH" <+> renderSQL ctes <+> renderSQL manip
212−
213type family Manipulation_ (schemas :: SchemasType) (params :: Type) (row :: Type) where
246type family Manipulation_ (schemas :: SchemasType) (params :: Type) (row :: Type) where
214 Manipulation_ schemas params row = Manipulation '[] schemas (TuplePG params) (RowPG row)
247 Manipulation_ schemas params row = Manipulation '[] schemas (TuplePG params) (RowPG row)
215
248
216-- | Convert a `Query` into a `Manipulation`.
249-- | Convert a `Query` into a `Manipulation`.
217queryStatement
250queryStatement
218 :: Query '[] commons schemas params columns
251 :: Query '[] commons schemas params columns
252+ -- ^ `Query` to embed as a `Manipulation`
219 -> Manipulation commons schemas params columns
253 -> Manipulation commons schemas params columns
220queryStatement q = UnsafeManipulation $ renderSQL q
254queryStatement q = UnsafeManipulation $ renderSQL q
221
255
@@ -238,9 +272,13 @@ insertInto
238 , SOP.SListI columns
272 , SOP.SListI columns
239 , SOP.SListI row1 )
273 , SOP.SListI row1 )
240 => QualifiedAlias sch tab
274 => QualifiedAlias sch tab
275+ -- ^ table
241 -> QueryClause commons schemas params columns
276 -> QueryClause commons schemas params columns
277+ -- ^ what to insert
242 -> ConflictClause tab commons schemas params table
278 -> ConflictClause tab commons schemas params table
279+ -- ^ what to do in case of conflict
243 -> ReturningClause commons schemas params '[tab ::: row0] row1
280 -> ReturningClause commons schemas params '[tab ::: row0] row1
281+ -- ^ what to return
244 -> Manipulation commons schemas params row1
282 -> Manipulation commons schemas params row1
245insertInto tab qry conflict ret = UnsafeManipulation $
283insertInto tab qry conflict ret = UnsafeManipulation $
246 "INSERT" <+> "INTO" <+> renderSQL tab
284 "INSERT" <+> "INTO" <+> renderSQL tab
@@ -248,6 +286,7 @@ insertInto tab qry conflict ret = UnsafeManipulation $
248 <> renderSQL conflict
286 <> renderSQL conflict
249 <> renderSQL ret
287 <> renderSQL ret
250
288
289+-- | Like `insertInto` but with `OnConflictDoRaise` and `no` `ReturningClause`.
251insertInto_
290insertInto_
252 :: ( Has sch schemas schema
291 :: ( Has sch schemas schema
253 , Has tab schema ('Table table)
292 , Has tab schema ('Table table)
@@ -255,25 +294,33 @@ insertInto_
255 , row ~ TableToRow table
294 , row ~ TableToRow table
256 , SOP.SListI columns )
295 , SOP.SListI columns )
257 => QualifiedAlias sch tab
296 => QualifiedAlias sch tab
297+ -- ^ table
258 -> QueryClause commons schemas params columns
298 -> QueryClause commons schemas params columns
299+ -- ^ what to insert
259 -> Manipulation commons schemas params '[]
300 -> Manipulation commons schemas params '[]
260insertInto_ tab qry =
301insertInto_ tab qry =
261 insertInto tab qry OnConflictDoRaise (Returning_ Nil)
302 insertInto tab qry OnConflictDoRaise (Returning_ Nil)
262
303
304+-- | A `QueryClause` describes what to `insertInto` a table.
263data QueryClause commons schemas params columns where
305data QueryClause commons schemas params columns where
264 Values
306 Values
265 :: SOP.SListI columns
307 :: SOP.SListI columns
266− => NP (ColumnExpression 'Ungrouped schemas params '[]) columns
308+ => NP (Aliased (Optional (Expression '[] commons 'Ungrouped schemas params '[]))) columns
309+ -- ^ row of values
267− -> [NP (ColumnExpression 'Ungrouped schemas params '[]) columns]
310+ -> [NP (Aliased (Optional (Expression '[] commons 'Ungrouped schemas params '[]))) columns]
311+ -- ^ additional rows of values
268 -> QueryClause commons schemas params columns
312 -> QueryClause commons schemas params columns
269 Select
313 Select
270 :: SOP.SListI columns
314 :: SOP.SListI columns
271− => NP (ColumnExpression grp schemas params from) columns
315+ => NP (Aliased (Optional (Expression '[] commons grp schemas params from))) columns
316+ -- ^ row of values
272− -> TableExpression '[] grp commons schemas params from
317+ -> TableExpression '[] commons grp schemas params from
318+ -- ^ from a table expression
273 -> QueryClause commons schemas params columns
319 -> QueryClause commons schemas params columns
274 Subquery
320 Subquery
275 :: ColumnsToRow columns ~ row
321 :: ColumnsToRow columns ~ row
276 => Query '[] commons schemas params row
322 => Query '[] commons schemas params row
323+ -- ^ subquery to insert
277 -> QueryClause commons schemas params columns
324 -> QueryClause commons schemas params columns
278
325
279instance RenderSQL (QueryClause commons schemas params columns) where
326instance RenderSQL (QueryClause commons schemas params columns) where
@@ -292,109 +339,41 @@ instance RenderSQL (QueryClause commons schemas params columns) where
292 Subquery qry -> renderQuery qry
339 Subquery qry -> renderQuery qry
293 where
340 where
294 renderSQLPartMaybe, renderValuePartMaybe
341 renderSQLPartMaybe, renderValuePartMaybe
295− :: ColumnExpression grp schemas params from column -> Maybe ByteString
342+ :: Aliased (Optional (Expression '[] commons grp schemas params from)) column
343+ -> Maybe ByteString
296 renderSQLPartMaybe = \case
344 renderSQLPartMaybe = \case
297− DefaultAs _ -> Nothing
345+ Default `As` _ -> Nothing
298− Specific (_ `As` name) -> Just $ renderSQL name
346+ Set _ `As` name -> Just $ renderSQL name
299 renderValuePartMaybe = \case
347 renderValuePartMaybe = \case
300− DefaultAs _ -> Nothing
348+ Default `As` _ -> Nothing
301− Specific (value `As` _) -> Just $ renderExpression value
349+ Set value `As` _ -> Just $ renderExpression value
302 renderSQLPart, renderValuePart
350 renderSQLPart, renderValuePart
303− :: ColumnExpression grp schemas params from column -> ByteString
351+ :: Aliased (Optional (Expression '[] commons grp schemas params from)) column
304− renderSQLPart = \case
352+ -> ByteString
305− DefaultAs name -> renderSQL name
306− Specific (_ `As` name) -> renderSQL name
353+ renderSQLPart (_ `As` name) = renderSQL name
307− renderValuePart = \case
354+ renderValuePart (value `As` _) = renderSQL value
308− DefaultAs _ -> "DEFAULT"
309− Specific (value `As` _) -> renderExpression value
310
355
356+-- | `Values_` describes a single `NP` list of `Aliased` `Optional` `Expression`s
357+-- whose `ColumnsType` must match the tables'.
311pattern Values_
358pattern Values_
312 :: SOP.SListI columns
359 :: SOP.SListI columns
313− => NP (ColumnExpression 'Ungrouped schemas params '[]) columns
360+ => NP (Aliased (Optional (Expression '[] commons 'Ungrouped schemas params '[]))) columns
361+ -- ^ row of values
314 -> QueryClause commons schemas params columns
362 -> QueryClause commons schemas params columns
315pattern Values_ vals = Values vals []
363pattern Values_ vals = Values vals []
316
364
317−data ColumnExpression grp schemas params from column where
365+-- | `Optional` is either `Default` or a value, parameterized by an appropriate
318− DefaultAs
366+-- `ColumnConstraint`.
319− :: KnownSymbol col
367+data Optional expr ty where
320− => Alias col
368+ -- | Use the `Default` value for a column.
321− -> ColumnExpression grp schemas params from (col ::: 'Def :=> ty)
369+ Default :: Optional expr ('Def :=> ty)
322− Specific
370+ -- | `Set` a value for a column.
323− :: Aliased (Expression '[] grp '[] schemas params from) (col ::: ty)
371+ Set :: expr ty -> Optional expr (def :=> ty)
324− -> ColumnExpression grp schemas params from (col ::: defness :=> ty)
372+
325−
373+instance (forall x. RenderSQL (expr x)) => RenderSQL (Optional expr ty) where
326−instance (KnownSymbol col, column ~ (col ::: defness :=> ty))
327− => Aliasable col
328− (Expression '[] grp '[] schemas params from ty)
329− (ColumnExpression grp schemas params from column) where
330− expression `as` col = Specific (expression `As` col)
331−instance (KnownSymbol col, columns ~ '[col ::: defness :=> ty])
332− => Aliasable col
333− (Expression '[] grp '[] schemas params from ty)
334− (NP (ColumnExpression grp schemas params from) columns) where
335− expression `as` col = expression `as` col :* Nil
336−instance (KnownSymbol col, column ~ (col ::: 'Def :=> ty))
337− => DefaultAliasable col (ColumnExpression grp schemas params from column) where
338− defaultAs = DefaultAs
339−instance (KnownSymbol col, columns ~ '[col ::: 'Def :=> ty])
340− => DefaultAliasable col (NP (ColumnExpression grp schemas params from) columns) where
341− defaultAs col = defaultAs col :* Nil
342−
343−instance (HasUnique tab from row, Has col row ty, column ~ (col ::: defness :=> ty))
344− => IsLabel col (ColumnExpression 'Ungrouped schemas params from column) where
345− fromLabel = fromLabel @col `as` Alias
346−instance (HasUnique tab from row, Has col row ty, columns ~ '[col ::: defness :=> ty])
347− => IsLabel col
348− (NP (ColumnExpression 'Ungrouped schemas params from) columns) where
349− fromLabel = fromLabel @col `as` Alias
350−
351−instance (Has tab from row, Has col row ty, column ~ (col ::: defness :=> ty))
352− => IsQualified tab col (ColumnExpression 'Ungrouped schemas params from column) where
353− tab ! col = tab ! col `as` col
354−instance (Has tab from row, Has col row ty, columns ~ '[col ::: defness :=> ty])
355− => IsQualified tab col (NP (ColumnExpression 'Ungrouped schemas params from) columns) where
356− tab ! col = tab ! col `as` col
357−
358−instance
359− ( HasUnique tab from row
360− , Has col row ty
361− , GroupedBy tab col bys
362− , column ~ (col ::: defness :=> ty)
363− ) => IsLabel col
364− (ColumnExpression ('Grouped bys) schemas params from column) where
365− fromLabel = fromLabel @col `as` Alias
366−instance
367− ( HasUnique tab from row
368− , Has col row ty
369− , GroupedBy tab col bys
370− , columns ~ '[col ::: defness :=> ty]
371− ) => IsLabel col
372− (NP (ColumnExpression ('Grouped bys) schemas params from) columns) where
373− fromLabel = fromLabel @col `as` Alias
374−
375−instance
376− ( Has tab from row
377− , Has col row ty
378− , GroupedBy tab col bys
379− , column ~ (col ::: defness :=> ty)
380− ) => IsQualified tab col
381− (ColumnExpression ('Grouped bys) schemas params from column) where
382− tab ! col = tab ! col `as` col
383−instance
384− ( Has tab from row
385− , Has col row ty
386− , GroupedBy tab col bys
387− , columns ~ '[col ::: defness :=> ty]
388− ) => IsQualified tab col
389− (NP (ColumnExpression ('Grouped bys) schemas params from) columns) where
390− tab ! col = tab ! col :* Nil
391−
392−instance RenderSQL (ColumnExpression grp schemas params from column) where
393 renderSQL = \case
374 renderSQL = \case
394− DefaultAs col ->
395− renderSQL col <+> "=" <+> "DEFAULT"
375+ Default -> "DEFAULT"
396− Specific (expression `As` col) ->
376+ Set expr -> renderSQL expr
397− renderSQL col <+> "=" <+> renderSQL expression
398
377
399-- | A `ReturningClause` computes and return value(s) based
378-- | A `ReturningClause` computes and return value(s) based
400-- on each row actually inserted, updated or deleted. This is primarily
379-- on each row actually inserted, updated or deleted. This is primarily
@@ -404,19 +383,21 @@ instance RenderSQL (ColumnExpression grp schemas params from column) where
404-- deleted will be returned. For example, if a row was locked
383-- deleted will be returned. For example, if a row was locked
405-- but not updated because an `OnConflict` `DoUpdate` condition was not satisfied,
384-- but not updated because an `OnConflict` `DoUpdate` condition was not satisfied,
406-- the row will not be returned. `Returning` `Star` will return all columns
385-- the row will not be returned. `Returning` `Star` will return all columns
407−-- in the row. Use @Returning Nil@ in the common case where no return
386+-- in the row. Use `Returning` `Nil` in the common case where no return
408-- values are desired.
387-- values are desired.
409newtype ReturningClause commons schemas params from row =
388newtype ReturningClause commons schemas params from row =
410− Returning (Selection '[] 'Ungrouped commons schemas params from row)
389+ Returning (Selection '[] commons 'Ungrouped schemas params from row)
411
390
412instance RenderSQL (ReturningClause commons schemas params from row) where
391instance RenderSQL (ReturningClause commons schemas params from row) where
413 renderSQL = \case
392 renderSQL = \case
414 Returning (List Nil) -> ""
393 Returning (List Nil) -> ""
415 Returning selection -> " RETURNING" <+> renderSQL selection
394 Returning selection -> " RETURNING" <+> renderSQL selection
416
395
396+-- | `Returning` a `List`
417pattern Returning_
397pattern Returning_
418 :: SOP.SListI row
398 :: SOP.SListI row
419− => NP (Aliased (Expression '[] 'Ungrouped commons schemas params from)) row
399+ => NP (Aliased (Expression '[] commons 'Ungrouped schemas params from)) row
400+ -- ^ row of values
420 -> ReturningClause commons schemas params from row
401 -> ReturningClause commons schemas params from row
421pattern Returning_ list = Returning (List list)
402pattern Returning_ list = Returning (List list)
422
403
@@ -429,7 +410,9 @@ data ConflictClause tab commons schemas params table where
429 OnConflictDoRaise :: ConflictClause tab commons schemas params table
410 OnConflictDoRaise :: ConflictClause tab commons schemas params table
430 OnConflict
411 OnConflict
431 :: ConflictTarget constraints
412 :: ConflictTarget constraints
413+ -- ^ conflict target
432 -> ConflictAction tab commons schemas params columns
414 -> ConflictAction tab commons schemas params columns
415+ -- ^ conflict action
433 -> ConflictClause tab commons schemas params (constraints :=> columns)
416 -> ConflictClause tab commons schemas params (constraints :=> columns)
434
417
435-- | Render a `ConflictClause`.
418-- | Render a `ConflictClause`.
@@ -440,6 +423,17 @@ instance SOP.SListI (TableToColumns table)
440 OnConflict target action -> " ON CONFLICT"
423 OnConflict target action -> " ON CONFLICT"
441 <+> renderSQL target <+> renderSQL action
424 <+> renderSQL target <+> renderSQL action
442
425
426+{- |
427+`ConflictAction` specifies an alternative `OnConflict` action.
428+It can be either `DoNothing`, or a `DoUpdate` clause specifying
429+the exact details of the `update` action to be performed in case of a conflict.
430+The `Set` and WHERE `Condition`s in `OnConflict` `DoUpdate` have access to the
431+existing row using the table's name (or an alias), and to rows proposed
432+for insertion using the special @#excluded@ table.
433+`OnConflict` `DoNothing` simply avoids inserting a row as its alternative action.
434+`OnConflict` `DoUpdate` updates the existing row that conflicts
435+with the row proposed for insertion as its alternative action.
436+-}
443data ConflictAction tab commons schemas params columns where
437data ConflictAction tab commons schemas params columns where
444 DoNothing :: ConflictAction tab commons schemas params columns
438 DoNothing :: ConflictAction tab commons schemas params columns
445 DoUpdate
439 DoUpdate
@@ -448,8 +442,9 @@ data ConflictAction tab commons schemas params columns where
448 , columns ~ (col0 ': cols)
442 , columns ~ (col0 ': cols)
449 , SOP.All (HasIn columns) subcolumns
443 , SOP.All (HasIn columns) subcolumns
450 , AllUnique subcolumns )
444 , AllUnique subcolumns )
451− => NP (ColumnExpression 'Ungrouped schemas params '[tab ::: row, "excluded" ::: row]) subcolumns
445+ => NP (Aliased (Optional (Expression '[] commons 'Ungrouped schemas params '[tab ::: row, "excluded" ::: row]))) subcolumns
452− -> [Condition '[] 'Ungrouped commons schemas params '[tab ::: row, "excluded" ::: row]]
446+ -> [Condition '[] commons 'Ungrouped schemas params '[tab ::: row, "excluded" ::: row]]
447+ -- ^ WHERE `Condition`s
453 -> ConflictAction tab commons schemas params columns
448 -> ConflictAction tab commons schemas params columns
454
449
455instance RenderSQL (ConflictAction tab commons schemas params columns) where
450instance RenderSQL (ConflictAction tab commons schemas params columns) where
@@ -457,11 +452,17 @@ instance RenderSQL (ConflictAction tab commons schemas params columns) where
457 DoNothing -> "DO NOTHING"
452 DoNothing -> "DO NOTHING"
458 DoUpdate updates whs'
453 DoUpdate updates whs'
459 -> "DO UPDATE SET"
454 -> "DO UPDATE SET"
460− <+> renderCommaSeparated renderSQL updates
455+ <+> renderCommaSeparated renderUpdate updates
461 <> case whs' of
456 <> case whs' of
462 [] -> ""
457 [] -> ""
463 wh:whs -> " WHERE" <+> renderSQL (foldr (.&&) wh whs)
458 wh:whs -> " WHERE" <+> renderSQL (foldr (.&&) wh whs)
464
459
460+renderUpdate
461+ :: (forall x. RenderSQL (expr x))
462+ => Aliased (Optional expr) ty
463+ -> ByteString
464+renderUpdate (expr `As` col) = renderSQL col <+> "=" <+> renderSQL expr
465+
465-- | A `ConflictTarget` specifies the constraint violation that triggers a
466-- | A `ConflictTarget` specifies the constraint violation that triggers a
466-- `ConflictAction`.
467-- `ConflictAction`.
467data ConflictTarget constraints where
468data ConflictTarget constraints where
@@ -484,7 +485,6 @@ UPDATE statements
484update
485update
485 :: ( SOP.SListI columns
486 :: ( SOP.SListI columns
486 , SOP.SListI row1
487 , SOP.SListI row1
487− , db ~ (commons :=> schemas)
488 , Has sch schemas schema
488 , Has sch schemas schema
489 , Has tab schema ('Table table)
489 , Has tab schema ('Table table)
490 , row0 ~ TableToRow table
490 , row0 ~ TableToRow table
@@ -492,9 +492,9 @@ update
492 , SOP.All (HasIn columns) subcolumns
492 , SOP.All (HasIn columns) subcolumns
493 , AllUnique subcolumns )
493 , AllUnique subcolumns )
494 => QualifiedAlias sch tab -- ^ table to update
494 => QualifiedAlias sch tab -- ^ table to update
495− -> NP (ColumnExpression 'Ungrouped schemas params '[tab ::: row0]) subcolumns
495+ -> NP (Aliased (Optional (Expression '[] '[] 'Ungrouped schemas params '[tab ::: row0]))) subcolumns
496 -- ^ modified values to replace old values
496 -- ^ modified values to replace old values
497− -> Condition '[] 'Ungrouped commons schemas params '[tab ::: row0]
497+ -> Condition '[] commons 'Ungrouped schemas params '[tab ::: row0]
498 -- ^ condition under which to perform update on a row
498 -- ^ condition under which to perform update on a row
499 -> ReturningClause commons schemas params '[tab ::: row0] row1 -- ^ results to return
499 -> ReturningClause commons schemas params '[tab ::: row0] row1 -- ^ results to return
500 -> Manipulation commons schemas params row1
500 -> Manipulation commons schemas params row1
@@ -502,14 +502,13 @@ update tab columns wh returning = UnsafeManipulation $
502 "UPDATE"
502 "UPDATE"
503 <+> renderSQL tab
503 <+> renderSQL tab
504 <+> "SET"
504 <+> "SET"
505− <+> renderCommaSeparated renderSQL columns
505+ <+> renderCommaSeparated renderUpdate columns
506 <+> "WHERE" <+> renderSQL wh
506 <+> "WHERE" <+> renderSQL wh
507 <> renderSQL returning
507 <> renderSQL returning
508
508
509-- | Update a row returning `Nil`.
509-- | Update a row returning `Nil`.
510update_
510update_
511 :: ( SOP.SListI columns
511 :: ( SOP.SListI columns
512− , db ~ (commons :=> schemas)
513 , Has sch schemas schema
512 , Has sch schemas schema
514 , Has tab schema ('Table table)
513 , Has tab schema ('Table table)
515 , row ~ TableToRow table
514 , row ~ TableToRow table
@@ -517,9 +516,9 @@ update_
517 , SOP.All (HasIn columns) subcolumns
516 , SOP.All (HasIn columns) subcolumns
518 , AllUnique subcolumns )
517 , AllUnique subcolumns )
519 => QualifiedAlias sch tab -- ^ table to update
518 => QualifiedAlias sch tab -- ^ table to update
520− -> NP (ColumnExpression 'Ungrouped schemas params '[tab ::: row]) subcolumns
519+ -> NP (Aliased (Optional (Expression '[] '[] 'Ungrouped schemas params '[tab ::: row]))) subcolumns
521 -- ^ modified values to replace old values
520 -- ^ modified values to replace old values
522− -> Condition '[] 'Ungrouped commons schemas params '[tab ::: row]
521+ -> Condition '[] commons 'Ungrouped schemas params '[tab ::: row]
523 -- ^ condition under which to perform update on a row
522 -- ^ condition under which to perform update on a row
524 -> Manipulation commons schemas params '[]
523 -> Manipulation commons schemas params '[]
525update_ tab columns wh = update tab columns wh (Returning_ Nil)
524update_ tab columns wh = update tab columns wh (Returning_ Nil)
@@ -528,23 +527,32 @@ update_ tab columns wh = update tab columns wh (Returning_ Nil)
528DELETE statements
527DELETE statements
529-----------------------------------------}
528-----------------------------------------}
530
529
530+-- | Specify additional tables with `Using`
531+-- an `also` list of table expressions, allowing columns
532+-- from other tables to appear in the WHERE condition.
533+-- This is similar to the list of tables that can be specified
534+-- in the FROM Clause of a SELECT statement;
535+-- for example, an alias for the table name can be specified.
536+-- Do not repeat the target table in the `Using` list,
537+-- unless you wish to set up a self-join.
538+-- `NoUsing` if no additional tables are to be used.
531data UsingClause commons schemas params from where
539data UsingClause commons schemas params from where
532 NoUsing :: UsingClause commons schemas params '[]
540 NoUsing :: UsingClause commons schemas params '[]
533 Using
541 Using
534 :: FromClause '[] commons schemas params from
542 :: FromClause '[] commons schemas params from
543+ -- ^ what to use
535 -> UsingClause commons schemas params from
544 -> UsingClause commons schemas params from
536
545
537-- | Delete rows from a table.
546-- | Delete rows from a table.
538deleteFrom
547deleteFrom
539 :: ( SOP.SListI row1
548 :: ( SOP.SListI row1
540− , db ~ (commons :=> schemas)
541 , Has sch schemas schema
549 , Has sch schemas schema
542 , Has tab schema ('Table table)
550 , Has tab schema ('Table table)
543 , row0 ~ TableToRow table
551 , row0 ~ TableToRow table
544 , columns ~ TableToColumns table )
552 , columns ~ TableToColumns table )
545 => QualifiedAlias sch tab -- ^ table to delete from
553 => QualifiedAlias sch tab -- ^ table to delete from
546 -> UsingClause commons schemas params from
554 -> UsingClause commons schemas params from
547− -> Condition '[] 'Ungrouped commons schemas params (tab ::: row0 ': from)
555+ -> Condition '[] commons 'Ungrouped schemas params (tab ::: row0 ': from)
548 -- ^ condition under which to delete a row
556 -- ^ condition under which to delete a row
549 -> ReturningClause commons schemas params '[tab ::: row0] row1 -- ^ results to return
557 -> ReturningClause commons schemas params '[tab ::: row0] row1 -- ^ results to return
550 -> Manipulation commons schemas params row1
558 -> Manipulation commons schemas params row1
@@ -559,27 +567,12 @@ deleteFrom tab using wh returning = UnsafeManipulation $
559
567
560-- | Delete rows returning `Nil`.
568-- | Delete rows returning `Nil`.
561deleteFrom_
569deleteFrom_
562− :: ( db ~ (commons :=> schemas)
563− , Has sch schemas schema
570+ :: ( Has sch schemas schema
564 , Has tab schema ('Table table)
571 , Has tab schema ('Table table)
565 , row ~ TableToRow table
572 , row ~ TableToRow table
566 , columns ~ TableToColumns table )
573 , columns ~ TableToColumns table )
567 => QualifiedAlias sch tab -- ^ table to delete from
574 => QualifiedAlias sch tab -- ^ table to delete from
568− -> Condition '[] 'Ungrouped commons schemas params '[tab ::: row]
575+ -> Condition '[] commons 'Ungrouped schemas params '[tab ::: row]
569 -- ^ condition under which to delete a row
576 -- ^ condition under which to delete a row
570 -> Manipulation commons schemas params '[]
577 -> Manipulation commons schemas params '[]
571deleteFrom_ tab wh = deleteFrom tab NoUsing wh (Returning_ Nil)
578deleteFrom_ tab wh = deleteFrom tab NoUsing wh (Returning_ Nil)
572−
573−-- | This has the behaviour of a cartesian product, taking all
574−-- possible combinations between @left@ and @right@ - exactly like a
575−-- `crossJoin`. Used when no `crossJoin` syntax is required but simply
576−-- a comma separated list of tables. Typical case is the `UsingClause`
577−-- of a `deleteFrom` query.
578−also
579− :: FromClause outer commons schemas params right
580− -- ^ right
581− -> FromClause outer commons schemas params left
582− -- ^ left
583− -> FromClause outer commons schemas params (Join left right)
584−also right left = UnsafeFromClause $
585− renderSQL left <> "," <+> renderSQL right
squeal-postgresql/src/Squeal/PostgreSQL/Migration.hs+337−186
@@ -8,8 +8,13 @@ Stability: experimental
8This module defines a `Migration` type to safely
8This module defines a `Migration` type to safely
9change the schema of your database over time. Let's see an example!
9change the schema of your database over time. Let's see an example!
10
10
11+First turn on some extensions.
12+
11>>> :set -XDataKinds -XOverloadedLabels
13>>> :set -XDataKinds -XOverloadedLabels
12>>> :set -XOverloadedStrings -XFlexibleContexts -XTypeOperators
14>>> :set -XOverloadedStrings -XFlexibleContexts -XTypeOperators
15+
16+Next, let's define our `TableType`s.
17+
13>>> :{
18>>> :{
14type UsersTable =
19type UsersTable =
15 '[ "pk_users" ::: 'PrimaryKey '["id"] ] :=>
20 '[ "pk_users" ::: 'PrimaryKey '["id"] ] :=>
@@ -20,7 +25,7 @@ type UsersTable =
20
25
21>>> :{
26>>> :{
22type EmailsTable =
27type EmailsTable =
23− '[ "pk_emails" ::: 'PrimaryKey '["id"]
28+ '[ "pk_emails" ::: 'PrimaryKey '["id"]
24 , "fk_user_id" ::: 'ForeignKey '["user_id"] "users" '["id"]
29 , "fk_user_id" ::: 'ForeignKey '["user_id"] "users" '["id"]
25 ] :=>
30 ] :=>
26 '[ "id" ::: 'Def :=> 'NotNull 'PGint4
31 '[ "id" ::: 'Def :=> 'NotNull 'PGint4
@@ -29,227 +34,293 @@ type EmailsTable =
29 ]
34 ]
30:}
35:}
31
36
37+Now we can define some `Migration`s to make our tables.
38+
32>>> :{
39>>> :{
33let
40let
34− makeUsers :: Migration IO (Public '[]) '["public" ::: '["users" ::: 'Table UsersTable]]
41+ makeUsers :: Migration Definition (Public '[]) '["public" ::: '["users" ::: 'Table UsersTable]]
35 makeUsers = Migration
42 makeUsers = Migration
36 { name = "make users table"
43 { name = "make users table"
37− , up = void . define $
38− createTable #users
44+ , up = createTable #users
39 ( serial `as` #id :*
45 ( serial `as` #id :*
40− (text & notNullable) `as` #name )
46+ notNullable text `as` #name )
41 ( primaryKey #id `as` #pk_users )
47 ( primaryKey #id `as` #pk_users )
42− , down = void . define $ dropTable #users
48+ , down = dropTable #users
43 }
49 }
44:}
50:}
45
51
46>>> :{
52>>> :{
47let
53let
48− makeEmails :: Migration IO '["public" ::: '["users" ::: 'Table UsersTable]]
54+ makeEmails :: Migration Definition '["public" ::: '["users" ::: 'Table UsersTable]]
49 '["public" ::: '["users" ::: 'Table UsersTable, "emails" ::: 'Table EmailsTable]]
55 '["public" ::: '["users" ::: 'Table UsersTable, "emails" ::: 'Table EmailsTable]]
50 makeEmails = Migration
56 makeEmails = Migration
51 { name = "make emails table"
57 { name = "make emails table"
52− , up = void . define $
53− createTable #emails
58+ , up = createTable #emails
54 ( serial `as` #id :*
59 ( serial `as` #id :*
55− (int & notNullable) `as` #user_id :*
60+ notNullable int `as` #user_id :*
56− (text & nullable) `as` #email )
61+ nullable text `as` #email )
57 ( primaryKey #id `as` #pk_emails :*
62 ( primaryKey #id `as` #pk_emails :*
58 foreignKey #user_id #users #id
63 foreignKey #user_id #users #id
59 OnDeleteCascade OnUpdateCascade `as` #fk_user_id )
64 OnDeleteCascade OnUpdateCascade `as` #fk_user_id )
60− , down = void . define $ dropTable #emails
65+ , down = dropTable #emails
61 }
66 }
62:}
67:}
63
68
64−Now that we have a couple migrations we can chain them together.
69+Now that we have a couple migrations we can chain them together into a `Path`.
65
70
66>>> let migrations = makeUsers :>> makeEmails :>> Done
71>>> let migrations = makeUsers :>> makeEmails :>> Done
67
72
68−>>> :{
73+Now run the migrations.
69−let
70− numMigrations
71− :: Has "migrations" schemas MigrationsSchema
72− => PQ schemas schemas IO ()
73− numMigrations = do
74− result <- runQuery (select Star (from (table (#migrations ! #schema_migrations `as` #m))))
75− num <- ntuples result
76− liftBase $ print num
77−:}
78
74
75+>>> import Control.Monad.IO.Class
79>>> :{
76>>> :{
80withConnection "host=localhost port=5432 dbname=exampledb" $
77withConnection "host=localhost port=5432 dbname=exampledb" $
81 manipulate (UnsafeManipulation "SET client_min_messages TO WARNING;")
78 manipulate (UnsafeManipulation "SET client_min_messages TO WARNING;")
82 -- suppress notices
79 -- suppress notices
80+ & pqThen (liftIO (putStrLn "Migrate"))
83 & pqThen (migrateUp migrations)
81 & pqThen (migrateUp migrations)
84− & pqThen numMigrations
82+ & pqThen (liftIO (putStrLn "Rollback"))
85 & pqThen (migrateDown migrations)
83 & pqThen (migrateDown migrations)
86− & pqThen numMigrations
87:}
84:}
88−Row 2
85+Migrate
89−Row 0
86+Rollback
87+
88+We can also create a simple executable using `defaultMain`.
89+
90+>>> let main = defaultMain "host=localhost port=5432 dbname=exampledb" migrations
91+
92+>>> withArgs [] main
93+Invalid command: "". Use:
94+migrate to run all available migrations
95+rollback to rollback all available migrations
96+status to display migrations run and migrations left to run
97+
98+>>> withArgs ["status"] main
99+Migrations already run:
100+ None
101+Migrations left to run:
102+ - make users table
103+ - make emails table
104+
105+>>> withArgs ["migrate"] main
106+Migrations already run:
107+ - make users table
108+ - make emails table
109+Migrations left to run:
110+ None
111+
112+>>> withArgs ["rollback"] main
113+Migrations already run:
114+ None
115+Migrations left to run:
116+ - make users table
117+ - make emails table
118+
119+In addition to enabling `Migration`s using pure SQL `Definition`s for
120+the `up` and `down` instructions, you can also perform impure `IO` actions
121+by using a `Migration`s over the `Terminally` `PQ` `IO` category.
90-}
122-}
91
123
92{-# LANGUAGE
124{-# LANGUAGE
93 DataKinds
125 DataKinds
126+ , DeriveGeneric
127+ , FlexibleContexts
128+ , FlexibleInstances
94 , GADTs
129 , GADTs
95 , LambdaCase
130 , LambdaCase
96− , PolyKinds
97 , OverloadedLabels
131 , OverloadedLabels
132+ , OverloadedStrings
133+ , PolyKinds
134+ , QuantifiedConstraints
135+ , RankNTypes
98 , TypeApplications
136 , TypeApplications
99− , FlexibleContexts
100 , TypeOperators
137 , TypeOperators
101#-}
138#-}
102
139
103module Squeal.PostgreSQL.Migration
140module Squeal.PostgreSQL.Migration
104 ( -- * Migration
141 ( -- * Migration
105 Migration (..)
142 Migration (..)
106− , migrateUp
143+ , Migratory (..)
107− , migrateDown
144+ , Terminally (..)
108− -- * Migration table
145+ , terminally
146+ , pureMigration
109 , MigrationsTable
147 , MigrationsTable
110− , createMigrations
148+ , defaultMain
111− , insertMigration
112− , deleteMigration
113− , selectMigration
114 ) where
149 ) where
115
150
151+import Control.Category
116import Control.Monad
152import Control.Monad
117−import Control.Monad.Base
153+import Data.ByteString (ByteString)
118−import Control.Monad.Trans.Control
154+import Data.Foldable (traverse_)
119−import Generics.SOP (K(..))
120import Data.Function ((&))
155import Data.Function ((&))
156+import Data.List ((\\))
121import Data.Text (Text)
157import Data.Text (Text)
158+import Data.Time (UTCTime)
159+import Prelude hiding ((.), id)
160+import System.Environment
161+import UnliftIO (MonadIO (..))
122
162
123−import Squeal.PostgreSQL
163+import qualified Data.Text.IO as Text (putStrLn)
164+import qualified Generics.SOP as SOP
165+import qualified GHC.Generics as GHC
124
166
167+import Squeal.PostgreSQL.Alias
168+import Squeal.PostgreSQL.Binary
169+import Squeal.PostgreSQL.Definition
170+import Squeal.PostgreSQL.Definition.Table
171+import Squeal.PostgreSQL.Definition.Table.Constraint
172+import Squeal.PostgreSQL.Expression.Comparison
173+import Squeal.PostgreSQL.Expression.Parameter
174+import Squeal.PostgreSQL.Expression.Time
175+import Squeal.PostgreSQL.Expression.Type
176+import Squeal.PostgreSQL.List
177+import Squeal.PostgreSQL.Manipulation
178+import Squeal.PostgreSQL.PQ
179+import Squeal.PostgreSQL.Query
180+import Squeal.PostgreSQL.Schema
181+import Squeal.PostgreSQL.Transaction
182+
183+-- | A `Migration` is a named "isomorphism" over a given category.
125−-- | A `Migration` should contain an inverse pair of
184+-- It should contain an inverse pair of `up` and `down`
126−-- `up` and `down` instructions and a unique `name`.
185+-- instructions and a unique `name`.
127−data Migration io schemas0 schemas1 = Migration
186+data Migration p schemas0 schemas1 = Migration
128 { name :: Text -- ^ The `name` of a `Migration`.
187 { name :: Text -- ^ The `name` of a `Migration`.
129 -- Each `name` in a `Migration` should be unique.
188 -- Each `name` in a `Migration` should be unique.
130− , up :: PQ schemas0 schemas1 io () -- ^ The `up` instruction of a `Migration`.
189+ , up :: p schemas0 schemas1 -- ^ The `up` instruction of a `Migration`.
131− , down :: PQ schemas1 schemas0 io () -- ^ The `down` instruction of a `Migration`.
190+ , down :: p schemas1 schemas0 -- ^ The `down` instruction of a `Migration`.
191+ } deriving (GHC.Generic)
192+
193+{- |
194+A `Migratory` @p@ is a `Category` for which one can execute or rewind
195+a `Path` of `Migration`s over @p@. This includes the category of pure
196+SQL `Definition`s and the category of impure `Terminally` `PQ` `IO` actions.
197+-}
198+class Category p => Migratory p where
199+
200+ {- |
201+ Run a `Path` of `Migration`s.
202+ Create the `MigrationsTable` as @public.schema_migrations@ if it does not already exist.
203+ In one transaction, for each each `Migration` query to see if the `Migration` has been executed;
204+ if not, `up` the `Migration` and insert its `name` in the `MigrationsTable`.
205+ -}
206+ migrateUp
207+ :: Path (Migration p) schemas0 schemas1
208+ -> PQ schemas0 schemas1 IO ()
209+
210+ {- |
211+ Rewind a `Path` of `Migration`s.
212+ Create the `MigrationsTable` as @public.schema_migrations@ if it does not already exist.
213+ In one transaction, for each each `Migration` query to see if the `Migration` has been executed;
214+ if so, `down` the `Migration` and delete its `name` in the `MigrationsTable`.
215+ -}
216+ migrateDown
217+ :: Path (Migration p) schemas0 schemas1
218+ -> PQ schemas1 schemas0 IO ()
219+
220+instance Migratory Definition where
221+ migrateUp = migrateUp . cmap pureMigration
222+ migrateDown = migrateDown . cmap pureMigration
223+
224+{- | `Terminally` turns an indexed monad transformer and the monad it transforms
225+into a category by restricting the return type to @()@ and permuting the type variables.
226+This is similar to how applying a monad to @()@ yields a monoid.
227+Since a `Terminally` action has a trivial return value, the only reason
228+to run one is for the side effects, in particular database and other IO effects.
229+-}
230+newtype Terminally trans monad x0 x1 = Terminally
231+ { runTerminally :: trans x0 x1 monad () }
232+ deriving GHC.Generic
233+
234+instance
235+ ( IndexedMonadTransPQ trans
236+ , Monad monad
237+ , forall x0 x1. x0 ~ x1 => Monad (trans x0 x1 monad) )
238+ => Category (Terminally trans monad) where
239+ id = Terminally (return ())
240+ Terminally g . Terminally f = Terminally $ pqThen g f
241+
242+-- | `terminally` ignores the output of a computation, returning @()@ and
243+-- wrapping it up into a `Terminally`. You can lift an action in the base monad
244+-- by using @terminally . lift@.
245+terminally
246+ :: Functor (trans x0 x1 monad)
247+ => trans x0 x1 monad ignore
248+ -> Terminally trans monad x0 x1
249+terminally = Terminally . void
250+
251+-- | A `pureMigration` turns a `Migration` involving only pure SQL
252+-- `Definition`s into a `Migration` that may be combined with arbitrary `IO`.
253+pureMigration
254+ :: Migration Definition schemas0 schemas1
255+ -> Migration (Terminally PQ IO) schemas0 schemas1
256+pureMigration migration = Migration
257+ { name = name migration
258+ , up = terminally . define $ up migration
259+ , down = terminally . define $ down migration
132 }
260 }
133
261
134−-- | Run `Migration`s by creating the `MigrationsTable`
262+instance Migratory (Terminally PQ IO) where
135−-- if it does not exist and then in a transaction, for each each `Migration`
136−-- query to see if the `Migration` is executed. If not, then
137−-- execute the `Migration` and insert its row in the `MigrationsTable`.
138−migrateUp
139− :: MonadBaseControl IO io
140− => AlignedList (Migration io) schemas0 schemas1 -- ^ migrations to run
141− -> PQ
142− ("migrations" ::: MigrationsSchema ': schemas0)
143− ("migrations" ::: MigrationsSchema ': schemas1)
144− io ()
145−migrateUp migration =
146− define createMigrations
147− & pqBind okResult
148− & pqThen (transactionallySchema_ (upMigrations migration))
149− where
150
263
151− upMigrations
264+ migrateUp migration = unsafePQ . transactionally_ $ do
152− :: MonadBaseControl IO io
265+ define createMigrations
153− => AlignedList (Migration io) schemas0 schemas1
266+ upMigrations migration
154− -> PQ
267+
155− ("migrations" ::: MigrationsSchema ': schemas0)
268+ where
156− ("migrations" ::: MigrationsSchema ': schemas1)
269+
157− io ()
270+ upMigrations
271+ :: Path (Migration (Terminally PQ IO)) schemas0 schemas1
272+ -> PQ MigrationsSchemas MigrationsSchemas IO ()
158− upMigrations = \case
273+ upMigrations = \case
159− Done -> return ()
274+ Done -> return ()
160− step :>> steps -> upMigration step & pqThen (upMigrations steps)
275+ step :>> steps -> upMigration step >> upMigrations steps
161−
276+
162− upMigration
277+ upMigration
163− :: MonadBase IO io
164− => Migration io schemas0 schemas1 -> PQ
278+ :: Migration (Terminally PQ IO) schemas0 schemas1
165− ("migrations" ::: MigrationsSchema ': schemas0)
279+ -> PQ MigrationsSchemas MigrationsSchemas IO ()
166− ("migrations" ::: MigrationsSchema ': schemas1)
167− io ()
168− upMigration step =
280+ upMigration step = do
169− queryExecuted step
281+ executed <- queryExecuted step
170− & pqBind (\ executed ->
282+ unless (executed == 1) $ do
171− if executed == 1 -- up step has already been executed
283+ unsafePQ . runTerminally $ up step
172− then PQ (\ _ -> return (K ())) -- unsafely switch schemas
173− else
174− pqEmbed (up step) -- safely switch schemas
175− & pqThen (manipulateParams insertMigration (Only (name step)))
284+ manipulateParams_ insertMigration (Only (name step))
176− -- insert execution record
285+
177− & pqBind okResult)
178−
179− queryExecuted
286+ queryExecuted
180− :: MonadBase IO io
287+ :: Migration (Terminally PQ IO) schemas0 schemas1
181− => Migration io schemas0 schemas1 -> PQ
288+ -> PQ MigrationsSchemas MigrationsSchemas IO Row
182− ("migrations" ::: MigrationsSchema ': schemas0)
183− ("migrations" ::: MigrationsSchema ': schemas0)
184− io Row
185− queryExecuted step = do
289+ queryExecuted step = do
186− result <- runQueryParams selectMigration (Only (name step))
290+ result <- runQueryParams selectMigration (Only (name step))
187− okResult result
188− ntuples result
291+ ntuples result
189−
190−-- | Rewind `Migration`s by creating the `MigrationsTable`
191−-- if it does not exist and then in a transaction, for each each `Migration`
192−-- query to see if the `Migration` is executed. If it is, then
193−-- rewind the `Migration` and delete its row in the `MigrationsTable`.
194−migrateDown
195− :: MonadBaseControl IO io
196− => AlignedList (Migration io) schemas0 schemas1 -- ^ migrations to rewind
197− -> PQ
198− ("migrations" ::: MigrationsSchema ': schemas1)
199− ("migrations" ::: MigrationsSchema ': schemas0)
200− io ()
201−migrateDown migrations =
202− define createMigrations
203− & pqBind okResult
204− & pqThen (transactionallySchema_ (downMigrations migrations))
205− where
206
292
207− downMigrations
293+ migrateDown migrations = unsafePQ . transactionally_ $ do
208− :: MonadBaseControl IO io
294+ define createMigrations
209− => AlignedList (Migration io) schemas0 schemas1 -> PQ
295+ downMigrations migrations
210− ("migrations" ::: MigrationsSchema ': schemas1)
296+
211− ("migrations" ::: MigrationsSchema ': schemas0)
297+ where
212− io ()
298+
299+ downMigrations
300+ :: Path (Migration (Terminally PQ IO)) schemas0 schemas1
301+ -> PQ MigrationsSchemas MigrationsSchemas IO ()
213− downMigrations = \case
302+ downMigrations = \case
214− Done -> return ()
303+ Done -> return ()
215− step :>> steps -> downMigrations steps & pqThen (downMigration step)
304+ step :>> steps -> downMigrations steps >> downMigration step
216−
305+
217− downMigration
306+ downMigration
218− :: MonadBase IO io
307+ :: Migration (Terminally PQ IO) schemas0 schemas1
219− => Migration io schemas0 schemas1 -> PQ
308+ -> PQ MigrationsSchemas MigrationsSchemas IO ()
220− ("migrations" ::: MigrationsSchema ': schemas1)
221− ("migrations" ::: MigrationsSchema ': schemas0)
222− io ()
223− downMigration step =
309+ downMigration step = do
224− queryExecuted step
310+ executed <- queryExecuted step
225− & pqBind (\ executed ->
311+ unless (executed == 0) $ do
226− if executed == 0 -- up step has not been executed
312+ unsafePQ . runTerminally $ down step
227− then PQ (\ _ -> return (K ())) -- unsafely switch schemas
228− else
229− pqEmbed (down step) -- safely switch schemas
230− & pqThen (manipulateParams deleteMigration (Only (name step)))
313+ manipulateParams_ deleteMigration (Only (name step))
231− -- delete execution record
314+
232− & pqBind okResult)
233−
234− queryExecuted
315+ queryExecuted
235− :: MonadBase IO io
316+ :: Migration (Terminally PQ IO) schemas0 schemas1
236− => Migration io schemas0 schemas1 -> PQ
317+ -> PQ MigrationsSchemas MigrationsSchemas IO Row
237− ("migrations" ::: MigrationsSchema ': schemas1)
238− ("migrations" ::: MigrationsSchema ': schemas1)
239− io Row
240− queryExecuted step = do
318+ queryExecuted step = do
241− result <- runQueryParams selectMigration (Only (name step))
319+ result <- runQueryParams selectMigration (Only (name step))
242− okResult result
243− ntuples result
320+ ntuples result
244−
321+
245−okResult :: MonadBase IO io => K Result results -> PQ schema schema io ()
322+unsafePQ :: (Functor m) => PQ db0 db1 m x -> PQ db0' db1' m x
246−okResult result = do
323+unsafePQ (PQ pq) = PQ $ fmap (SOP.K . SOP.unK) . pq . SOP.K . SOP.unK
247− status <- resultStatus result
248− when (not (status `elem` [CommandOk, TuplesOk])) $ do
249− errorMessageMaybe <- resultErrorMessage result
250− case errorMessageMaybe of
251− Nothing -> error "migrateDown: unknown error"
252− Just msg -> error ("migrationDown: " <> show msg)
253
324
254-- | The `TableType` for a Squeal migration.
325-- | The `TableType` for a Squeal migration.
255type MigrationsTable =
326type MigrationsTable =
@@ -258,40 +329,120 @@ type MigrationsTable =
258 , "executed_at" ::: 'Def :=> 'NotNull 'PGtimestamptz
329 , "executed_at" ::: 'Def :=> 'NotNull 'PGtimestamptz
259 ]
330 ]
260
331
332+data MigrationRow =
333+ MigrationRow { migrationName :: Text
334+ , migrationTime :: UTCTime }
335+ deriving (GHC.Generic, Show)
336+
337+instance SOP.Generic MigrationRow
338+instance SOP.HasDatatypeInfo MigrationRow
339+
261type MigrationsSchema = '["schema_migrations" ::: 'Table MigrationsTable]
340type MigrationsSchema = '["schema_migrations" ::: 'Table MigrationsTable]
341+type MigrationsSchemas = Public MigrationsSchema
262
342
263-- | Creates a `MigrationsTable` if it does not already exist.
343-- | Creates a `MigrationsTable` if it does not already exist.
264−createMigrations
344+createMigrations :: Definition MigrationsSchemas MigrationsSchemas
265− :: Has "migrations" schemas MigrationsSchema
266− => Definition schemas schemas
267createMigrations =
345createMigrations =
268− createSchemaIfNotExists #migrations >>>
269− createTableIfNotExists (#migrations ! #schema_migrations)
346+ createTableIfNotExists #schema_migrations
270 ( (text & notNullable) `as` #name :*
347 ( (text & notNullable) `as` #name :*
271 (timestampWithTimeZone & notNullable & default_ currentTimestamp)
348 (timestampWithTimeZone & notNullable & default_ currentTimestamp)
272 `as` #executed_at )
349 `as` #executed_at )
273 ( unique #name `as` #migrations_unique_name )
350 ( unique #name `as` #migrations_unique_name )
274
351
275−-- | Inserts a `Migration` into the `MigrationsTable`
352+-- | Inserts a `Migration` into the `MigrationsTable`, returning
276−insertMigration
353+-- the time at which it was inserted.
277− :: Has "migrations" schemas MigrationsSchema
354+insertMigration :: Manipulation_ MigrationsSchemas (Only Text) ()
278− => Manipulation '[] schemas '[ 'NotNull 'PGtext] '[]
279−insertMigration = insertInto_ (#migrations ! #schema_migrations) . Values_ $
355+insertMigration = insertInto_ #schema_migrations
280− (param @1) `as` #name :* defaultAs #executed_at
356+ (Values_ (Set (param @1) `as` #name :* Default `as` #executed_at))
281
357
282−-- | Deletes a `Migration` from the `MigrationsTable`
358+-- | Deletes a `Migration` from the `MigrationsTable`, returning
283−deleteMigration
359+-- the time at which it was inserted.
284− :: Has "migrations" schemas MigrationsSchema
360+deleteMigration :: Manipulation_ MigrationsSchemas (Only Text) ()
285− => Manipulation '[] schemas '[ 'NotNull 'PGtext ] '[]
286−deleteMigration = deleteFrom_ (#migrations ! #schema_migrations) (#name .== param @1)
361+deleteMigration = deleteFrom_ #schema_migrations (#name .== param @1)
287
362
288-- | Selects a `Migration` from the `MigrationsTable`, returning
363-- | Selects a `Migration` from the `MigrationsTable`, returning
289−-- the time at which it was executed.
364+-- the time at which it was inserted.
290selectMigration
365selectMigration
291− :: Has "migrations" schemas MigrationsSchema
366+ :: Query_ MigrationsSchemas (Only Text) (Only UTCTime)
292− => Query '[] '[] schemas '[ 'NotNull 'PGtext ]
293− '[ "executed_at" ::: 'NotNull 'PGtimestamptz ]
294−selectMigration = select_
367+selectMigration = select_ (#executed_at `as` #fromOnly)
295− (#executed_at `as` #executed_at)
296− ( from (table ((#migrations ! #schema_migrations) `as` #m))
368+ $ from (table (#schema_migrations))
297− & where_ (#name .== param @1))
369+ & where_ (#name .== param @1)
370+
371+selectMigrations :: Query_ MigrationsSchemas () MigrationRow
372+selectMigrations = select_
373+ (#name `as` #migrationName :* #executed_at `as` #migrationTime)
374+ (from (table #schema_migrations))
375+
376+data MigrateCommand
377+ = MigrateStatus
378+ | MigrateUp
379+ | MigrateDown deriving (GHC.Generic, Show)
380+
381+{- | `defaultMain` creates a simple executable
382+from a connection string and a list of `Migration`s. -}
383+defaultMain
384+ :: Migratory p
385+ => ByteString
386+ -- ^ connection string
387+ -> Path (Migration p) db0 db1
388+ -- ^ migrations
389+ -> IO ()
390+defaultMain connectTo migrations = do
391+ command <- readCommandFromArgs
392+ maybe (pure ()) performCommand command
393+
394+ where
395+
396+ performCommand :: MigrateCommand -> IO ()
397+ performCommand = \case
398+ MigrateStatus -> withConnection connectTo $
399+ suppressNotices >> migrateStatus
400+ MigrateUp -> withConnection connectTo $
401+ suppressNotices & pqThen (migrateUp migrations) & pqThen migrateStatus
402+ MigrateDown -> withConnection connectTo $
403+ suppressNotices & pqThen (migrateDown migrations) & pqThen migrateStatus
404+
405+ migrateStatus :: PQ schema schema IO ()
406+ migrateStatus = unsafePQ $ do
407+ runNames <- getRunMigrationNames
408+ let names = ctoList name migrations
409+ unrunNames = names \\ runNames
410+ liftIO $ displayRunned runNames >> displayUnrunned unrunNames
411+
412+ suppressNotices :: PQ schema schema IO ()
413+ suppressNotices = manipulate_ $
414+ UnsafeManipulation "SET client_min_messages TO WARNING;"
415+
416+ readCommandFromArgs :: IO (Maybe MigrateCommand)
417+ readCommandFromArgs = getArgs >>= \case
418+ ["migrate"] -> pure . Just $ MigrateUp
419+ ["rollback"] -> pure . Just $ MigrateDown
420+ ["status"] -> pure . Just $ MigrateStatus
421+ args -> displayUsage args >> pure Nothing
422+
423+ displayUsage :: [String] -> IO ()
424+ displayUsage args = do
425+ putStrLn $ "Invalid command: \"" <> unwords args <> "\". Use:"
426+ putStrLn "migrate to run all available migrations"
427+ putStrLn "rollback to rollback all available migrations"
428+ putStrLn "status to display migrations run and migrations left to run"
429+
430+ getRunMigrationNames :: (MonadIO m) => PQ db0 db0 m [Text]
431+ getRunMigrationNames =
432+ fmap migrationName <$> (unsafePQ (define createMigrations & pqThen (runQuery selectMigrations)) >>= getRows)
433+
434+ displayListOfNames :: [Text] -> IO ()
435+ displayListOfNames [] = Text.putStrLn " None"
436+ displayListOfNames xs =
437+ let singleName n = Text.putStrLn $ " - " <> n
438+ in traverse_ singleName xs
439+
440+ displayUnrunned :: [Text] -> IO ()
441+ displayUnrunned unrunned =
442+ Text.putStrLn "Migrations left to run:"
443+ >> displayListOfNames unrunned
444+
445+ displayRunned :: [Text] -> IO ()
446+ displayRunned runned =
447+ Text.putStrLn "Migrations already run:"
448+ >> displayListOfNames runned
squeal-postgresql/src/Squeal/PostgreSQL/PG.hsnew file+388
@@ -0,0 +1,388 @@
1+{-|
2+Module: Squeal.PostgreSQL.PG
3+Description: Embedding of Haskell types into Postgres's type system
4+Copyright: (c) Eitan Chatav, 2010
5+Maintainer: eitan@morphism.tech
6+Stability: experimental
7+
8+`Squeal.PostgreSQL.PG` provides type families for turning Haskell
9+`Type`s into corresponding Postgres types.
10+-}
11+{-# LANGUAGE
12+ AllowAmbiguousTypes
13+ , DeriveAnyClass
14+ , DeriveFoldable
15+ , DeriveFunctor
16+ , DeriveGeneric
17+ , DeriveTraversable
18+ , DerivingStrategies
19+ , DefaultSignatures
20+ , FlexibleContexts
21+ , FlexibleInstances
22+ , FunctionalDependencies
23+ , GADTs
24+ , LambdaCase
25+ , MultiParamTypeClasses
26+ , OverloadedStrings
27+ , ScopedTypeVariables
28+ , TypeApplications
29+ , TypeFamilies
30+ , TypeInType
31+ , TypeOperators
32+ , UndecidableInstances
33+ , UndecidableSuperClasses
34+#-}
35+
36+module Squeal.PostgreSQL.PG
37+ ( -- * PG embeddings
38+ PG
39+ , NullPG
40+ , TuplePG
41+ , RowPG
42+ -- * Storage newtypes
43+ , Money (..)
44+ , Json (..)
45+ , Jsonb (..)
46+ , Composite (..)
47+ , Enumerated (..)
48+ , VarArray (..)
49+ , FixArray (..)
50+ , LibPQ.Oid (..)
51+ -- * Type families
52+ , LabelsPG
53+ , DimPG
54+ , FixPG
55+ , TupleOf
56+ , TupleCodeOf
57+ , RowOf
58+ , ConstructorsOf
59+ , ConstructorNameOf
60+ , ConstructorNamesOf
61+ ) where
62+
63+import Data.Aeson (Value)
64+import Data.Kind (Type)
65+import Data.Int (Int16, Int32, Int64)
66+import Data.Scientific (Scientific)
67+import Data.Time (Day, DiffTime, LocalTime, TimeOfDay, TimeZone, UTCTime)
68+import Data.Vector (Vector)
69+import Data.UUID.Types (UUID)
70+import GHC.TypeLits
71+import Network.IP.Addr (NetAddr, IP)
72+
73+import qualified Data.ByteString.Lazy as Lazy (ByteString)
74+import qualified Data.ByteString as Strict (ByteString)
75+import qualified Data.Text.Lazy as Lazy (Text)
76+import qualified Data.Text as Strict (Text)
77+import qualified Database.PostgreSQL.LibPQ as LibPQ
78+import qualified GHC.Generics as GHC
79+import qualified Generics.SOP as SOP
80+import qualified Generics.SOP.Record as SOP
81+import qualified Generics.SOP.Type.Metadata as Type
82+
83+import Squeal.PostgreSQL.Alias
84+import Squeal.PostgreSQL.Schema
85+
86+-- $setup
87+-- >>> import Squeal.PostgreSQL
88+-- >>> import Data.Text (Text)
89+
90+{- | The `PG` type family embeds a subset of Haskell types
91+as Postgres types. As an open type family, `PG` is extensible.
92+
93+>>> :kind! PG LocalTime
94+PG LocalTime :: PGType
95+= 'PGtimestamp
96+
97+>>> newtype MyDouble = My Double
98+>>> :set -XTypeFamilies
99+>>> type instance PG MyDouble = 'PGfloat8
100+-}
101+type family PG (hask :: Type) :: PGType
102+-- | `PGbool`
103+type instance PG Bool = 'PGbool
104+-- | `PGint2`
105+type instance PG Int16 = 'PGint2
106+-- | `PGint4`
107+type instance PG Int32 = 'PGint4
108+-- | `PGint8`
109+type instance PG Int64 = 'PGint8
110+-- | `PGint2`
111+type instance PG LibPQ.Oid = 'PGoid
112+-- | `PGnumeric`
113+type instance PG Scientific = 'PGnumeric
114+-- | `PGfloat4`
115+type instance PG Float = 'PGfloat4
116+-- | `PGfloat8`
117+type instance PG Double = 'PGfloat8
118+-- | `PGchar` @1@
119+type instance PG Char = 'PGchar 1
120+-- | `PGtext`
121+type instance PG Strict.Text = 'PGtext
122+-- | `PGtext`
123+type instance PG Lazy.Text = 'PGtext
124+-- | `PGtext`
125+type instance PG String = 'PGtext
126+-- | `PGbytea`
127+type instance PG Strict.ByteString = 'PGbytea
128+-- | `PGbytea`
129+type instance PG Lazy.ByteString = 'PGbytea
130+-- | `PGtimestamp`
131+type instance PG LocalTime = 'PGtimestamp
132+-- | `PGtimestamptz`
133+type instance PG UTCTime = 'PGtimestamptz
134+-- | `PGdate`
135+type instance PG Day = 'PGdate
136+-- | `PGtime`
137+type instance PG TimeOfDay = 'PGtime
138+-- | `PGtimetz`
139+type instance PG (TimeOfDay, TimeZone) = 'PGtimetz
140+-- | `PGinterval`
141+type instance PG DiffTime = 'PGinterval
142+-- | `PGuuid`
143+type instance PG UUID = 'PGuuid
144+-- | `PGinet`
145+type instance PG (NetAddr IP) = 'PGinet
146+-- | `PGjson`
147+type instance PG Value = 'PGjson
148+
149+{-| The `LabelsPG` type family calculates the constructors of a
150+Haskell enum type.
151+
152+>>> data Schwarma = Beef | Lamb | Chicken deriving GHC.Generic
153+>>> instance SOP.Generic Schwarma
154+>>> instance SOP.HasDatatypeInfo Schwarma
155+>>> :kind! LabelsPG Schwarma
156+LabelsPG Schwarma :: [Type.ConstructorName]
157+= '["Beef", "Lamb", "Chicken"]
158+-}
159+type family LabelsPG (hask :: Type) :: [Type.ConstructorName] where
160+ LabelsPG hask =
161+ ConstructorNamesOf (ConstructorsOf (SOP.DatatypeInfoOf hask))
162+
163+{- |
164+`RowPG` turns a Haskell `Type` into a `RowType`.
165+
166+`RowPG` may be applied to normal Haskell record types provided they
167+have `SOP.Generic` and `SOP.HasDatatypeInfo` instances;
168+
169+>>> data Person = Person { name :: Strict.Text, age :: Int32 } deriving GHC.Generic
170+>>> instance SOP.Generic Person
171+>>> instance SOP.HasDatatypeInfo Person
172+>>> :kind! RowPG Person
173+RowPG Person :: [(Symbol, NullityType)]
174+= '["name" ::: 'NotNull 'PGtext, "age" ::: 'NotNull 'PGint4]
175+-}
176+type family RowPG (hask :: Type) :: RowType where
177+ RowPG hask = RowOf (SOP.RecordCodeOf hask)
178+
179+-- | `RowOf` applies `NullPG` to the fields of a list.
180+type family RowOf (record :: [(Symbol, Type)]) :: RowType where
181+ RowOf (col ::: ty ': col1 ::: ty1 ': col2 ::: ty2 ': col3 ::: ty3 ': col4 ::: ty4 ': record) =
182+ col ::: NullPG ty ': col1 ::: NullPG ty1 ': col2 ::: NullPG ty2 ': col3 ::: NullPG ty3 ': col4 ::: NullPG ty4 ': RowOf record
183+ RowOf (col ::: ty ': col1 ::: ty1 ': col2 ::: ty2 ': col3 ::: ty3 ': record) =
184+ col ::: NullPG ty ': col1 ::: NullPG ty1 ': col2 ::: NullPG ty2 ': col3 ::: NullPG ty3 ': RowOf record
185+ RowOf (col ::: ty ': col1 ::: ty1 ': col2 ::: ty2 ': record) =
186+ col ::: NullPG ty ': col1 ::: NullPG ty1 ': col2 ::: NullPG ty2 ': RowOf record
187+ RowOf (col ::: ty ': col1 ::: ty1 ': record) =
188+ col ::: NullPG ty ': col1::: NullPG ty1 ': RowOf record
189+ RowOf (col ::: ty ': record) = col ::: NullPG ty ': RowOf record
190+ RowOf '[] = '[]
191+
192+{- | `NullPG` turns a Haskell type into a `NullityType`.
193+
194+>>> :kind! NullPG Double
195+NullPG Double :: NullityType
196+= 'NotNull 'PGfloat8
197+>>> :kind! NullPG (Maybe Double)
198+NullPG (Maybe Double) :: NullityType
199+= 'Null 'PGfloat8
200+-}
201+type family NullPG (hask :: Type) :: NullityType where
202+ NullPG (Maybe hask) = 'Null (PG hask)
203+ NullPG hask = 'NotNull (PG hask)
204+
205+{- | `TuplePG` turns a Haskell tuple type (including record types) into
206+the corresponding list of `NullityType`s.
207+
208+>>> :kind! TuplePG (Double, Maybe Char)
209+TuplePG (Double, Maybe Char) :: [NullityType]
210+= '[ 'NotNull 'PGfloat8, 'Null ('PGchar 1)]
211+-}
212+type family TuplePG (hask :: Type) :: [NullityType] where
213+ TuplePG hask = TupleOf (TupleCodeOf hask (SOP.Code hask))
214+
215+-- | `TupleOf` turns a list of Haskell `Type`s into a list of `NullityType`s.
216+type family TupleOf (tuple :: [Type]) :: [NullityType] where
217+ TupleOf (hask ': hask1 ': hask2 ': hask3 ': hask4 ': hask5 ': tuple) =
218+ NullPG hask ': NullPG hask1 ': NullPG hask2 ': NullPG hask3 ': NullPG hask4 ': NullPG hask5 ': TupleOf tuple
219+ TupleOf (hask ': hask1 ': hask2 ': hask3 ': hask4 ': tuple) =
220+ NullPG hask ': NullPG hask1 ': NullPG hask2 ': NullPG hask3 ': NullPG hask4 ': TupleOf tuple
221+ TupleOf (hask ': hask1 ': hask2 ': hask3 ': tuple) =
222+ NullPG hask ': NullPG hask1 ': NullPG hask2 ': NullPG hask3 ': TupleOf tuple
223+ TupleOf (hask ': hask1 ': hask2 ': tuple) =
224+ NullPG hask ': NullPG hask1 ': NullPG hask2 ': TupleOf tuple
225+ TupleOf (hask ': hask1 ': tuple) = NullPG hask ': NullPG hask1 ': TupleOf tuple
226+ TupleOf (hask ': tuple) = NullPG hask ': TupleOf tuple
227+ TupleOf '[] = '[]
228+
229+-- | `TupleCodeOf` takes the `SOP.Code` of a haskell `Type`
230+-- and if it's a simple product returns it, otherwise giving a `TypeError`.
231+type family TupleCodeOf (hask :: Type) (code :: [[Type]]) :: [Type] where
232+ TupleCodeOf hask '[tuple] = tuple
233+ TupleCodeOf hask '[] =
234+ TypeError
235+ ( 'Text "The type `" ':<>: 'ShowType hask ':<>: 'Text "' is not a tuple type."
236+ ':$$: 'Text "It is a void type with no constructors."
237+ )
238+ TupleCodeOf hask (_ ': _ ': _) =
239+ TypeError
240+ ( 'Text "The type `" ':<>: 'ShowType hask ':<>: 'Text "' is not a tuple type."
241+ ':$$: 'Text "It is a sum type with more than one constructor."
242+ )
243+
244+-- | Calculates constructors of a datatype.
245+type family ConstructorsOf (datatype :: Type.DatatypeInfo)
246+ :: [Type.ConstructorInfo] where
247+ ConstructorsOf ('Type.ADT _module _datatype constructors) =
248+ constructors
249+ ConstructorsOf ('Type.Newtype _module _datatype constructor) =
250+ '[constructor]
251+
252+-- | Calculates the name of a nullary constructor, otherwise
253+-- generates a type error.
254+type family ConstructorNameOf (constructor :: Type.ConstructorInfo)
255+ :: Type.ConstructorName where
256+ ConstructorNameOf ('Type.Constructor name) = name
257+ ConstructorNameOf ('Type.Infix name _assoc _fix) = TypeError
258+ ('Text "ConstructorNameOf error: non-nullary constructor "
259+ ':<>: 'Text name)
260+ ConstructorNameOf ('Type.Record name _fields) = TypeError
261+ ('Text "ConstructorNameOf error: non-nullary constructor "
262+ ':<>: 'Text name)
263+
264+-- | Calculate the names of nullary constructors.
265+type family ConstructorNamesOf (constructors :: [Type.ConstructorInfo])
266+ :: [Type.ConstructorName] where
267+ ConstructorNamesOf '[] = '[]
268+ ConstructorNamesOf (constructor ': constructors) =
269+ ConstructorNameOf constructor ': ConstructorNamesOf constructors
270+
271+-- | `DimPG` turns Haskell nested homogeneous tuples into a list of lengths.
272+type family DimPG (hask :: Type) :: [Nat] where
273+ DimPG (x,x) = 2 ': DimPG x
274+ DimPG (x,x,x) = 3 ': DimPG x
275+ DimPG (x,x,x,x) = 4 ': DimPG x
276+ DimPG (x,x,x,x,x) = 5 ': DimPG x
277+ DimPG (x,x,x,x,x,x) = 6 ': DimPG x
278+ DimPG (x,x,x,x,x,x,x) = 7 ': DimPG x
279+ DimPG (x,x,x,x,x,x,x,x) = 8 ': DimPG x
280+ DimPG (x,x,x,x,x,x,x,x,x) = 9 ': DimPG x
281+ DimPG (x,x,x,x,x,x,x,x,x,x) = 10 ': DimPG x
282+ DimPG x = '[]
283+
284+-- | `FixPG` extracts `NullPG` of the base type of nested homogeneous tuples.
285+type family FixPG (hask :: Type) :: NullityType where
286+ FixPG (x,x) = FixPG x
287+ FixPG (x,x,x) = FixPG x
288+ FixPG (x,x,x,x) = FixPG x
289+ FixPG (x,x,x,x,x) = FixPG x
290+ FixPG (x,x,x,x,x,x) = FixPG x
291+ FixPG (x,x,x,x,x,x,x) = FixPG x
292+ FixPG (x,x,x,x,x,x,x,x) = FixPG x
293+ FixPG (x,x,x,x,x,x,x,x,x) = FixPG x
294+ FixPG (x,x,x,x,x,x,x,x,x,x) = FixPG x
295+ FixPG (x,x,x,x,x,x,x,x,x,x,x) = FixPG x
296+ FixPG x = NullPG x
297+
298+{- | The `Money` newtype stores a monetary value in terms
299+of the number of cents, i.e. @$2,000.20@ would be expressed as
300+@Money { cents = 200020 }@.
301+
302+>>> import Control.Monad (void)
303+>>> import Control.Monad.IO.Class (liftIO)
304+>>> import Squeal.PostgreSQL
305+>>> :{
306+let
307+ roundTrip :: Query_ (Public '[]) (Only Money) (Only Money)
308+ roundTrip = values_ $ parameter @1 money `as` #fromOnly
309+:}
310+
311+>>> let input = Only (Money 20020)
312+
313+>>> :{
314+withConnection "host=localhost port=5432 dbname=exampledb" $ do
315+ result <- runQueryParams roundTrip input
316+ Just output <- firstRow result
317+ liftIO . print $ input == output
318+:}
319+True
320+-}
321+newtype Money = Money { cents :: Int64 }
322+ deriving stock (Eq, Ord, Show, Read, GHC.Generic)
323+ deriving anyclass (SOP.HasDatatypeInfo, SOP.Generic)
324+-- | `PGmoney`
325+type instance PG Money = 'PGmoney
326+
327+{- | The `Json` newtype is an indication that the Haskell
328+type it's applied to should be stored as a `PGjson`.
329+-}
330+newtype Json hask = Json {getJson :: hask}
331+ deriving stock (Eq, Ord, Show, Read, GHC.Generic)
332+ deriving anyclass (SOP.HasDatatypeInfo, SOP.Generic)
333+-- | `PGjson`
334+type instance PG (Json hask) = 'PGjson
335+
336+{- | The `Jsonb` newtype is an indication that the Haskell
337+type it's applied to should be stored as a `PGjsonb`.
338+-}
339+newtype Jsonb hask = Jsonb {getJsonb :: hask}
340+ deriving stock (Eq, Ord, Show, Read, GHC.Generic)
341+ deriving anyclass (SOP.HasDatatypeInfo, SOP.Generic)
342+-- | `PGjsonb`
343+type instance PG (Jsonb hask) = 'PGjsonb
344+
345+{- | The `Composite` newtype is an indication that the Haskell
346+type it's applied to should be stored as a `PGcomposite`.
347+-}
348+newtype Composite record = Composite {getComposite :: record}
349+ deriving stock (Eq, Ord, Show, Read, GHC.Generic)
350+ deriving anyclass (SOP.HasDatatypeInfo, SOP.Generic)
351+-- | `PGcomposite` @(@`RowPG` @hask)@
352+type instance PG (Composite hask) = 'PGcomposite (RowPG hask)
353+
354+{- | The `Enumerated` newtype is an indication that the Haskell
355+type it's applied to should be stored as a `PGenum`.
356+-}
357+newtype Enumerated enum = Enumerated {getEnumerated :: enum}
358+ deriving stock (Eq, Ord, Show, Read, GHC.Generic)
359+ deriving anyclass (SOP.HasDatatypeInfo, SOP.Generic)
360+-- | `PGenum` @(@`LabelsPG` @hask)@
361+type instance PG (Enumerated hask) = 'PGenum (LabelsPG hask)
362+
363+{- | The `VarArray` newtype is an indication that the Haskell
364+type it's applied to should be stored as a `PGvararray`.
365+
366+>>> :kind! PG (VarArray (Vector Double))
367+PG (VarArray (Vector Double)) :: PGType
368+= 'PGvararray ('NotNull 'PGfloat8)
369+-}
370+newtype VarArray arr = VarArray {getVarArray :: arr}
371+ deriving stock (Eq, Ord, Show, Read, GHC.Generic)
372+ deriving anyclass (SOP.HasDatatypeInfo, SOP.Generic)
373+-- | `PGvararray` @(@`NullPG` @hask)@
374+type instance PG (VarArray (Vector hask)) = 'PGvararray (NullPG hask)
375+type instance PG (VarArray [hask]) = 'PGvararray (NullPG hask)
376+
377+{- | The `FixArray` newtype is an indication that the Haskell
378+type it's applied to should be stored as a `PGfixarray`.
379+
380+>>> :kind! PG (FixArray ((Double, Double), (Double, Double)))
381+PG (FixArray ((Double, Double), (Double, Double))) :: PGType
382+= 'PGfixarray '[2, 2] ('NotNull 'PGfloat8)
383+-}
384+newtype FixArray arr = FixArray {getFixArray :: arr}
385+ deriving stock (Eq, Ord, Show, Read, GHC.Generic)
386+ deriving anyclass (SOP.HasDatatypeInfo, SOP.Generic)
387+-- | `PGfixarray` @(@`DimPG` @hask) (@`FixPG` @hask)@
388+type instance PG (FixArray hask) = 'PGfixarray (DimPG hask) (FixPG hask)
squeal-postgresql/src/Squeal/PostgreSQL/PQ.hs+138−103
@@ -24,6 +24,7 @@ of executing Squeal commands.
24 , FunctionalDependencies
24 , FunctionalDependencies
25 , FlexibleContexts
25 , FlexibleContexts
26 , FlexibleInstances
26 , FlexibleInstances
27+ , InstanceSigs
27 , OverloadedStrings
28 , OverloadedStrings
28 , RankNTypes
29 , RankNTypes
29 , ScopedTypeVariables
30 , ScopedTypeVariables
@@ -48,8 +49,6 @@ module Squeal.PostgreSQL.PQ
48 , evalPQ
49 , evalPQ
49 , IndexedMonadTransPQ (..)
50 , IndexedMonadTransPQ (..)
50 , MonadPQ (..)
51 , MonadPQ (..)
51− , PQRun
52− , pqliftWith
53 -- * Results
52 -- * Results
54 , LibPQ.Result
53 , LibPQ.Result
55 , LibPQ.Row
54 , LibPQ.Row
@@ -65,18 +64,21 @@ module Squeal.PostgreSQL.PQ
65 , resultErrorCode
64 , resultErrorCode
66 -- * Exceptions
65 -- * Exceptions
67 , SquealException (..)
66 , SquealException (..)
67+ , PQState (..)
68+ , okResult
68 , catchSqueal
69 , catchSqueal
69 , handleSqueal
70 , handleSqueal
71+ , trySqueal
70 ) where
72 ) where
71
73
72−import Control.Exception.Lifted
74+import Control.Exception (Exception, throw)
73−import Control.Monad.Base
74import Control.Monad.Except
75import Control.Monad.Except
75import Control.Monad.Morph
76import Control.Monad.Morph
76−import Control.Monad.Trans.Control
77+import UnliftIO (MonadUnliftIO (..), bracket, catch, handle, try)
77import Data.ByteString (ByteString)
78import Data.ByteString (ByteString)
78import Data.Foldable
79import Data.Foldable
79import Data.Function ((&))
80import Data.Function ((&))
81+import Data.Functor ((<&>))
80import Data.Kind
82import Data.Kind
81import Data.Text (pack, Text)
83import Data.Text (pack, Text)
82import Data.Traversable
84import Data.Traversable
@@ -85,6 +87,7 @@ import PostgreSQL.Binary.Encoding (encodingBytes)
85
87
86import qualified Control.Monad.Fail as Fail
88import qualified Control.Monad.Fail as Fail
87import qualified Database.PostgreSQL.LibPQ as LibPQ
89import qualified Database.PostgreSQL.LibPQ as LibPQ
90+import qualified PostgreSQL.Binary.Encoding as Encoding
88
91
89import Squeal.PostgreSQL.Binary
92import Squeal.PostgreSQL.Binary
90import Squeal.PostgreSQL.Definition
93import Squeal.PostgreSQL.Definition
@@ -105,6 +108,9 @@ import qualified Control.Monad.Trans.Writer.Strict as Strict
105import qualified Control.Monad.Trans.RWS.Lazy as Lazy
108import qualified Control.Monad.Trans.RWS.Lazy as Lazy
106import qualified Control.Monad.Trans.RWS.Strict as Strict
109import qualified Control.Monad.Trans.RWS.Strict as Strict
107
110
111+-- $setup
112+-- >>> import Squeal.PostgreSQL
113+
108{- | Makes a new connection to the database server.
114{- | Makes a new connection to the database server.
109
115
110This function opens a new database connection using the parameters taken
116This function opens a new database connection using the parameters taken
@@ -132,19 +138,19 @@ with the wrong schema!
132-}
138-}
133connectdb
139connectdb
134 :: forall schemas io
140 :: forall schemas io
135− . MonadBase IO io
141+ . MonadIO io
136 => ByteString -- ^ conninfo
142 => ByteString -- ^ conninfo
137 -> io (K LibPQ.Connection schemas)
143 -> io (K LibPQ.Connection schemas)
138−connectdb = fmap K . liftBase . LibPQ.connectdb
144+connectdb = fmap K . liftIO . LibPQ.connectdb
139
145
140-- | Closes the connection to the server.
146-- | Closes the connection to the server.
141−finish :: MonadBase IO io => K LibPQ.Connection schemas -> io ()
147+finish :: MonadIO io => K LibPQ.Connection schemas -> io ()
142−finish = liftBase . LibPQ.finish . unK
148+finish = liftIO . LibPQ.finish . unK
143
149
144-- | Do `connectdb` and `finish` before and after a computation.
150-- | Do `connectdb` and `finish` before and after a computation.
145withConnection
151withConnection
146 :: forall schemas0 schemas1 io x
152 :: forall schemas0 schemas1 io x
147− . MonadBaseControl IO io
153+ . MonadUnliftIO io
148 => ByteString
154 => ByteString
149 -> PQ schemas0 schemas1 io x
155 -> PQ schemas0 schemas1 io x
150 -> io x
156 -> io x
@@ -202,8 +208,7 @@ evalPQ (PQ pq) conn = unK <$> pq conn
202-- [enriched category](https://ncatlab.org/nlab/show/enriched+category).
208-- [enriched category](https://ncatlab.org/nlab/show/enriched+category).
203-- An indexed monad transformer transforms a `Monad` into an indexed monad.
209-- An indexed monad transformer transforms a `Monad` into an indexed monad.
204-- And, `IndexedMonadTransPQ` is a class for indexed monad transformers that
210-- And, `IndexedMonadTransPQ` is a class for indexed monad transformers that
205−-- support running `Definition`s using `define` and embedding a computation
211+-- support running `Definition`s using `define`.
206−-- in a larger schema using `pqEmbed`.
207class IndexedMonadTransPQ pq where
212class IndexedMonadTransPQ pq where
208
213
209 -- | indexed analog of `<*>`
214 -- | indexed analog of `<*>`
@@ -243,19 +248,16 @@ class IndexedMonadTransPQ pq where
243 -> x -> pq schemas0 schemas2 m z
248 -> x -> pq schemas0 schemas2 m z
244 pqAndThen g f x = pqBind g (f x)
249 pqAndThen g f x = pqBind g (f x)
245
250
246− -- | Safely embed a computation in a larger schema.
247− pqEmbed
248− :: Monad m
249− => pq schemas0 schemas1 m x
250− -> pq (schema ': schemas0) (schema : schemas1) m x
251−
252− -- | Run a `Definition` with `LibPQ.exec`, we expect that libpq obeys the law
251+ -- | Run a `Definition` with `LibPQ.exec`.
252+ --
253+ -- It should be functorial in effect.
253 --
254 --
255+ -- @define id = return ()@
254− -- @define statement1 & pqThen (define statement2) = define (statement1 >>> statement2)@
256+ -- @define (statement1 >>> statement2) = define statement1 & pqThen (define statement2)@
255 define
257 define
256− :: MonadBase IO io
258+ :: MonadIO io
257 => Definition schemas0 schemas1
259 => Definition schemas0 schemas1
258− -> pq schemas0 schemas1 io (K LibPQ.Result '[])
260+ -> pq schemas0 schemas1 io ()
259
261
260instance IndexedMonadTransPQ PQ where
262instance IndexedMonadTransPQ PQ where
261
263
@@ -268,16 +270,12 @@ instance IndexedMonadTransPQ PQ where
268 K x' <- x conn
270 K x' <- x conn
269 unPQ (f x') (K (unK conn))
271 unPQ (f x') (K (unK conn))
270
272
271− pqEmbed (PQ pq) = PQ $ \ (K conn) -> do
272− K x <- pq (K conn)
273− return $ K x
274−
275 define (UnsafeDefinition q) = PQ $ \ (K conn) -> do
273 define (UnsafeDefinition q) = PQ $ \ (K conn) -> do
276− resultMaybe <- liftBase $ LibPQ.exec conn q
274+ resultMaybe <- liftIO $ LibPQ.exec conn q
277 case resultMaybe of
275 case resultMaybe of
278 Nothing -> throw $ ResultException
276 Nothing -> throw $ ResultException
279 "define: LibPQ.exec returned no results"
277 "define: LibPQ.exec returned no results"
280− Just result -> return $ K (K result)
278+ Just result -> K <$> okResult_ result
281
279
282{- | `MonadPQ` is an @mtl@ style constraint, similar to
280{- | `MonadPQ` is an @mtl@ style constraint, similar to
283`Control.Monad.State.Class.MonadState`, for using `Database.PostgreSQL.LibPQ` to
281`Control.Monad.State.Class.MonadState`, for using `Database.PostgreSQL.LibPQ` to
@@ -286,8 +284,12 @@ instance IndexedMonadTransPQ PQ where
286 with a `ToParams` constraint. It calls `LibPQ.execParams` and
284 with a `ToParams` constraint. It calls `LibPQ.execParams` and
287 doesn't afraid of anything.
285 doesn't afraid of anything.
288
286
287+* `manipulateParams_` is like `manipulateParams` for a returning-free statement.
288+
289* `manipulate` is like `manipulateParams` for a parameter-free statement.
289* `manipulate` is like `manipulateParams` for a parameter-free statement.
290
290
291+* `manipulate_` is like `manipulate` for a returning-free statement.
292+
291* `runQueryParams` is like `manipulateParams` for query statements.
293* `runQueryParams` is like `manipulateParams` for query statements.
292
294
293* `runQuery` is like `runQueryParams` for a parameter-free statement.
295* `runQuery` is like `runQueryParams` for a parameter-free statement.
@@ -301,7 +303,7 @@ instance IndexedMonadTransPQ PQ where
301* `forPrepared` is a flipped `traversePrepared`
303* `forPrepared` is a flipped `traversePrepared`
302
304
303* `traversePrepared_` is like `traversePrepared` but works on `Foldable`
305* `traversePrepared_` is like `traversePrepared` but works on `Foldable`
304− containers and returns unit.
306+ containers for a returning-free statement.
305
307
306* `forPrepared_` is a flipped `traversePrepared_`.
308* `forPrepared_` is a flipped `traversePrepared_`.
307
309
@@ -315,24 +317,34 @@ a default instance.
315-}
317-}
316class Monad pq => MonadPQ schemas pq | pq -> schemas where
318class Monad pq => MonadPQ schemas pq | pq -> schemas where
317 manipulateParams
319 manipulateParams
318− :: ToParams x params
320+ :: (ToParams x params, All OidOfParam params)
319 => Manipulation '[] schemas params ys
321 => Manipulation '[] schemas params ys
320 -- ^ `insertInto`, `update` or `deleteFrom`
322 -- ^ `insertInto`, `update` or `deleteFrom`
321 -> x -> pq (K LibPQ.Result ys)
323 -> x -> pq (K LibPQ.Result ys)
322 default manipulateParams
324 default manipulateParams
323 :: (MonadTrans t, MonadPQ schemas pq1, pq ~ t pq1)
325 :: (MonadTrans t, MonadPQ schemas pq1, pq ~ t pq1)
324− => ToParams x params
326+ => (ToParams x params, All OidOfParam params)
325 => Manipulation '[] schemas params ys
327 => Manipulation '[] schemas params ys
326 -- ^ `insertInto`, `update` or `deleteFrom`
328 -- ^ `insertInto`, `update` or `deleteFrom`
327 -> x -> pq (K LibPQ.Result ys)
329 -> x -> pq (K LibPQ.Result ys)
328 manipulateParams manipulation params = lift $
330 manipulateParams manipulation params = lift $
329 manipulateParams manipulation params
331 manipulateParams manipulation params
330
332
333+ manipulateParams_
334+ :: (ToParams x params, All OidOfParam params)
335+ => Manipulation '[] schemas params '[]
336+ -- ^ `insertInto`, `update` or `deleteFrom`
337+ -> x -> pq ()
338+ manipulateParams_ q x = void $ manipulateParams q x
339+
331 manipulate :: Manipulation '[] schemas '[] ys -> pq (K LibPQ.Result ys)
340 manipulate :: Manipulation '[] schemas '[] ys -> pq (K LibPQ.Result ys)
332 manipulate statement = manipulateParams statement ()
341 manipulate statement = manipulateParams statement ()
333
342
343+ manipulate_ :: Manipulation '[] schemas '[] '[] -> pq ()
344+ manipulate_ = void . manipulate
345+
334 runQueryParams
346 runQueryParams
335− :: ToParams x params
347+ :: (ToParams x params, All OidOfParam params)
336 => Query '[] '[] schemas params ys
348 => Query '[] '[] schemas params ys
337 -- ^ `select` and friends
349 -- ^ `select` and friends
338 -> x -> pq (K LibPQ.Result ys)
350 -> x -> pq (K LibPQ.Result ys)
@@ -345,19 +357,19 @@ class Monad pq => MonadPQ schemas pq | pq -> schemas where
345 runQuery q = runQueryParams q ()
357 runQuery q = runQueryParams q ()
346
358
347 traversePrepared
359 traversePrepared
348− :: (ToParams x params, Traversable list)
360+ :: (ToParams x params, Traversable list, All OidOfParam params)
349 => Manipulation '[] schemas params ys
361 => Manipulation '[] schemas params ys
350 -- ^ `insertInto`, `update`, or `deleteFrom`, and friends
362 -- ^ `insertInto`, `update`, or `deleteFrom`, and friends
351 -> list x -> pq (list (K LibPQ.Result ys))
363 -> list x -> pq (list (K LibPQ.Result ys))
352 default traversePrepared
364 default traversePrepared
353 :: (MonadTrans t, MonadPQ schemas pq1, pq ~ t pq1)
365 :: (MonadTrans t, MonadPQ schemas pq1, pq ~ t pq1)
354− => (ToParams x params, Traversable list)
366+ => (ToParams x params, Traversable list, All OidOfParam params)
355 => Manipulation '[] schemas params ys -> list x -> pq (list (K LibPQ.Result ys))
367 => Manipulation '[] schemas params ys -> list x -> pq (list (K LibPQ.Result ys))
356 traversePrepared manipulation params = lift $
368 traversePrepared manipulation params = lift $
357 traversePrepared manipulation params
369 traversePrepared manipulation params
358
370
359 forPrepared
371 forPrepared
360− :: (ToParams x params, Traversable list)
372+ :: (ToParams x params, Traversable list, All OidOfParam params)
361 => list x
373 => list x
362 -> Manipulation '[] schemas params ys
374 -> Manipulation '[] schemas params ys
363 -- ^ `insertInto`, `update` or `deleteFrom`
375 -- ^ `insertInto`, `update` or `deleteFrom`
@@ -365,13 +377,13 @@ class Monad pq => MonadPQ schemas pq | pq -> schemas where
365 forPrepared = flip traversePrepared
377 forPrepared = flip traversePrepared
366
378
367 traversePrepared_
379 traversePrepared_
368− :: (ToParams x params, Foldable list)
380+ :: (ToParams x params, Foldable list, All OidOfParam params)
369 => Manipulation '[] schemas params '[]
381 => Manipulation '[] schemas params '[]
370 -- ^ `insertInto`, `update` or `deleteFrom`
382 -- ^ `insertInto`, `update` or `deleteFrom`
371 -> list x -> pq ()
383 -> list x -> pq ()
372 default traversePrepared_
384 default traversePrepared_
373 :: (MonadTrans t, MonadPQ schemas pq1, pq ~ t pq1)
385 :: (MonadTrans t, MonadPQ schemas pq1, pq ~ t pq1)
374− => (ToParams x params, Foldable list)
386+ => (ToParams x params, Foldable list, All OidOfParam params)
375 => Manipulation '[] schemas params '[]
387 => Manipulation '[] schemas params '[]
376 -- ^ `insertInto`, `update` or `deleteFrom`
388 -- ^ `insertInto`, `update` or `deleteFrom`
377 -> list x -> pq ()
389 -> list x -> pq ()
@@ -379,7 +391,7 @@ class Monad pq => MonadPQ schemas pq | pq -> schemas where
379 traversePrepared_ manipulation params
391 traversePrepared_ manipulation params
380
392
381 forPrepared_
393 forPrepared_
382− :: (ToParams x params, Foldable list)
394+ :: (ToParams x params, Foldable list, All OidOfParam params)
383 => list x
395 => list x
384 -> Manipulation '[] schemas params '[]
396 -> Manipulation '[] schemas params '[]
385 -- ^ `insertInto`, `update` or `deleteFrom`
397 -- ^ `insertInto`, `update` or `deleteFrom`
@@ -392,61 +404,83 @@ class Monad pq => MonadPQ schemas pq | pq -> schemas where
392 => (LibPQ.Connection -> IO a) -> pq a
404 => (LibPQ.Connection -> IO a) -> pq a
393 liftPQ = lift . liftPQ
405 liftPQ = lift . liftPQ
394
406
395−instance (MonadBase IO io, schemas0 ~ schemas, schemas1 ~ schemas)
407+instance (MonadIO io, schemas0 ~ schemas, schemas1 ~ schemas)
396 => MonadPQ schemas (PQ schemas0 schemas1 io) where
408 => MonadPQ schemas (PQ schemas0 schemas1 io) where
397
409
398 manipulateParams
410 manipulateParams
399 (UnsafeManipulation q :: Manipulation '[] schemas ps ys) (params :: x) =
411 (UnsafeManipulation q :: Manipulation '[] schemas ps ys) (params :: x) =
400 PQ $ \ (K conn) -> do
412 PQ $ \ (K conn) -> do
401 let
413 let
402− toParam' encoding =
414+ paramSet
415+ :: forall param. OidOfParam param
416+ => K (Maybe Encoding.Encoding) param
417+ -> K (Maybe (LibPQ.Oid, ByteString, LibPQ.Format)) param
418+ paramSet (K maybeEncoding) = K $
419+ maybeEncoding <&> \encoding ->
403− (LibPQ.invalidOid, encodingBytes encoding, LibPQ.Binary)
420+ (oidOfParam @param, encodingBytes encoding, LibPQ.Binary)
421+ params'
422+ = hcollapse
423+ . hcmap (Proxy @OidOfParam) paramSet
404− params' = fmap (fmap toParam') (hcollapse (toParams @x @ps params))
424+ $ toParams @x @ps params
405 q' = q <> ";"
425 q' = q <> ";"
406− resultMaybe <- liftBase $ LibPQ.execParams conn q' params' LibPQ.Binary
426+ resultMaybe <- liftIO $ LibPQ.execParams conn q' params' LibPQ.Binary
407 case resultMaybe of
427 case resultMaybe of
408 Nothing -> throw $ ResultException
428 Nothing -> throw $ ResultException
409 "manipulateParams: LibPQ.execParams returned no results"
429 "manipulateParams: LibPQ.execParams returned no results"
410 Just result -> do
430 Just result -> do
411− tryResult result
431+ okResult_ result
412 return $ K (K result)
432 return $ K (K result)
413
433
414 traversePrepared
434 traversePrepared
415 (UnsafeManipulation q :: Manipulation '[] schemas xs ys) (list :: list x) =
435 (UnsafeManipulation q :: Manipulation '[] schemas xs ys) (list :: list x) =
416− PQ $ \ (K conn) -> liftBase $ do
436+ PQ $ \ (K conn) -> liftIO $ do
437+ let
417− let temp = "temporary_statement"
438+ temp = "temporary_statement"
439+ paramOid :: forall p. OidOfParam p => K LibPQ.Oid p
440+ paramOid = K (oidOfParam @p)
441+ paramOids :: NP (K LibPQ.Oid) xs
442+ paramOids = hcpure (Proxy @OidOfParam) paramOid
443+ paramOids' :: [LibPQ.Oid]
444+ paramOids' = hcollapse paramOids
418− prepResultMaybe <- LibPQ.prepare conn temp q Nothing
445+ prepResultMaybe <- LibPQ.prepare conn temp q (Just paramOids')
419 case prepResultMaybe of
446 case prepResultMaybe of
420 Nothing -> throw $ ResultException
447 Nothing -> throw $ ResultException
421 "traversePrepared: LibPQ.prepare returned no results"
448 "traversePrepared: LibPQ.prepare returned no results"
422− Just prepResult -> tryResult prepResult
449+ Just prepResult -> okResult_ prepResult
423 results <- for list $ \ params -> do
450 results <- for list $ \ params -> do
424 let
451 let
425− toParam' encoding = (encodingBytes encoding,LibPQ.Binary)
452+ toParam' encoding = (encodingBytes encoding, LibPQ.Binary)
426 params' = fmap (fmap toParam') (hcollapse (toParams @x @xs params))
453 params' = fmap (fmap toParam') (hcollapse (toParams @x @xs params))
427 resultMaybe <- LibPQ.execPrepared conn temp params' LibPQ.Binary
454 resultMaybe <- LibPQ.execPrepared conn temp params' LibPQ.Binary
428 case resultMaybe of
455 case resultMaybe of
429 Nothing -> throw $ ResultException
456 Nothing -> throw $ ResultException
430 "traversePrepared: LibPQ.execParams returned no results"
457 "traversePrepared: LibPQ.execParams returned no results"
431 Just result -> do
458 Just result -> do
432− tryResult result
459+ okResult_ result
433 return $ K result
460 return $ K result
434 deallocResultMaybe <- LibPQ.exec conn ("DEALLOCATE " <> temp <> ";")
461 deallocResultMaybe <- LibPQ.exec conn ("DEALLOCATE " <> temp <> ";")
435 case deallocResultMaybe of
462 case deallocResultMaybe of
436 Nothing -> throw $ ResultException
463 Nothing -> throw $ ResultException
437 "traversePrepared: LibPQ.exec DEALLOCATE returned no results"
464 "traversePrepared: LibPQ.exec DEALLOCATE returned no results"
438− Just deallocResult -> tryResult deallocResult
465+ Just deallocResult -> okResult_ deallocResult
439 return (K results)
466 return (K results)
440
467
441 traversePrepared_
468 traversePrepared_
442 (UnsafeManipulation q :: Manipulation '[] schemas xs '[]) (list :: list x) =
469 (UnsafeManipulation q :: Manipulation '[] schemas xs '[]) (list :: list x) =
443− PQ $ \ (K conn) -> liftBase $ do
470+ PQ $ \ (K conn) -> liftIO $ do
471+ let
444− let temp = "temporary_statement"
472+ temp = "temporary_statement"
473+ paramOid :: forall p. OidOfParam p => K LibPQ.Oid p
474+ paramOid = K (oidOfParam @p)
475+ paramOids :: NP (K LibPQ.Oid) xs
476+ paramOids = hcpure (Proxy @OidOfParam) paramOid
477+ paramOids' :: [LibPQ.Oid]
478+ paramOids' = hcollapse paramOids
445− prepResultMaybe <- LibPQ.prepare conn temp q Nothing
479+ prepResultMaybe <- LibPQ.prepare conn temp q (Just paramOids')
446 case prepResultMaybe of
480 case prepResultMaybe of
447 Nothing -> throw $ ResultException
481 Nothing -> throw $ ResultException
448 "traversePrepared_: LibPQ.prepare returned no results"
482 "traversePrepared_: LibPQ.prepare returned no results"
449− Just prepResult -> tryResult prepResult
483+ Just prepResult -> okResult_ prepResult
450 for_ list $ \ params -> do
484 for_ list $ \ params -> do
451 let
485 let
452 toParam' encoding = (encodingBytes encoding, LibPQ.Binary)
486 toParam' encoding = (encodingBytes encoding, LibPQ.Binary)
@@ -455,16 +489,16 @@ instance (MonadBase IO io, schemas0 ~ schemas, schemas1 ~ schemas)
455 case resultMaybe of
489 case resultMaybe of
456 Nothing -> throw $ ResultException
490 Nothing -> throw $ ResultException
457 "traversePrepared_: LibPQ.execParams returned no results"
491 "traversePrepared_: LibPQ.execParams returned no results"
458− Just result -> tryResult result
492+ Just result -> okResult_ result
459 deallocResultMaybe <- LibPQ.exec conn ("DEALLOCATE " <> temp <> ";")
493 deallocResultMaybe <- LibPQ.exec conn ("DEALLOCATE " <> temp <> ";")
460 case deallocResultMaybe of
494 case deallocResultMaybe of
461 Nothing -> throw $ ResultException
495 Nothing -> throw $ ResultException
462 "traversePrepared: LibPQ.exec DEALLOCATE returned no results"
496 "traversePrepared: LibPQ.exec DEALLOCATE returned no results"
463− Just deallocResult -> tryResult deallocResult
497+ Just deallocResult -> okResult_ deallocResult
464 return (K ())
498 return (K ())
465
499
466 liftPQ pq = PQ $ \ (K conn) -> do
500 liftPQ pq = PQ $ \ (K conn) -> do
467− y <- liftBase $ pq conn
501+ y <- liftIO $ pq conn
468 return (K y)
502 return (K y)
469
503
470instance MonadPQ schemas m => MonadPQ schemas (IdentityT m)
504instance MonadPQ schemas m => MonadPQ schemas (IdentityT m)
@@ -505,40 +539,29 @@ instance schemas0 ~ schemas1 => MMonad (PQ schemas0 schemas1) where
505 embed f (PQ pq) = PQ $ \ conn -> do
539 embed f (PQ pq) = PQ $ \ conn -> do
506 evalPQ (f (pq conn)) conn
540 evalPQ (f (pq conn)) conn
507
541
508−instance (MonadBase b m, schemas0 ~ schemas1)
509− => MonadBase b (PQ schemas0 schemas1 m) where
510− liftBase = lift . liftBase
511−
512instance (MonadIO m, schema0 ~ schema1)
542instance (MonadIO m, schema0 ~ schema1)
513 => MonadIO (PQ schema0 schema1 m) where
543 => MonadIO (PQ schema0 schema1 m) where
514 liftIO = lift . liftIO
544 liftIO = lift . liftIO
515
545
516−-- | A snapshot of the state of a `PQ` computation.
517−type PQRun schemas =
518− forall m x. Monad m => PQ schemas schemas m x -> m (K x schemas)
519−
520−-- | Helper function in defining `MonadBaseControl` instance for `PQ`.
521−pqliftWith :: Functor m => (PQRun schemas -> m a) -> PQ schemas schemas m a
522−pqliftWith f = PQ $ \ conn ->
523− fmap K (f $ \ pq -> unPQ pq conn)
524−
525−instance (MonadBaseControl b m, schemas0 ~ schemas1)
546+instance (MonadUnliftIO m, schemas0 ~ schemas1)
526− => MonadBaseControl b (PQ schemas0 schemas1 m) where
547+ => MonadUnliftIO (PQ schemas0 schemas1 m) where
527− type StM (PQ schemas0 schemas1 m) x = StM m (K x schemas0)
548+ withRunInIO
528− liftBaseWith f =
549+ :: ((forall a . PQ schemas0 schema1 m a -> IO a) -> IO b)
529− pqliftWith $ \ run -> liftBaseWith $ \ runInBase -> f $ runInBase . run
550+ -> PQ schemas0 schema1 m b
530− restoreM = PQ . const . restoreM
551+ withRunInIO inner = PQ $ \conn ->
552+ withRunInIO $ \(run :: (forall x . m x -> IO x)) ->
553+ K <$> inner (\pq -> run $ unK <$> unPQ pq conn)
531
554
532-- | Get a row corresponding to a given row number from a `LibPQ.Result`,
555-- | Get a row corresponding to a given row number from a `LibPQ.Result`,
533-- throwing an exception if the row number is out of bounds.
556-- throwing an exception if the row number is out of bounds.
534getRow
557getRow
535− :: (FromRow columns y, MonadBase IO io)
558+ :: (FromRow columns y, MonadIO io)
536 => LibPQ.Row
559 => LibPQ.Row
537 -- ^ row number
560 -- ^ row number
538 -> K LibPQ.Result columns
561 -> K LibPQ.Result columns
539 -- ^ result
562 -- ^ result
540 -> io y
563 -> io y
541−getRow r (K result :: K LibPQ.Result columns) = liftBase $ do
564+getRow r (K result :: K LibPQ.Result columns) = liftIO $ do
542 numRows <- LibPQ.ntuples result
565 numRows <- LibPQ.ntuples result
543 when (numRows < r) $ throw $ ResultException $
566 when (numRows < r) $ throw $ ResultException $
544 "getRow: expected at least " <> pack (show r) <> "rows but only saw "
567 "getRow: expected at least " <> pack (show r) <> "rows but only saw "
@@ -556,13 +579,13 @@ getRow r (K result :: K LibPQ.Result columns) = liftBase $ do
556-- and a `LibPQ.Result` and given a row number if it's too large returns `Nothing`,
579-- and a `LibPQ.Result` and given a row number if it's too large returns `Nothing`,
557-- otherwise returning the row along with the next row number.
580-- otherwise returning the row along with the next row number.
558nextRow
581nextRow
559− :: (FromRow columns y, MonadBase IO io)
582+ :: (FromRow columns y, MonadIO io)
560 => LibPQ.Row -- ^ total number of rows
583 => LibPQ.Row -- ^ total number of rows
561 -> K LibPQ.Result columns -- ^ result
584 -> K LibPQ.Result columns -- ^ result
562 -> LibPQ.Row -- ^ row number
585 -> LibPQ.Row -- ^ row number
563 -> io (Maybe (LibPQ.Row,y))
586 -> io (Maybe (LibPQ.Row,y))
564nextRow total (K result :: K LibPQ.Result columns) r
587nextRow total (K result :: K LibPQ.Result columns) r
565− = liftBase $ if r >= total then return Nothing else do
588+ = liftIO $ if r >= total then return Nothing else do
566 let len = fromIntegral (lengthSList (Proxy @columns))
589 let len = fromIntegral (lengthSList (Proxy @columns))
567 row' <- traverse (LibPQ.getvalue result r) [0 .. len - 1]
590 row' <- traverse (LibPQ.getvalue result r) [0 .. len - 1]
568 case fromList row' of
591 case fromList row' of
@@ -573,10 +596,10 @@ nextRow total (K result :: K LibPQ.Result columns) r
573
596
574-- | Get all rows from a `LibPQ.Result`.
597-- | Get all rows from a `LibPQ.Result`.
575getRows
598getRows
576− :: (FromRow columns y, MonadBase IO io)
599+ :: (FromRow columns y, MonadIO io)
577 => K LibPQ.Result columns -- ^ result
600 => K LibPQ.Result columns -- ^ result
578 -> io [y]
601 -> io [y]
579−getRows (K result :: K LibPQ.Result columns) = liftBase $ do
602+getRows (K result :: K LibPQ.Result columns) = liftIO $ do
580 let len = fromIntegral (lengthSList (Proxy @columns))
603 let len = fromIntegral (lengthSList (Proxy @columns))
581 numRows <- LibPQ.ntuples result
604 numRows <- LibPQ.ntuples result
582 for [0 .. numRows - 1] $ \ r -> do
605 for [0 .. numRows - 1] $ \ r -> do
@@ -589,10 +612,10 @@ getRows (K result :: K LibPQ.Result columns) = liftBase $ do
589
612
590-- | Get the first row if possible from a `LibPQ.Result`.
613-- | Get the first row if possible from a `LibPQ.Result`.
591firstRow
614firstRow
592− :: (FromRow columns y, MonadBase IO io)
615+ :: (FromRow columns y, MonadIO io)
593 => K LibPQ.Result columns -- ^ result
616 => K LibPQ.Result columns -- ^ result
594 -> io (Maybe y)
617 -> io (Maybe y)
595−firstRow (K result :: K LibPQ.Result columns) = liftBase $ do
618+firstRow (K result :: K LibPQ.Result columns) = liftIO $ do
596 numRows <- LibPQ.ntuples result
619 numRows <- LibPQ.ntuples result
597 if numRows <= 0 then return Nothing else do
620 if numRows <= 0 then return Nothing else do
598 let len = fromIntegral (lengthSList (Proxy @columns))
621 let len = fromIntegral (lengthSList (Proxy @columns))
@@ -605,23 +628,23 @@ firstRow (K result :: K LibPQ.Result columns) = liftBase $ do
605
628
606-- | Lifts actions on results from @LibPQ@.
629-- | Lifts actions on results from @LibPQ@.
607liftResult
630liftResult
608− :: MonadBase IO io
631+ :: MonadIO io
609 => (LibPQ.Result -> IO x)
632 => (LibPQ.Result -> IO x)
610 -> K LibPQ.Result results -> io x
633 -> K LibPQ.Result results -> io x
611−liftResult f (K result) = liftBase $ f result
634+liftResult f (K result) = liftIO $ f result
612
635
613-- | Returns the number of rows (tuples) in the query result.
636-- | Returns the number of rows (tuples) in the query result.
614−ntuples :: MonadBase IO io => K LibPQ.Result columns -> io LibPQ.Row
637+ntuples :: MonadIO io => K LibPQ.Result columns -> io LibPQ.Row
615ntuples = liftResult LibPQ.ntuples
638ntuples = liftResult LibPQ.ntuples
616
639
617-- | Returns the result status of the command.
640-- | Returns the result status of the command.
618−resultStatus :: MonadBase IO io => K LibPQ.Result results -> io LibPQ.ExecStatus
641+resultStatus :: MonadIO io => K LibPQ.Result results -> io LibPQ.ExecStatus
619resultStatus = liftResult LibPQ.resultStatus
642resultStatus = liftResult LibPQ.resultStatus
620
643
621-- | Returns the error message most recently generated by an operation
644-- | Returns the error message most recently generated by an operation
622-- on the connection.
645-- on the connection.
623resultErrorMessage
646resultErrorMessage
624− :: MonadBase IO io => K LibPQ.Result results -> io (Maybe ByteString)
647+ :: MonadIO io => K LibPQ.Result results -> io (Maybe ByteString)
625resultErrorMessage = liftResult LibPQ.resultErrorMessage
648resultErrorMessage = liftResult LibPQ.resultErrorMessage
626
649
627-- | Returns the error code most recently generated by an operation
650-- | Returns the error code most recently generated by an operation
@@ -629,29 +652,29 @@ resultErrorMessage = liftResult LibPQ.resultErrorMessage
629--
652--
630-- https://www.postgresql.org/docs/current/static/errcodes-appendix.html
653-- https://www.postgresql.org/docs/current/static/errcodes-appendix.html
631resultErrorCode
654resultErrorCode
632− :: MonadBase IO io
655+ :: MonadIO io
633 => K LibPQ.Result results
656 => K LibPQ.Result results
634 -> io (Maybe ByteString)
657 -> io (Maybe ByteString)
635resultErrorCode = liftResult (flip LibPQ.resultErrorField LibPQ.DiagSqlstate)
658resultErrorCode = liftResult (flip LibPQ.resultErrorField LibPQ.DiagSqlstate)
636
659
637−-- | `Exception`s that can be thrown by Squeal.
660+-- | the state of LibPQ
638−data SquealException
661+data PQState = PQState
639− = PQException
640 { sqlExecStatus :: LibPQ.ExecStatus
662 { sqlExecStatus :: LibPQ.ExecStatus
641 , sqlStateCode :: Maybe ByteString
663 , sqlStateCode :: Maybe ByteString
642 -- ^ https://www.postgresql.org/docs/current/static/errcodes-appendix.html
664 -- ^ https://www.postgresql.org/docs/current/static/errcodes-appendix.html
643 , sqlErrorMessage :: Maybe ByteString
665 , sqlErrorMessage :: Maybe ByteString
644− }
666+ } deriving (Eq, Show)
667+
668+-- | `Exception`s that can be thrown by Squeal.
669+data SquealException
670+ = PQException PQState
645 | ResultException Text
671 | ResultException Text
646 | ParseException Text
672 | ParseException Text
647 deriving (Eq, Show)
673 deriving (Eq, Show)
648instance Exception SquealException
674instance Exception SquealException
649
675
650−tryResult
651− :: MonadBase IO io
652− => LibPQ.Result
676+okResult_ :: MonadIO io => LibPQ.Result -> io ()
653− -> io ()
677+okResult_ result = liftIO $ do
654−tryResult result = liftBase $ do
655 status <- LibPQ.resultStatus result
678 status <- LibPQ.resultStatus result
656 case status of
679 case status of
657 LibPQ.CommandOk -> return ()
680 LibPQ.CommandOk -> return ()
@@ -659,11 +682,16 @@ tryResult result = liftBase $ do
659 _ -> do
682 _ -> do
660 stateCode <- LibPQ.resultErrorField result LibPQ.DiagSqlstate
683 stateCode <- LibPQ.resultErrorField result LibPQ.DiagSqlstate
661 msg <- LibPQ.resultErrorMessage result
684 msg <- LibPQ.resultErrorMessage result
662− throw $ PQException status stateCode msg
685+ throw . PQException $ PQState status stateCode msg
686+
687+-- | Check if a `LibPQ.Result`'s status is either `LibPQ.CommandOk`
688+-- or `LibPQ.TuplesOk` otherwise `throw` a `PQException`.
689+okResult :: MonadIO io => K LibPQ.Result row -> io ()
690+okResult = okResult_ . unK
663
691
664-- | Catch `SquealException`s.
692-- | Catch `SquealException`s.
665catchSqueal
693catchSqueal
666− :: MonadBaseControl IO io
694+ :: MonadUnliftIO io
667 => io a
695 => io a
668 -> (SquealException -> io a) -- ^ handler
696 -> (SquealException -> io a) -- ^ handler
669 -> io a
697 -> io a
@@ -671,7 +699,14 @@ catchSqueal = catch
671
699
672-- | Handle `SquealException`s.
700-- | Handle `SquealException`s.
673handleSqueal
701handleSqueal
674− :: MonadBaseControl IO io
702+ :: MonadUnliftIO io
675 => (SquealException -> io a) -- ^ handler
703 => (SquealException -> io a) -- ^ handler
676 -> io a -> io a
704 -> io a -> io a
677handleSqueal = handle
705handleSqueal = handle
706+
707+-- | `Either` return a `SquealException` or a result.
708+trySqueal
709+ :: MonadUnliftIO io
710+ => io a
711+ -> io (Either SquealException a)
712+trySqueal = try
squeal-postgresql/src/Squeal/PostgreSQL/Pool.hs+72−109
@@ -1,17 +1,40 @@
1{-|
1{-|
2−Module: Squeal.PostgreSQL.Definition
2+Module: Squeal.PostgreSQL.Pool
3−Description: Pooled connections
3+Description: Connection pools
4Copyright: (c) Eitan Chatav, 2017
4Copyright: (c) Eitan Chatav, 2017
5Maintainer: eitan@morphism.tech
5Maintainer: eitan@morphism.tech
6Stability: experimental
6Stability: experimental
7
7
8−A `MonadPQ` for pooled connections.
8+Connection pools.
9+
10+Typical use case would be to create your pool using `createConnectionPool`
11+and run anything that requires the pool connection with `usingConnectionPool`.
12+
13+Here's a simplified example:
14+
15+>>> import Squeal.PostgreSQL
16+
17+>>> :{
18+do
19+ let
20+ query :: Query_ (Public '[]) () (Only Char)
21+ query = values_ (literal 'a' `as` #fromOnly)
22+ pool <- createConnectionPool "host=localhost port=5432 dbname=exampledb" 1 0.5 10
23+ chr <- usingConnectionPool pool $ do
24+ result <- runQuery query
25+ Just (Only a) <- firstRow result
26+ return a
27+ destroyConnectionPool pool
28+ putChar chr
29+:}
30+a
9-}
31-}
10
32
11{-# LANGUAGE
33{-# LANGUAGE
12 DeriveFunctor
34 DeriveFunctor
13 , FlexibleContexts
35 , FlexibleContexts
14 , FlexibleInstances
36 , FlexibleInstances
37+ , InstanceSigs
15 , MultiParamTypeClasses
38 , MultiParamTypeClasses
16 , RankNTypes
39 , RankNTypes
17 , ScopedTypeVariables
40 , ScopedTypeVariables
@@ -22,57 +45,24 @@ A `MonadPQ` for pooled connections.
22
45
23module Squeal.PostgreSQL.Pool
46module Squeal.PostgreSQL.Pool
24 ( -- * Pools
47 ( -- * Pools
25− PoolPQ (..)
48+ Pool
26 , createConnectionPool
49 , createConnectionPool
27− , Pool
50+ , usingConnectionPool
28− , destroyAllResources
51+ , destroyConnectionPool
29− , PoolPQRun
30− , poolpqliftWith
31 ) where
52 ) where
32
53
33−import Control.Monad.Base
34−import Control.Monad.Trans
35−import Control.Monad.Trans.Control
36import Data.ByteString
54import Data.ByteString
37−import Data.Pool
38import Data.Time
55import Data.Time
39−import Generics.SOP (K(..))
56+import Generics.SOP (K(..), unK)
40−
57+import UnliftIO (MonadUnliftIO (..))
41−import qualified Control.Monad.Fail as Fail
58+import UnliftIO.Pool (Pool, createPool, destroyAllResources, withResource)
42
59
43import Squeal.PostgreSQL.PQ
60import Squeal.PostgreSQL.PQ
44−import Squeal.PostgreSQL.Schema
45−
46−{- | `PoolPQ` @schemas@ should be a drop-in replacement for `PQ` @schemas schemas@.
47−
48−Typical use case would be to create your pool using `createConnectionPool` and run anything that requires the pool connection with it.
49−
50−Here's a simplified example:
51−
52−> type Schema = '[ "tab" ::: 'Table ('[] :=> '["col" ::: 'NoDef :=> 'NotNull 'PGint2])]
53−>
54−> someQuery :: Manipulation Schema '[ 'NotNull 'PGint2] '[]
55−> someQuery = insertRow #tab
56−> (Set (param @1) `As` #col :* Nil)
57−> OnConflictDoNothing (Returning Nil)
58−>
59−> insertOne :: (MonadBaseControl IO m, MonadPQ Schema m) => m ()
60−> insertOne = void $ manipulateParams someQuery . Only $ (1 :: Int16)
61−>
62−> insertOneInPool :: ByteString -> IO ()
63−> insertOneInPool connectionString = do
64−> pool <- createConnectionPool connectionString 1 0.5 10
65−> liftIO $ runPoolPQ (insertOne) pool
66−
67−-}
68−newtype PoolPQ (schemas :: SchemasType) m x =
69− PoolPQ { runPoolPQ :: Pool (K Connection schemas) -> m x }
70− deriving Functor
71
61
72-- | Create a striped pool of connections.
62-- | Create a striped pool of connections.
73-- Although the garbage collector will destroy all idle connections when the pool is garbage collected it's recommended to manually `destroyAllResources` when you're done with the pool so that the connections are freed up as soon as possible.
63-- Although the garbage collector will destroy all idle connections when the pool is garbage collected it's recommended to manually `destroyAllResources` when you're done with the pool so that the connections are freed up as soon as possible.
74createConnectionPool
64createConnectionPool
75− :: MonadBase IO io
65+ :: MonadUnliftIO io
76 => ByteString
66 => ByteString
77 -- ^ The passed string can be empty to use all default parameters, or it can
67 -- ^ The passed string can be empty to use all default parameters, or it can
78 -- contain one or more parameter settings separated by whitespace.
68 -- contain one or more parameter settings separated by whitespace.
@@ -89,71 +79,44 @@ createConnectionPool
89 -- ^ Maximum number of connections to keep open per stripe. The smallest acceptable value is 1.
79 -- ^ Maximum number of connections to keep open per stripe. The smallest acceptable value is 1.
90 -- Requests for connections will block if this limit is reached on a single stripe, even if other stripes have idle connections available.
80 -- Requests for connections will block if this limit is reached on a single stripe, even if other stripes have idle connections available.
91 -> io (Pool (K Connection schemas))
81 -> io (Pool (K Connection schemas))
92−createConnectionPool conninfo stripes idle maxResrc = liftBase $
82+createConnectionPool conninfo stripes idle maxResrc =
93 createPool (connectdb conninfo) finish stripes idle maxResrc
83 createPool (connectdb conninfo) finish stripes idle maxResrc
94
84
95−-- | `Applicative` instance for `PoolPQ`.
85+{-|
96−instance Monad m => Applicative (PoolPQ schemas m) where
86+Temporarily take a connection from a `Pool`, perform an action with it,
97− pure x = PoolPQ $ \ _ -> pure x
87+and return it to the pool afterwards.
98− PoolPQ f <*> PoolPQ x = PoolPQ $ \ pool -> do
88+
99− f' <- f pool
89+If the pool has an idle connection available, it is used immediately.
100− x' <- x pool
90+Otherwise, if the maximum number of connections has not yet been reached,
101− return $ f' x'
91+a new connection is created and used.
102−
92+If the maximum number of connections has been reached, this function blocks
103−-- | `Monad` instance for `PoolPQ`.
93+until a connection becomes available.
104−instance Monad m => Monad (PoolPQ schemas m) where
94+-}
105− return = pure
95+usingConnectionPool
106− PoolPQ x >>= f = PoolPQ $ \ pool -> do
96+ :: MonadUnliftIO io
107− x' <- x pool
97+ => Pool (K Connection schemas) -- ^ pool
108− runPoolPQ (f x') pool
98+ -> PQ schemas schemas io x -- ^ session
109−
99+ -> io x
110−-- | `Fail.MonadFail` instance for `PoolPQ`.
100+usingConnectionPool pool (PQ session) = unK <$> withResource pool session
111−instance Monad m => Fail.MonadFail (PoolPQ schemas m) where
101+
112− fail = Fail.fail
102+{- |
113−
103+Destroy all connections in all stripes in the pool.
114−-- | `MonadTrans` instance for `PoolPQ`.
104+Note that this will ignore any exceptions in the destroy function.
115−instance MonadTrans (PoolPQ schemas) where
105+
116− lift m = PoolPQ $ \ _pool -> m
106+This function is useful when you detect that all connections
117−
107+in the pool are broken. For example after a database has been
118−-- | `MonadBase` instance for `PoolPQ`.
108+restarted all connections opened before the restart will be broken.
119−instance MonadBase b m => MonadBase b (PoolPQ schemas m) where
109+In that case it's better to close those connections so that
120− liftBase = lift . liftBase
110+`usingConnectionPool` won't take a broken connection from the pool
121−
111+but will open a new connection instead.
122−-- | `MonadPQ` instance for `PoolPQ`.
112+
123−instance MonadBaseControl IO io => MonadPQ schemas (PoolPQ schemas io) where
113+Another use-case for this function is that when you know you are done
124− manipulateParams manipulation params = PoolPQ $ \ pool -> do
114+with the pool you can destroy all idle connections immediately
125− withResource pool $ \ conn -> do
115+instead of waiting on the garbage collector to destroy them,
126− (K result :: K (K Result ys) schemas) <- flip unPQ conn $
116+thus freeing up those connections sooner.
127− manipulateParams manipulation params
117+-}
128− return result
118+destroyConnectionPool
129− traversePrepared manipulation params = PoolPQ $ \ pool ->
119+ :: MonadUnliftIO io
130− withResource pool $ \ conn -> do
120+ => Pool (K Connection schemas) -- ^ pool
131− (K result :: K (list (K Result ys)) schemas) <- flip unPQ conn $
121+ -> io ()
132− traversePrepared manipulation params
122+destroyConnectionPool = destroyAllResources
133− return result
134− traversePrepared_ manipulation params = PoolPQ $ \ pool -> do
135− withResource pool $ \ conn -> do
136− (_ :: K () schemas) <- flip unPQ conn $
137− traversePrepared_ manipulation params
138− return ()
139− liftPQ m = PoolPQ $ \ pool ->
140− withResource pool $ \ conn -> do
141− (K result :: K result schemas) <- flip unPQ conn $
142− liftPQ m
143− return result
144−
145−-- | A snapshot of the state of a `PoolPQ` computation.
146−type PoolPQRun schemas =
147− forall m x. Monad m => PoolPQ schemas m x -> m x
148−
149−-- | Helper function in defining `MonadBaseControl` instance for `PoolPQ`.
150−poolpqliftWith :: Functor m => (PoolPQRun schemas -> m a) -> PoolPQ schemas m a
151−poolpqliftWith f = PoolPQ $ \ pool ->
152− (f $ \ pq -> runPoolPQ pq pool)
153−
154−-- | `MonadBaseControl` instance for `PoolPQ`.
155−instance MonadBaseControl b m => MonadBaseControl b (PoolPQ schemas m) where
156− type StM (PoolPQ schemas m) x = StM m x
157− liftBaseWith f =
158− poolpqliftWith $ \ run -> liftBaseWith $ \ runInBase -> f $ runInBase . run
159− restoreM = PoolPQ . const . restoreM
squeal-postgresql/src/Squeal/PostgreSQL/Query.hs+310−429
@@ -1,7 +1,7 @@
1{-|
1{-|
2Module: Squeal.PostgreSQL.Query
2Module: Squeal.PostgreSQL.Query
3Description: Squeal queries
3Description: Squeal queries
4−Copyright: (c) Eitan Chatav, 2017
4+Copyright: (c) Eitan Chatav, 2019
5Maintainer: eitan@morphism.tech
5Maintainer: eitan@morphism.tech
6Stability: experimental
6Stability: experimental
7
7
@@ -32,13 +32,15 @@ Squeal queries.
32
32
33module Squeal.PostgreSQL.Query
33module Squeal.PostgreSQL.Query
34 ( -- * Queries
34 ( -- * Queries
35+ Query_
35− Query (..)
36+ , Query (..)
36− , Query_
37 -- ** Select
37 -- ** Select
38 , select
38 , select
39 , select_
39 , select_
40 , selectDistinct
40 , selectDistinct
41 , selectDistinct_
41 , selectDistinct_
42+ , selectDistinctOn
43+ , selectDistinctOn_
42 , Selection (..)
44 , Selection (..)
43 -- ** Values
45 -- ** Values
44 , values
46 , values
@@ -53,23 +55,7 @@ module Squeal.PostgreSQL.Query
53 -- ** With
55 -- ** With
54 , With (..)
56 , With (..)
55 , CommonTableExpression (..)
57 , CommonTableExpression (..)
56− -- ** Unnest
58+ , withRecursive
57− , unnest
58− -- ** Json
59− , jsonEach
60− , jsonbEach
61− , jsonEachText
62− , jsonbEachText
63− , jsonObjectKeys
64− , jsonbObjectKeys
65− , jsonPopulateRecord
66− , jsonbPopulateRecord
67− , jsonPopulateRecordSet
68− , jsonbPopulateRecordSet
69− , jsonToRecord
70− , jsonbToRecord
71− , jsonToRecordSet
72− , jsonbToRecordSet
73 -- * Table Expressions
59 -- * Table Expressions
74 , TableExpression (..)
60 , TableExpression (..)
75 , from
61 , from
@@ -93,13 +79,6 @@ module Squeal.PostgreSQL.Query
93 , By (..)
79 , By (..)
94 , GroupByClause (..)
80 , GroupByClause (..)
95 , HavingClause (..)
81 , HavingClause (..)
96− -- * Subquery Expressions
97− , exists
98− , in_
99− , notIn
100− , Operator
101− , subAll
102− , subAny
103 ) where
82 ) where
104
83
105import Control.DeepSeq
84import Control.DeepSeq
@@ -112,14 +91,67 @@ import GHC.TypeLits
112
91
113import qualified GHC.Generics as GHC
92import qualified GHC.Generics as GHC
114
93
115−import Squeal.PostgreSQL.Binary
94+import Squeal.PostgreSQL.Alias
116import Squeal.PostgreSQL.Expression
95import Squeal.PostgreSQL.Expression
96+import Squeal.PostgreSQL.Expression.Logic
97+import Squeal.PostgreSQL.Expression.Sort
98+import Squeal.PostgreSQL.Expression.Window
99+import Squeal.PostgreSQL.List
100+import Squeal.PostgreSQL.PG
117import Squeal.PostgreSQL.Render
101import Squeal.PostgreSQL.Render
118import Squeal.PostgreSQL.Schema
102import Squeal.PostgreSQL.Schema
119
103
104+-- $setup
105+-- >>> import Squeal.PostgreSQL
106+-- >>> import Data.Int (Int32, Int64)
107+-- >>> import Data.Monoid (Sum (..))
108+-- >>> import Data.Text (Text)
109+-- >>> import qualified Generics.SOP as SOP
110+
111+{- |
112+The process of retrieving or the command to retrieve data from
113+a database is called a `Query`.
114+
115+The general `Query` type is parameterized by
116+
117+* @outer :: FromType@ - outer scope for a correlated subquery,
118+* @commons :: FromType@ - scope for all `common` table expressions,
119+* @schemas :: SchemasType@ - scope for all `table`s and `view`s,
120+* @params :: [NullityType]@ - scope for all `Squeal.Expression.Parameter.parameter`s,
121+* @row :: RowType@ - return type of the `Query`.
122+-}
123+newtype Query
124+ (outer :: FromType)
125+ (commons :: FromType)
126+ (schemas :: SchemasType)
127+ (params :: [NullityType])
128+ (row :: RowType)
129+ = UnsafeQuery { renderQuery :: ByteString }
130+ deriving (GHC.Generic,Show,Eq,Ord,NFData)
131+instance RenderSQL (Query outer commons schemas params row) where renderSQL = renderQuery
132+
120{- |
133{- |
121−The process of retrieving or the command to retrieve data from a database
134+The top level `Query_` type is parameterized by a @schemas@ `SchemasType`,
135+against which the query is type-checked, an input @parameters@ Haskell `Type`,
136+and an ouput row Haskell `Type`.
137+
138+A top-level query can be run
139+using `Squeal.PostgreSQL.PQ.runQueryParams`, or if @parameters = ()@
140+using `Squeal.PostgreSQL.PQ.runQuery`.
141+
142+Generally, @parameters@ will be a Haskell tuple or record whose entries
143+may be referenced using positional
144+`Squeal.PostgreSQL.Expression.Parameter.parameter`s and @row@ will be a
145+Haskell record, whose entries will be targeted using overloaded labels.
146+
122−is called a `Query`. Let's see some examples of queries.
147+Let's see some examples of queries.
148+
149+>>> :set -XDeriveAnyClass -XDerivingStrategies
150+>>> :{
151+data Row a b = Row { col1 :: a, col2 :: b }
152+ deriving stock (GHC.Generic)
153+ deriving anyclass (SOP.Generic, SOP.HasDatatypeInfo)
154+:}
123
155
124simple query:
156simple query:
125
157
@@ -127,7 +159,7 @@ simple query:
127>>> type Schema = '["tab" ::: 'Table ('[] :=> Columns)]
159>>> type Schema = '["tab" ::: 'Table ('[] :=> Columns)]
128>>> :{
160>>> :{
129let
161let
130− query :: Query '[] '[] (Public Schema) '[] '["col1" ::: 'NotNull 'PGint4, "col2" ::: 'NotNull 'PGint4]
162+ query :: Query_ (Public Schema) () (Row Int32 Int32)
131 query = select Star (from (table #tab))
163 query = select Star (from (table #tab))
132in printSQL query
164in printSQL query
133:}
165:}
@@ -137,21 +169,21 @@ restricted query:
137
169
138>>> :{
170>>> :{
139let
171let
140− query :: Query '[] '[] (Public Schema) '[] '["sum" ::: 'NotNull 'PGint4, "col1" ::: 'NotNull 'PGint4]
172+ query :: Query_ (Public Schema) () (Row Int32 Int32)
141 query =
173 query =
142− select_ ((#col1 + #col2) `as` #sum :* #col1)
174+ select_ ((#col1 + #col2) `as` #col1 :* #col1 `as` #col2)
143 ( from (table #tab)
175 ( from (table #tab)
144 & where_ (#col1 .> #col2)
176 & where_ (#col1 .> #col2)
145 & where_ (#col2 .> 0) )
177 & where_ (#col2 .> 0) )
146in printSQL query
178in printSQL query
147:}
179:}
148−SELECT ("col1" + "col2") AS "sum", "col1" AS "col1" FROM "tab" AS "tab" WHERE (("col1" > "col2") AND ("col2" > 0))
180+SELECT ("col1" + "col2") AS "col1", "col1" AS "col2" FROM "tab" AS "tab" WHERE (("col1" > "col2") AND ("col2" > 0))
149
181
150subquery:
182subquery:
151
183
152>>> :{
184>>> :{
153let
185let
154− query :: Query '[] '[] (Public Schema) '[] '["col1" ::: 'NotNull 'PGint4, "col2" ::: 'NotNull 'PGint4]
186+ query :: Query_ (Public Schema) () (Row Int32 Int32)
155 query = select Star (from (subquery (select Star (from (table #tab)) `as` #sub)))
187 query = select Star (from (subquery (select Star (from (table #tab)) `as` #sub)))
156in printSQL query
188in printSQL query
157:}
189:}
@@ -161,7 +193,7 @@ limits and offsets:
161
193
162>>> :{
194>>> :{
163let
195let
164− query :: Query '[] '[] (Public Schema) '[] '["col1" ::: 'NotNull 'PGint4, "col2" ::: 'NotNull 'PGint4]
196+ query :: Query_ (Public Schema) () (Row Int32 Int32)
165 query = select Star (from (table #tab) & limit 100 & offset 2 & limit 50 & offset 2)
197 query = select Star (from (table #tab) & limit 100 & offset 2 & limit 50 & offset 2)
166in printSQL query
198in printSQL query
167:}
199:}
@@ -171,7 +203,7 @@ parameterized query:
171
203
172>>> :{
204>>> :{
173let
205let
174− query :: Query '[] '[] (Public Schema) '[ 'NotNull 'PGint4] '["col1" ::: 'NotNull 'PGint4, "col2" ::: 'NotNull 'PGint4]
206+ query :: Query_ (Public Schema) (Only Int32) (Row Int32 Int32)
175 query = select Star (from (table #tab) & where_ (#col1 .> param @1))
207 query = select Star (from (table #tab) & where_ (#col1 .> param @1))
176in printSQL query
208in printSQL query
177:}
209:}
@@ -181,21 +213,21 @@ aggregation query:
181
213
182>>> :{
214>>> :{
183let
215let
184− query :: Query '[] '[] (Public Schema) '[] '["sum" ::: 'NotNull 'PGint4, "col1" ::: 'NotNull 'PGint4 ]
216+ query :: Query_ (Public Schema) () (Row Int64 Int32)
185 query =
217 query =
186− select_ (sum_ (All #col2) `as` #sum :* #col1)
218+ select_ ((fromNull 0 (sum_ (All #col2))) `as` #col1 :* #col1 `as` #col2)
187 ( from (table (#tab `as` #table1))
219 ( from (table (#tab `as` #table1))
188 & groupBy #col1
220 & groupBy #col1
189− & having (#col1 + sum_ (Distinct #col2) .> 1) )
221+ & having (sum_ (Distinct #col2) .> 1) )
190in printSQL query
222in printSQL query
191:}
223:}
192−SELECT sum(ALL "col2") AS "sum", "col1" AS "col1" FROM "tab" AS "table1" GROUP BY "col1" HAVING (("col1" + sum(DISTINCT "col2")) > 1)
224+SELECT COALESCE(sum(ALL "col2"), 0) AS "col1", "col1" AS "col2" FROM "tab" AS "table1" GROUP BY "col1" HAVING (sum(DISTINCT "col2") > 1)
193
225
194sorted query:
226sorted query:
195
227
196>>> :{
228>>> :{
197let
229let
198− query :: Query '[] '[] (Public Schema) '[] '["col1" ::: 'NotNull 'PGint4, "col2" ::: 'NotNull 'PGint4]
230+ query :: Query_ (Public Schema) () (Row Int32 Int32)
199 query = select Star (from (table #tab) & orderBy [#col1 & Asc])
231 query = select Star (from (table #tab) & orderBy [#col1 & Asc])
200in printSQL query
232in printSQL query
201:}
233:}
@@ -203,14 +235,12 @@ SELECT * FROM "tab" AS "tab" ORDER BY "col1" ASC
203
235
204joins:
236joins:
205
237
206−>>> :set -XFlexibleContexts
207>>> :{
238>>> :{
208type OrdersColumns =
239type OrdersColumns =
209 '[ "id" ::: 'NoDef :=> 'NotNull 'PGint4
240 '[ "id" ::: 'NoDef :=> 'NotNull 'PGint4
210− , "price" ::: 'NoDef :=> 'NotNull 'PGfloat4
241+ , "price" ::: 'NoDef :=> 'NotNull 'PGfloat4
211− , "customer_id" ::: 'NoDef :=> 'NotNull 'PGint4
242+ , "customer_id" ::: 'NoDef :=> 'NotNull 'PGint4
212− , "shipper_id" ::: 'NoDef :=> 'NotNull 'PGint4
243+ , "shipper_id" ::: 'NoDef :=> 'NotNull 'PGint4 ]
213− ]
214:}
244:}
215
245
216>>> :{
246>>> :{
@@ -226,22 +256,27 @@ type OrdersConstraints =
226>>> :{
256>>> :{
227type OrdersSchema =
257type OrdersSchema =
228 '[ "orders" ::: 'Table (OrdersConstraints :=> OrdersColumns)
258 '[ "orders" ::: 'Table (OrdersConstraints :=> OrdersColumns)
229− , "customers" ::: 'Table (CustomersConstraints :=> NamesColumns)
259+ , "customers" ::: 'Table (CustomersConstraints :=> NamesColumns)
230− , "shippers" ::: 'Table (ShippersConstraints :=> NamesColumns) ]
260+ , "shippers" ::: 'Table (ShippersConstraints :=> NamesColumns) ]
261+:}
262+
263+>>> :{
264+data Order = Order
265+ { price :: Float
266+ , customerName :: Text
267+ , shipperName :: Text
268+ } deriving GHC.Generic
269+instance SOP.Generic Order
270+instance SOP.HasDatatypeInfo Order
231:}
271:}
232
272
233>>> :{
273>>> :{
234let
274let
235− query :: Query '[] '[] (Public OrdersSchema)
275+ query :: Query_ (Public OrdersSchema) () Order
236− '[]
237− '[ "order_price" ::: 'NotNull 'PGfloat4
238− , "customer_name" ::: 'NotNull 'PGtext
239− , "shipper_name" ::: 'NotNull 'PGtext
240− ]
241 query = select_
276 query = select_
242− ( #o ! #price `as` #order_price :*
277+ ( #o ! #price `as` #price :*
243− #c ! #name `as` #customer_name :*
278+ #c ! #name `as` #customerName :*
244− #s ! #name `as` #shipper_name )
279+ #s ! #name `as` #shipperName )
245 ( from (table (#orders `as` #o)
280 ( from (table (#orders `as` #o)
246 & innerJoin (table (#customers `as` #c))
281 & innerJoin (table (#customers `as` #c))
247 (#o ! #customer_id .== #c ! #id)
282 (#o ! #customer_id .== #c ! #id)
@@ -249,14 +284,16 @@ let
249 (#o ! #shipper_id .== #s ! #id)) )
284 (#o ! #shipper_id .== #s ! #id)) )
250in printSQL query
285in printSQL query
251:}
286:}
252−SELECT "o"."price" AS "order_price", "c"."name" AS "customer_name", "s"."name" AS "shipper_name" 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")
287+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")
253
288
254self-join:
289self-join:
255
290
256>>> :{
291>>> :{
257let
292let
258− query :: Query '[] '[] (Public Schema) '[] '["col1" ::: 'NotNull 'PGint4, "col2" ::: 'NotNull 'PGint4]
293+ query :: Query_ (Public Schema) () (Row Int32 Int32)
294+ query = select
295+ (#t1 & DotStar)
259− query = select (#t1 & DotStar) (from (table (#tab `as` #t1) & crossJoin (table (#tab `as` #t2))))
296+ (from (table (#tab `as` #t1) & crossJoin (table (#tab `as` #t2))))
260in printSQL query
297in printSQL query
261:}
298:}
262SELECT "t1".* FROM "tab" AS "t1" CROSS JOIN "tab" AS "t2"
299SELECT "t1".* FROM "tab" AS "t1" CROSS JOIN "tab" AS "t2"
@@ -265,17 +302,19 @@ value queries:
265
302
266>>> :{
303>>> :{
267let
304let
268− query :: Query '[] commons schemas '[] '["foo" ::: 'NotNull 'PGint2, "bar" ::: 'NotNull 'PGbool]
305+ query :: Query_ schemas () (Row String Bool)
269− query = values (1 `as` #foo :* true `as` #bar) [2 `as` #foo :* false `as` #bar]
306+ query = values
307+ ("true" `as` #col1 :* true `as` #col2)
308+ ["false" `as` #col1 :* false `as` #col2]
270in printSQL query
309in printSQL query
271:}
310:}
272−SELECT * FROM (VALUES (1, TRUE), (2, FALSE)) AS t ("foo", "bar")
311+SELECT * FROM (VALUES (E'true', TRUE), (E'false', FALSE)) AS t ("col1", "col2")
273
312
274set operations:
313set operations:
275
314
276>>> :{
315>>> :{
277let
316let
278− query :: Query '[] '[] (Public Schema) '[] '["col1" ::: 'NotNull 'PGint4, "col2" ::: 'NotNull 'PGint4]
317+ query :: Query_ (Public Schema) () (Row Int32 Int32)
279 query = select Star (from (table #tab)) `unionAll` select Star (from (table #tab))
318 query = select Star (from (table #tab)) `unionAll` select Star (from (table #tab))
280in printSQL query
319in printSQL query
281:}
320:}
@@ -285,7 +324,7 @@ with queries:
285
324
286>>> :{
325>>> :{
287let
326let
288− query :: Query '[] '[] (Public Schema) '[] '["col1" ::: 'NotNull 'PGint4, "col2" ::: 'NotNull 'PGint4]
327+ query :: Query_ (Public Schema) () (Row Int32 Int32)
289 query = with (
328 query = with (
290 select Star (from (table #tab)) `as` #cte1 :>>
329 select Star (from (table #tab)) `as` #cte1 :>>
291 select Star (from (common #cte1)) `as` #cte2
330 select Star (from (common #cte1)) `as` #cte2
@@ -298,40 +337,35 @@ window function queries
298
337
299>>> :{
338>>> :{
300let
339let
301− query :: Query '[] '[] (Public Schema) '[] ["col1" ::: 'NotNull 'PGint4, "rank" ::: 'NotNull 'PGint8]
340+ query :: Query_ (Public Schema) () (Row Int32 Int64)
302 query = select
341 query = select
303− (#col1 & Also (rank `as` #rank `Over` (partitionBy #col1 & orderBy [#col2 & Asc])))
342+ (#col1 & Also (rank `as` #col2 `Over` (partitionBy #col1 & orderBy [#col2 & Asc])))
304 (from (table #tab))
343 (from (table #tab))
305in printSQL query
344in printSQL query
306:}
345:}
307−SELECT "col1" AS "col1", rank() OVER (PARTITION BY "col1" ORDER BY "col2" ASC) AS "rank" FROM "tab" AS "tab"
346+SELECT "col1" AS "col1", rank() OVER (PARTITION BY "col1" ORDER BY "col2" ASC) AS "col2" FROM "tab" AS "tab"
308
347
309correlated subqueries
348correlated subqueries
310
349
311>>> :{
350>>> :{
312let
351let
313− query :: Query '[] '[] (Public Schema) '[] '["col1" ::: 'NotNull 'PGint4]
352+ query :: Query_ (Public Schema) () (Only Int32)
314 query =
353 query =
315− select #col1 (from (table (#tab `as` #t1))
354+ select (#col1 `as` #fromOnly) (from (table (#tab `as` #t1))
316 & where_ (exists (
355 & where_ (exists (
317 select Star (from (table (#tab `as` #t2))
356 select Star (from (table (#tab `as` #t2))
318 & where_ (#t2 ! #col2 .== #t1 ! #col1)))))
357 & where_ (#t2 ! #col2 .== #t1 ! #col1)))))
319in printSQL query
358in printSQL query
320:}
359:}
321−SELECT "col1" AS "col1" FROM "tab" AS "t1" WHERE EXISTS (SELECT * FROM "tab" AS "t2" WHERE ("t2"."col2" = "t1"."col1"))
360+SELECT "col1" AS "fromOnly" FROM "tab" AS "t1" WHERE EXISTS (SELECT * FROM "tab" AS "t2" WHERE ("t2"."col2" = "t1"."col1"))
361+
322-}
362-}
323−newtype Query
363+type family Query_
324− (outer :: FromType)
325− (commons :: FromType)
326 (schemas :: SchemasType)
364 (schemas :: SchemasType)
327− (params :: [NullityType])
365+ (parameters :: Type)
328− (row :: RowType)
366+ (row :: Type) where
329− = UnsafeQuery { renderQuery :: ByteString }
367+ Query_ schemas params row =
330− deriving (GHC.Generic,Show,Eq,Ord,NFData)
331−instance RenderSQL (Query outer commons schemas params row) where renderSQL = renderQuery
332−
333−type family Query_ (schemas :: SchemasType) (params :: Type) (row :: Type) where
334− Query_ schemas params row = Query '[] '[] schemas (TuplePG params) (RowPG row)
368+ Query '[] '[] schemas (TuplePG params) (RowPG row)
335
369
336-- | The results of two queries can be combined using the set operation
370-- | The results of two queries can be combined using the set operation
337-- `union`. Duplicate rows are eliminated.
371-- `union`. Duplicate rows are eliminated.
@@ -403,35 +437,48 @@ q1 `exceptAll` q2 = UnsafeQuery $
403SELECT queries
437SELECT queries
404-----------------------------------------}
438-----------------------------------------}
405
439
440+{- | The simplest kinds of `Selection` are `Star` and `DotStar` which
441+emits all columns that a `TableExpression` produces. A select `List`
442+is a list of `Expression`s. A `Selection` could be a list of
443+`WindowFunction`s `Over` `WindowDefinition`. `Additional` `Selection`s can
444+be selected with `Also`.
445+-}
406−data Selection outer grp commons schemas params from row where
446+data Selection outer commons grp schemas params from row where
407− List
408− :: SListI row
409− => NP (Aliased (Expression outer grp commons schemas params from)) row
410− -> Selection outer grp commons schemas params from row
411 Star
447 Star
412 :: HasUnique tab from row
448 :: HasUnique tab from row
413− => Selection outer 'Ungrouped commons schemas params from row
449+ => Selection outer commons 'Ungrouped schemas params from row
450+ -- ^ `HasUnique` table in the `FromClause`
414 DotStar
451 DotStar
415 :: Has tab from row
452 :: Has tab from row
416 => Alias tab
453 => Alias tab
454+ -- ^ `Has` table with `Alias`
417− -> Selection outer 'Ungrouped commons schemas params from row
455+ -> Selection outer commons 'Ungrouped schemas params from row
418− Also
456+ List
457+ :: SListI row
419− :: Selection outer grp commons schemas params from right
458+ => NP (Aliased (Expression outer commons grp schemas params from)) row
420− -> Selection outer grp commons schemas params from left
459+ -- ^ `NP` list of `Aliased` `Expression`s
421− -> Selection outer grp commons schemas params from (Join left right)
460+ -> Selection outer commons grp schemas params from row
422 Over
461 Over
423 :: SListI row
462 :: SListI row
424− => NP (Aliased (WindowFunction outer grp commons schemas params from)) row
463+ => NP (Aliased (WindowFunction outer commons grp schemas params from)) row
464+ -- ^ `NP` list of `Aliased` `WindowFunction`s
465+ -> WindowDefinition outer commons grp schemas params from
466+ -> Selection outer commons grp schemas params from row
467+ Also
468+ :: Selection outer commons grp schemas params from right
469+ -- ^ `Additional` `Selection`
425− -> WindowDefinition outer grp commons schemas params from
470+ -> Selection outer commons grp schemas params from left
471+ -> Selection outer commons grp schemas params from (Join left right)
426− -> Selection outer grp commons schemas params from row
472+instance Additional (Selection outer commons grp schemas params from) where
473+ also = Also
427instance (KnownSymbol col, row ~ '[col ::: ty])
474instance (KnownSymbol col, row ~ '[col ::: ty])
428 => Aliasable col
475 => Aliasable col
429− (Expression outer grp commons schemas params from ty)
476+ (Expression outer commons grp schemas params from ty)
430− (Selection outer grp commons schemas params from row) where
477+ (Selection outer commons grp schemas params from row) where
431 expr `as` col = List (expr `as` col)
478 expr `as` col = List (expr `as` col)
432instance (Has tab (Join outer from) row0, Has col row0 ty, row1 ~ '[col ::: ty])
479instance (Has tab (Join outer from) row0, Has col row0 ty, row1 ~ '[col ::: ty])
433 => IsQualified tab col
480 => IsQualified tab col
434− (Selection outer 'Ungrouped commons schemas params from row1) where
481+ (Selection outer commons 'Ungrouped schemas params from row1) where
435 tab ! col = tab ! col `as` col
482 tab ! col = tab ! col `as` col
436instance
483instance
437 ( Has tab (Join outer from) row0
484 ( Has tab (Join outer from) row0
@@ -439,11 +486,11 @@ instance
439 , row1 ~ '[col ::: ty]
486 , row1 ~ '[col ::: ty]
440 , GroupedBy tab col bys )
487 , GroupedBy tab col bys )
441 => IsQualified tab col
488 => IsQualified tab col
442− (Selection outer ('Grouped bys) commons schemas params from row1) where
489+ (Selection outer commons ('Grouped bys) schemas params from row1) where
443 tab ! col = tab ! col `as` col
490 tab ! col = tab ! col `as` col
444instance (HasUnique tab (Join outer from) row0, Has col row0 ty, row1 ~ '[col ::: ty])
491instance (HasUnique tab (Join outer from) row0, Has col row0 ty, row1 ~ '[col ::: ty])
445 => IsLabel col
492 => IsLabel col
446− (Selection outer 'Ungrouped commons schemas params from row1) where
493+ (Selection outer commons 'Ungrouped schemas params from row1) where
447 fromLabel = fromLabel @col `as` Alias
494 fromLabel = fromLabel @col `as` Alias
448instance
495instance
449 ( HasUnique tab (Join outer from) row0
496 ( HasUnique tab (Join outer from) row0
@@ -451,10 +498,10 @@ instance
451 , row1 ~ '[col ::: ty]
498 , row1 ~ '[col ::: ty]
452 , GroupedBy tab col bys )
499 , GroupedBy tab col bys )
453 => IsLabel col
500 => IsLabel col
454− (Selection outer ('Grouped bys) commons schemas params from row1) where
501+ (Selection outer commons ('Grouped bys) schemas params from row1) where
455 fromLabel = fromLabel @col `as` Alias
502 fromLabel = fromLabel @col `as` Alias
456
503
457−instance RenderSQL (Selection outer grp commons schemas params from row) where
504+instance RenderSQL (Selection outer commons grp schemas params from row) where
458 renderSQL = \case
505 renderSQL = \case
459 List list -> renderCommaSeparated (renderAliased renderSQL) list
506 List list -> renderCommaSeparated (renderAliased renderSQL) list
460 Star -> "*"
507 Star -> "*"
@@ -463,7 +510,7 @@ instance RenderSQL (Selection outer grp commons schemas params from row) where
463 Over winFns winDef ->
510 Over winFns winDef ->
464 let
511 let
465 renderOver
512 renderOver
466− :: Aliased (WindowFunction outer grp commons schemas params from) field
513+ :: Aliased (WindowFunction outer commons grp schemas params from) field
467 -> ByteString
514 -> ByteString
468 renderOver (winFn `As` col) = renderSQL winFn
515 renderOver (winFn `As` col) = renderSQL winFn
469 <+> "OVER" <+> parenthesized (renderSQL winDef)
516 <+> "OVER" <+> parenthesized (renderSQL winDef)
@@ -472,7 +519,7 @@ instance RenderSQL (Selection outer grp commons schemas params from row) where
472 renderCommaSeparated renderOver winFns
519 renderCommaSeparated renderOver winFns
473
520
474instance IsString
521instance IsString
475− (Selection outer grp commons schemas params from '["fromOnly" ::: 'NotNull 'PGtext]) where
522+ (Selection outer commons grp schemas params from '["fromOnly" ::: 'NotNull 'PGtext]) where
476 fromString str = fromString str `as` Alias
523 fromString str = fromString str `as` Alias
477
524
478-- | the `TableExpression` in the `select` command constructs an intermediate
525-- | the `TableExpression` in the `select` command constructs an intermediate
@@ -482,9 +529,9 @@ instance IsString
482-- the intermediate table are actually output.
529-- the intermediate table are actually output.
483select
530select
484 :: (SListI row, row ~ (x ': xs))
531 :: (SListI row, row ~ (x ': xs))
485− => Selection outer grp commons schemas params from row
532+ => Selection outer commons grp schemas params from row
486− -- ^ select list
533+ -- ^ selection
487− -> TableExpression outer grp commons schemas params from
534+ -> TableExpression outer commons grp schemas params from
488 -- ^ intermediate virtual table
535 -- ^ intermediate virtual table
489 -> Query outer commons schemas params row
536 -> Query outer commons schemas params row
490select selection tabexpr = UnsafeQuery $
537select selection tabexpr = UnsafeQuery $
@@ -492,20 +539,24 @@ select selection tabexpr = UnsafeQuery $
492 <+> renderSQL selection
539 <+> renderSQL selection
493 <+> renderSQL tabexpr
540 <+> renderSQL tabexpr
494
541
542+-- | Like `select` but takes an `NP` list of `Expression`s instead
543+-- of a general `Selection`.
495select_
544select_
496 :: (SListI row, row ~ (x ': xs))
545 :: (SListI row, row ~ (x ': xs))
497− => NP (Aliased (Expression outer grp commons schemas params from)) row
546+ => NP (Aliased (Expression outer commons grp schemas params from)) row
547+ -- ^ select list
498− -> TableExpression outer grp commons schemas params from
548+ -> TableExpression outer commons grp schemas params from
549+ -- ^ intermediate virtual table
499 -> Query outer commons schemas params row
550 -> Query outer commons schemas params row
500−select_ list = select (List list)
551+select_ = select . List
501
552
502-- | After the select list has been processed, the result table can
553-- | After the select list has been processed, the result table can
503-- be subject to the elimination of duplicate rows using `selectDistinct`.
554-- be subject to the elimination of duplicate rows using `selectDistinct`.
504selectDistinct
555selectDistinct
505 :: (SListI columns, columns ~ (col ': cols))
556 :: (SListI columns, columns ~ (col ': cols))
506− => Selection outer 'Ungrouped commons schemas params from columns
557+ => Selection outer commons grp schemas params from columns
507− -- ^ select list
558+ -- ^ selection
508− -> TableExpression outer 'Ungrouped commons schemas params from
559+ -> TableExpression outer commons grp schemas params from
509 -- ^ intermediate virtual table
560 -- ^ intermediate virtual table
510 -> Query outer commons schemas params columns
561 -> Query outer commons schemas params columns
511selectDistinct selection tabexpr = UnsafeQuery $
562selectDistinct selection tabexpr = UnsafeQuery $
@@ -513,14 +564,65 @@ selectDistinct selection tabexpr = UnsafeQuery $
513 <+> renderSQL selection
564 <+> renderSQL selection
514 <+> renderSQL tabexpr
565 <+> renderSQL tabexpr
515
566
567+-- | Like `selectDistinct` but takes an `NP` list of `Expression`s instead
568+-- of a general `Selection`.
516selectDistinct_
569selectDistinct_
517 :: (SListI columns, columns ~ (col ': cols))
570 :: (SListI columns, columns ~ (col ': cols))
518− => NP (Aliased (Expression outer 'Ungrouped commons schemas params from)) columns
571+ => NP (Aliased (Expression outer commons grp schemas params from)) columns
519 -- ^ select list
572 -- ^ select list
520− -> TableExpression outer 'Ungrouped commons schemas params from
573+ -> TableExpression outer commons grp schemas params from
574+ -- ^ intermediate virtual table
575+ -> Query outer commons schemas params columns
576+selectDistinct_ = selectDistinct . List
577+
578+{-|
579+`selectDistinctOn` keeps only the first row of each set of rows where
580+the given expressions evaluate to equal. The DISTINCT ON expressions are
581+interpreted using the same rules as for ORDER BY. ORDER BY is used to
582+ensure that the desired row appears first.
583+
584+The DISTINCT ON expression(s) must match the leftmost ORDER BY expression(s).
585+The ORDER BY clause will normally contain additional expression(s) that
586+determine the desired precedence of rows within each DISTINCT ON group.
587+
588+In order to guarantee they match and reduce redundancy, this function
589+will prepend the The DISTINCT ON expressions to the ORDER BY clause.
590+-}
591+selectDistinctOn
592+ :: (SListI columns, columns ~ (col ': cols))
593+ => [SortExpression outer commons grp schemas params from]
594+ -- ^ DISTINCT ON expression(s) and prepended to ORDER BY clause
595+ -> Selection outer commons grp schemas params from columns
596+ -- ^ selection
597+ -> TableExpression outer commons grp schemas params from
521 -- ^ intermediate virtual table
598 -- ^ intermediate virtual table
522 -> Query outer commons schemas params columns
599 -> Query outer commons schemas params columns
523−selectDistinct_ list = select (List list)
600+selectDistinctOn distincts selection tab = UnsafeQuery $
601+ "SELECT DISTINCT ON"
602+ <+> parenthesized (commaSeparated (renderDistinctOn <$> distincts))
603+ <+> renderSQL selection
604+ <+> renderSQL (tab {orderByClause = distincts <> orderByClause tab})
605+ where
606+ renderDistinctOn = \case
607+ Asc expression -> renderSQL expression
608+ Desc expression -> renderSQL expression
609+ AscNullsFirst expression -> renderSQL expression
610+ DescNullsFirst expression -> renderSQL expression
611+ AscNullsLast expression -> renderSQL expression
612+ DescNullsLast expression -> renderSQL expression
613+
614+-- | Like `selectDistinctOn` but takes an `NP` list of `Expression`s instead
615+-- of a general `Selection`.
616+selectDistinctOn_
617+ :: (SListI columns, columns ~ (col ': cols))
618+ => [SortExpression outer commons grp schemas params from]
619+ -- ^ distinct on and return the first row in ordering
620+ -> NP (Aliased (Expression outer commons grp schemas params from)) columns
621+ -- ^ selection
622+ -> TableExpression outer commons grp schemas params from
623+ -- ^ intermediate virtual table
624+ -> Query outer commons schemas params columns
625+selectDistinctOn_ distincts = selectDistinctOn distincts . List
524
626
525-- | `values` computes a row value or set of row values
627-- | `values` computes a row value or set of row values
526-- specified by value expressions. It is most commonly used
628-- specified by value expressions. It is most commonly used
@@ -533,8 +635,8 @@ selectDistinct_ list = select (List list)
533-- SELECT * FROM (VALUES (1, E'one')) AS t ("a", "b")
635-- SELECT * FROM (VALUES (1, E'one')) AS t ("a", "b")
534values
636values
535 :: SListI cols
637 :: SListI cols
536− => NP (Aliased (Expression outer 'Ungrouped commons schemas params '[] )) cols
638+ => NP (Aliased (Expression outer commons 'Ungrouped schemas params '[] )) cols
537− -> [NP (Aliased (Expression outer 'Ungrouped commons schemas params '[] )) cols]
639+ -> [NP (Aliased (Expression outer commons 'Ungrouped schemas params '[] )) cols]
538 -- ^ When more than one row is specified, all the rows must
640 -- ^ When more than one row is specified, all the rows must
539 -- must have the same number of elements
641 -- must have the same number of elements
540 -> Query outer commons schemas params cols
642 -> Query outer commons schemas params cols
@@ -548,7 +650,7 @@ values rw rws = UnsafeQuery $ "SELECT * FROM"
548 <+> parenthesized (renderCommaSeparated renderAliasPart rw)
650 <+> parenthesized (renderCommaSeparated renderAliasPart rw)
549 where
651 where
550 renderAliasPart, renderValuePart
652 renderAliasPart, renderValuePart
551− :: Aliased (Expression outer 'Ungrouped commons schemas params '[] ) ty -> ByteString
653+ :: Aliased (Expression outer commons 'Ungrouped schemas params '[] ) ty -> ByteString
552 renderAliasPart (_ `As` name) = renderSQL name
654 renderAliasPart (_ `As` name) = renderSQL name
553 renderValuePart (value `As` _) = renderSQL value
655 renderValuePart (value `As` _) = renderSQL value
554
656
@@ -556,7 +658,7 @@ values rw rws = UnsafeQuery $ "SELECT * FROM"
556-- specified by value expressions.
658-- specified by value expressions.
557values_
659values_
558 :: SListI cols
660 :: SListI cols
559− => NP (Aliased (Expression outer 'Ungrouped commons schemas params '[] )) cols
661+ => NP (Aliased (Expression outer commons 'Ungrouped schemas params '[] )) cols
560 -- ^ one row of values
662 -- ^ one row of values
561 -> Query outer commons schemas params cols
663 -> Query outer commons schemas params cols
562values_ rw = values rw []
664values_ rw = values rw []
@@ -573,8 +675,8 @@ Table Expressions
573-- can be used to modify or combine base tables in various ways.
675-- can be used to modify or combine base tables in various ways.
574data TableExpression
676data TableExpression
575 (outer :: FromType)
677 (outer :: FromType)
576− (grp :: Grouping)
577 (commons :: FromType)
678 (commons :: FromType)
679+ (grp :: Grouping)
578 (schemas :: SchemasType)
680 (schemas :: SchemasType)
579 (params :: [NullityType])
681 (params :: [NullityType])
580 (from :: FromType)
682 (from :: FromType)
@@ -582,7 +684,7 @@ data TableExpression
582 { fromClause :: FromClause outer commons schemas params from
684 { fromClause :: FromClause outer commons schemas params from
583 -- ^ A table reference that can be a table name, or a derived table such
685 -- ^ A table reference that can be a table name, or a derived table such
584 -- as a subquery, a @JOIN@ construct, or complex combinations of these.
686 -- as a subquery, a @JOIN@ construct, or complex combinations of these.
585− , whereClause :: [Condition outer 'Ungrouped commons schemas params from]
687+ , whereClause :: [Condition outer commons 'Ungrouped schemas params from]
586 -- ^ optional search coditions, combined with `.&&`. After the processing
688 -- ^ optional search coditions, combined with `.&&`. After the processing
587 -- of the `fromClause` is done, each row of the derived virtual table
689 -- of the `fromClause` is done, each row of the derived virtual table
588 -- is checked against the search condition. If the result of the
690 -- is checked against the search condition. If the result of the
@@ -598,13 +700,13 @@ data TableExpression
598 -- set of rows having common values into one group row that represents all
700 -- set of rows having common values into one group row that represents all
599 -- rows in the group. This is done to eliminate redundancy in the output
701 -- rows in the group. This is done to eliminate redundancy in the output
600 -- and/or compute aggregates that apply to these groups.
702 -- and/or compute aggregates that apply to these groups.
601− , havingClause :: HavingClause outer grp commons schemas params from
703+ , havingClause :: HavingClause outer commons grp schemas params from
602 -- ^ If a table has been grouped using `groupBy`, but only certain groups
704 -- ^ If a table has been grouped using `groupBy`, but only certain groups
603 -- are of interest, the `havingClause` can be used, much like a
705 -- are of interest, the `havingClause` can be used, much like a
604 -- `whereClause`, to eliminate groups from the result. Expressions in the
706 -- `whereClause`, to eliminate groups from the result. Expressions in the
605 -- `havingClause` can refer both to grouped expressions and to ungrouped
707 -- `havingClause` can refer both to grouped expressions and to ungrouped
606 -- expressions (which necessarily involve an aggregate function).
708 -- expressions (which necessarily involve an aggregate function).
607− , orderByClause :: [SortExpression outer grp commons schemas params from]
709+ , orderByClause :: [SortExpression outer commons grp schemas params from]
608 -- ^ The `orderByClause` is for optional sorting. When more than one
710 -- ^ The `orderByClause` is for optional sorting. When more than one
609 -- `SortExpression` is specified, the later (right) values are used to sort
711 -- `SortExpression` is specified, the later (right) values are used to sort
610 -- rows that are equal according to the earlier (left) values.
712 -- rows that are equal according to the earlier (left) values.
@@ -621,7 +723,7 @@ data TableExpression
621 } deriving (GHC.Generic)
723 } deriving (GHC.Generic)
622
724
623-- | Render a `TableExpression`
725-- | Render a `TableExpression`
624−instance RenderSQL (TableExpression outer grp commons schemas params from) where
726+instance RenderSQL (TableExpression outer commons grp schemas params from) where
625 renderSQL
727 renderSQL
626 (TableExpression frm' whs' grps' hvs' srts' lims' offs') = mconcat
728 (TableExpression frm' whs' grps' hvs' srts' lims' offs') = mconcat
627 [ "FROM ", renderSQL frm'
729 [ "FROM ", renderSQL frm'
@@ -654,29 +756,29 @@ instance RenderSQL (TableExpression outer grp commons schemas params from) where
654-- to match the left-to-right sequencing of their placement in SQL.
756-- to match the left-to-right sequencing of their placement in SQL.
655from
757from
656 :: FromClause outer commons schemas params from -- ^ table reference
758 :: FromClause outer commons schemas params from -- ^ table reference
657− -> TableExpression outer 'Ungrouped commons schemas params from
759+ -> TableExpression outer commons 'Ungrouped schemas params from
658−from tab = TableExpression tab [] NoGroups NoHaving [] [] []
760+from tab = TableExpression tab [] noGroups NoHaving [] [] []
659
761
660-- | A `where_` is an endomorphism of `TableExpression`s which adds a
762-- | A `where_` is an endomorphism of `TableExpression`s which adds a
661-- search condition to the `whereClause`.
763-- search condition to the `whereClause`.
662where_
764where_
663− :: Condition outer 'Ungrouped commons schemas params from -- ^ filtering condition
765+ :: Condition outer commons 'Ungrouped schemas params from -- ^ filtering condition
664− -> TableExpression outer grp commons schemas params from
766+ -> TableExpression outer commons grp schemas params from
665− -> TableExpression outer grp commons schemas params from
767+ -> TableExpression outer commons grp schemas params from
666where_ wh rels = rels {whereClause = wh : whereClause rels}
768where_ wh rels = rels {whereClause = wh : whereClause rels}
667
769
668-- | A `groupBy` is a transformation of `TableExpression`s which switches
770-- | A `groupBy` is a transformation of `TableExpression`s which switches
669−-- its `Grouping` from `Ungrouped` to `Grouped`. Use @group Nil@ to perform
771+-- its `Grouping` from `Ungrouped` to `Grouped`. Use @groupBy Nil@ to perform
670-- a "grand total" aggregation query.
772-- a "grand total" aggregation query.
671groupBy
773groupBy
672 :: SListI bys
774 :: SListI bys
673 => NP (By from) bys -- ^ grouped columns
775 => NP (By from) bys -- ^ grouped columns
674− -> TableExpression outer 'Ungrouped commons schemas params from
776+ -> TableExpression outer commons 'Ungrouped schemas params from
675− -> TableExpression outer ('Grouped bys) commons schemas params from
777+ -> TableExpression outer commons ('Grouped bys) schemas params from
676groupBy bys rels = TableExpression
778groupBy bys rels = TableExpression
677 { fromClause = fromClause rels
779 { fromClause = fromClause rels
678 , whereClause = whereClause rels
780 , whereClause = whereClause rels
679− , groupByClause = Group bys
781+ , groupByClause = group bys
680 , havingClause = Having []
782 , havingClause = Having []
681 , orderByClause = []
783 , orderByClause = []
682 , limitClause = limitClause rels
784 , limitClause = limitClause rels
@@ -686,9 +788,9 @@ groupBy bys rels = TableExpression
686-- | A `having` is an endomorphism of `TableExpression`s which adds a
788-- | A `having` is an endomorphism of `TableExpression`s which adds a
687-- search condition to the `havingClause`.
789-- search condition to the `havingClause`.
688having
790having
689− :: Condition outer ('Grouped bys) commons schemas params from -- ^ having condition
791+ :: Condition outer commons ('Grouped bys) schemas params from -- ^ having condition
690− -> TableExpression outer ('Grouped bys) commons schemas params from
792+ -> TableExpression outer commons ('Grouped bys) schemas params from
691− -> TableExpression outer ('Grouped bys) commons schemas params from
793+ -> TableExpression outer commons ('Grouped bys) schemas params from
692having hv rels = rels
794having hv rels = rels
693 { havingClause = case havingClause rels of Having hvs -> Having (hv:hvs) }
795 { havingClause = case havingClause rels of Having hvs -> Having (hv:hvs) }
694
796
@@ -699,190 +801,22 @@ instance OrderBy TableExpression where
699-- `limitClause`.
801-- `limitClause`.
700limit
802limit
701 :: Word64 -- ^ limit parameter
803 :: Word64 -- ^ limit parameter
702− -> TableExpression outer grp commons schemas params from
804+ -> TableExpression outer commons grp schemas params from
703− -> TableExpression outer grp commons schemas params from
805+ -> TableExpression outer commons grp schemas params from
704limit lim rels = rels {limitClause = lim : limitClause rels}
806limit lim rels = rels {limitClause = lim : limitClause rels}
705
807
706-- | An `offset` is an endomorphism of `TableExpression`s which adds to the
808-- | An `offset` is an endomorphism of `TableExpression`s which adds to the
707-- `offsetClause`.
809-- `offsetClause`.
708offset
810offset
709 :: Word64 -- ^ offset parameter
811 :: Word64 -- ^ offset parameter
710− -> TableExpression outer grp commons schemas params from
812+ -> TableExpression outer commons grp schemas params from
711− -> TableExpression outer grp commons schemas params from
813+ -> TableExpression outer commons grp schemas params from
712offset off rels = rels {offsetClause = off : offsetClause rels}
814offset off rels = rels {offsetClause = off : offsetClause rels}
713
815
714−{-----------------------------------------
715−JSON stuff
716−-----------------------------------------}
717−
718−unsafeSetOfFunction
719− :: ByteString
720− -> Expression outer 'Ungrouped commons schemas params '[] ty
721− -> FromClause outer commons schemas params from
722−unsafeSetOfFunction fun expr = UnsafeFromClause $
723− fun <> "(" <> renderSQL expr <> ")"
724−
725−-- | Expand an array to a set of rows
726−unnest
727− :: Expression outer 'Ungrouped commons schemas params '[] (nullity ('PGvararray ty))
728− -> FromClause outer commons schemas params '["unnest" ::: '["unnest" ::: ty]]
729−unnest = unsafeSetOfFunction "unnest"
730−
731−-- | Expands the outermost JSON object into a set of key/value pairs.
732−-- >>> import Data.Aeson
733−-- >>> printSQL (select Star (from (jsonEach (jsonLit (object ["a" .= "foo", "b" .= "bar"])))))
734−-- SELECT * FROM json_each(('{"a":"foo","b":"bar"}' :: json))
735−jsonEach
736− :: Expression outer 'Ungrouped commons schemas params '[] (nullity 'PGjson) -- ^ json object
737− -> FromClause outer commons schemas params
738− '["json_each" ::: '["key" ::: 'NotNull 'PGtext, "value" ::: 'NotNull 'PGjson]]
739−jsonEach = unsafeSetOfFunction "json_each"
740−
741−-- | Expands the outermost binary JSON object into a set of key/value pairs.
742−-- >>> import Data.Aeson
743−-- >>> printSQL (select Star (from (jsonbEach (jsonbLit (object ["a" .= "foo", "b" .= "bar"])))))
744−-- SELECT * FROM jsonb_each(('{"a":"foo","b":"bar"}' :: jsonb))
745−jsonbEach
746− :: Expression outer 'Ungrouped commons schemas params '[] (nullity 'PGjsonb) -- ^ jsonb object
747− -> FromClause outer commons schemas params
748− '["jsonb_each" ::: '["key" ::: 'NotNull 'PGtext, "value" ::: 'NotNull 'PGjson]]
749−jsonbEach = unsafeSetOfFunction "jsonb_each"
750−
751−-- | Expands the outermost JSON object into a set of key/value pairs.-- | Expands the outermost binary JSON object into a set of key/value pairs.
752−-- >>> import Data.Aeson
753−-- >>> printSQL (select Star (from (jsonEachText (jsonLit (object ["a" .= "foo", "b" .= "bar"])))))
754−-- SELECT * FROM json_each_text(('{"a":"foo","b":"bar"}' :: json))
755−jsonEachText
756− :: Expression outer 'Ungrouped commons schemas params '[] (nullity 'PGjson) -- ^ json object
757− -> FromClause outer commons schemas params
758− '["json_each" ::: '["key" ::: 'NotNull 'PGtext, "value" ::: 'NotNull 'PGtext]]
759−jsonEachText = unsafeSetOfFunction "json_each_text"
760−
761−-- | Expands the outermost binary JSON object into a set of key/value pairs.
762−-- >>> import Data.Aeson
763−-- >>> printSQL (select Star (from (jsonbEachText (jsonbLit (object ["a" .= "foo", "b" .= "bar"])))))
764−-- SELECT * FROM jsonb_each_text(('{"a":"foo","b":"bar"}' :: jsonb))
765−jsonbEachText
766− :: Expression outer 'Ungrouped commons schemas params '[] (nullity 'PGjsonb) -- ^ jsonb object
767− -> FromClause outer commons schemas params
768− '["jsonb_each" ::: '["key" ::: 'NotNull 'PGtext, "value" ::: 'NotNull 'PGtext]]
769−jsonbEachText = unsafeSetOfFunction "jsonb_each_text"
770−
771−-- | Returns set of keys in the outermost JSON object.
772−-- >>> import Data.Aeson
773−-- >>> printSQL (jsonObjectKeys (jsonLit (object ["a" .= "foo", "b" .= "bar"])))
774−-- json_object_keys(('{"a":"foo","b":"bar"}' :: json))
775−jsonObjectKeys
776− :: Expression outer 'Ungrouped commons schemas params '[] (nullity 'PGjson) -- ^ json object
777− -> FromClause outer commons schemas params
778− '["json_object_keys" ::: '["json_object_keys" ::: 'NotNull 'PGtext]]
779−jsonObjectKeys = unsafeSetOfFunction "json_object_keys"
780−
781−-- | Returns set of keys in the outermost JSON object.
782−-- >>> import Data.Aeson
783−-- >>> printSQL (jsonbObjectKeys (jsonbLit (object ["a" .= "foo", "b" .= "bar"])))
784−-- jsonb_object_keys(('{"a":"foo","b":"bar"}' :: jsonb))
785−jsonbObjectKeys
786− :: Expression outer 'Ungrouped commons schemas params '[] (nullity 'PGjsonb) -- ^ jsonb object
787− -> FromClause outer commons schemas params
788− '["jsonb_object_keys" ::: '["jsonb_object_keys" ::: 'NotNull 'PGtext]]
789−jsonbObjectKeys = unsafeSetOfFunction "jsonb_object_keys"
790−
791−unsafePopulateFunction
792− :: KnownSymbol fun
793− => Alias fun
794− -> TypeExpression schemas (nullity ('PGcomposite row))
795− -> Expression outer 'Ungrouped commons schemas params '[] ty
796− -> FromClause outer commons schemas params '[fun ::: row]
797−unsafePopulateFunction fun ty expr = UnsafeFromClause $ renderSQL fun
798− <> parenthesized ("null::" <> renderSQL ty <> ", " <> renderSQL expr)
799−
800−-- | Expands the JSON expression to a row whose columns match the record
801−-- type defined by the given table.
802−jsonPopulateRecord
803− :: TypeExpression schemas (nullity ('PGcomposite row)) -- ^ row type
804− -> Expression outer 'Ungrouped commons schemas params '[] (nullity 'PGjson) -- ^ json object
805− -> FromClause outer commons schemas params '["json_populate_record" ::: row]
806−jsonPopulateRecord = unsafePopulateFunction #json_populate_record
807−
808−-- | Expands the binary JSON expression to a row whose columns match the record
809−-- type defined by the given table.
810−jsonbPopulateRecord
811− :: TypeExpression schemas (nullity ('PGcomposite row)) -- ^ row type
812− -> Expression outer 'Ungrouped commons schemas params '[] (nullity 'PGjsonb) -- ^ jsonb object
813− -> FromClause outer commons schemas params '["jsonb_populate_record" ::: row]
814−jsonbPopulateRecord = unsafePopulateFunction #jsonb_populate_record
815−
816−-- | Expands the outermost array of objects in the given JSON expression to a
817−-- set of rows whose columns match the record type defined by the given table.
818−jsonPopulateRecordSet
819− :: TypeExpression schemas (nullity ('PGcomposite row)) -- ^ row type
820− -> Expression outer 'Ungrouped commons schemas params '[] (nullity 'PGjson) -- ^ json array
821− -> FromClause outer commons schemas params '["json_populate_record_set" ::: row]
822−jsonPopulateRecordSet = unsafePopulateFunction #json_populate_record_set
823−
824−-- | Expands the outermost array of objects in the given binary JSON expression
825−-- to a set of rows whose columns match the record type defined by the given
826−-- table.
827−jsonbPopulateRecordSet
828− :: TypeExpression schemas (nullity ('PGcomposite row)) -- ^ row type
829− -> Expression outer 'Ungrouped commons schemas params '[] (nullity 'PGjsonb) -- ^ jsonb array
830− -> FromClause outer commons schemas params '["jsonb_populate_record_set" ::: row]
831−jsonbPopulateRecordSet = unsafePopulateFunction #jsonb_populate_record_set
832−
833−unsafeRecordFunction
834− :: (SListI record, json `In` PGJsonType)
835− => ByteString
836− -> Expression outer 'Ungrouped commons schemas params '[] (nullity json)
837− -> Aliased (NP (Aliased (TypeExpression schemas))) (tab ::: record)
838− -> FromClause outer commons schemas params '[tab ::: record]
839−unsafeRecordFunction fun expr (types `As` tab) = UnsafeFromClause $
840− fun <> parenthesized (renderSQL expr) <+> "AS" <+> renderSQL tab
841− <> parenthesized (renderCommaSeparated renderTy types)
842− where
843− renderTy :: Aliased (TypeExpression schemas) ty -> ByteString
844− renderTy (ty `As` alias) = renderSQL alias <+> renderSQL ty
845−
846−-- | Builds an arbitrary record from a JSON object.
847−jsonToRecord
848− :: SListI record
849− => Expression outer 'Ungrouped commons schemas params '[] (nullity 'PGjson) -- ^ json object
850− -> Aliased (NP (Aliased (TypeExpression schemas))) (tab ::: record)
851− -> FromClause outer commons schemas params '[tab ::: record]
852−jsonToRecord = unsafeRecordFunction "json_to_record"
853−
854−-- | Builds an arbitrary record from a binary JSON object.
855−jsonbToRecord
856− :: SListI record
857− => Expression outer 'Ungrouped commons schemas params '[] (nullity 'PGjsonb) -- ^ jsonb object
858− -> Aliased (NP (Aliased (TypeExpression schemas))) (tab ::: record)
859− -> FromClause outer commons schemas params '[tab ::: record]
860−jsonbToRecord = unsafeRecordFunction "jsonb_to_record"
861−
862−-- | Builds an arbitrary set of records from a JSON array of objects.
863−jsonToRecordSet
864− :: SListI record
865− => Expression outer 'Ungrouped commons schemas params '[] (nullity 'PGjson) -- ^ json array
866− -> Aliased (NP (Aliased (TypeExpression schemas))) (tab ::: record)
867− -> FromClause outer commons schemas params '[tab ::: record]
868−jsonToRecordSet = unsafeRecordFunction "json_to_record_set"
869−
870−-- | Builds an arbitrary set of records from a binary JSON array of objects.
871−jsonbToRecordSet
872− :: SListI record
873− => Expression outer 'Ungrouped commons schemas params '[] (nullity 'PGjsonb) -- ^ jsonb array
874− -> Aliased (NP (Aliased (TypeExpression schemas))) (tab ::: record)
875− -> FromClause outer commons schemas params '[tab ::: record]
876−jsonbToRecordSet = unsafeRecordFunction "jsonb_to_record_set"
877−
878{-----------------------------------------
816{-----------------------------------------
879FROM clauses
817FROM clauses
880-----------------------------------------}
818-----------------------------------------}
881
819
882−type family FromClause_ schemas params from where
883− FromClause_ schemas params from =
884− FromClause schemas (TuplePG params) (FromPG from)
885−
886{- |
820{- |
887A `FromClause` can be a table name, or a derived table such
821A `FromClause` can be a table name, or a derived table such
888as a subquery, a @JOIN@ construct, or complex combinations of these.
822as a subquery, a @JOIN@ construct, or complex combinations of these.
@@ -905,7 +839,7 @@ table (tab `As` alias) = UnsafeFromClause $
905subquery
839subquery
906 :: Aliased (Query outer commons schemas params) query
840 :: Aliased (Query outer commons schemas params) query
907 -> FromClause outer commons schemas params '[query]
841 -> FromClause outer commons schemas params '[query]
908−subquery = UnsafeFromClause . renderAliased (parenthesized . renderQuery)
842+subquery = UnsafeFromClause . renderAliased (parenthesized . renderSQL)
909
843
910-- | `view` derives a table from a `View`.
844-- | `view` derives a table from a `View`.
911view
845view
@@ -923,11 +857,16 @@ common
923common (cte `As` alias) = UnsafeFromClause $
857common (cte `As` alias) = UnsafeFromClause $
924 renderSQL cte <+> "AS" <+> renderSQL alias
858 renderSQL cte <+> "AS" <+> renderSQL alias
925
859
860+instance Additional (FromClause outer commons schemas params) where
861+ also right left = UnsafeFromClause $
862+ renderSQL left <> ", " <> renderSQL right
863+
864+{- |
926−{- | @left & crossJoin right@. For every possible combination of rows from
865+@left & crossJoin right@. For every possible combination of rows from
927− @left@ and @right@ (i.e., a Cartesian product), the joined table will contain
866+@left@ and @right@ (i.e., a Cartesian product), the joined table will contain
928− a row consisting of all columns in @left@ followed by all columns in @right@.
867+a row consisting of all columns in @left@ followed by all columns in @right@.
929− If the tables have @n@ and @m@ rows respectively, the joined table will
868+If the tables have @n@ and @m@ rows respectively, the joined table will
930− have @n * m@ rows.
869+have @n * m@ rows.
931-}
870-}
932crossJoin
871crossJoin
933 :: FromClause outer commons schemas params right
872 :: FromClause outer commons schemas params right
@@ -944,7 +883,7 @@ the @on@ condition.
944innerJoin
883innerJoin
945 :: FromClause outer commons schemas params right
884 :: FromClause outer commons schemas params right
946 -- ^ right
885 -- ^ right
947− -> Condition outer 'Ungrouped commons schemas params (Join left right)
886+ -> Condition outer commons 'Ungrouped schemas params (Join left right)
948 -- ^ @on@ condition
887 -- ^ @on@ condition
949 -> FromClause outer commons schemas params left
888 -> FromClause outer commons schemas params left
950 -- ^ left
889 -- ^ left
@@ -961,7 +900,7 @@ innerJoin right on left = UnsafeFromClause $
961leftOuterJoin
900leftOuterJoin
962 :: FromClause outer commons schemas params right
901 :: FromClause outer commons schemas params right
963 -- ^ right
902 -- ^ right
964− -> Condition outer 'Ungrouped commons schemas params (Join left right)
903+ -> Condition outer commons 'Ungrouped schemas params (Join left right)
965 -- ^ @on@ condition
904 -- ^ @on@ condition
966 -> FromClause outer commons schemas params left
905 -> FromClause outer commons schemas params left
967 -- ^ left
906 -- ^ left
@@ -979,7 +918,7 @@ leftOuterJoin right on left = UnsafeFromClause $
979rightOuterJoin
918rightOuterJoin
980 :: FromClause outer commons schemas params right
919 :: FromClause outer commons schemas params right
981 -- ^ right
920 -- ^ right
982− -> Condition outer 'Ungrouped commons schemas params (Join left right)
921+ -> Condition outer commons 'Ungrouped schemas params (Join left right)
983 -- ^ @on@ condition
922 -- ^ @on@ condition
984 -> FromClause outer commons schemas params left
923 -> FromClause outer commons schemas params left
985 -- ^ left
924 -- ^ left
@@ -998,7 +937,7 @@ rightOuterJoin right on left = UnsafeFromClause $
998fullOuterJoin
937fullOuterJoin
999 :: FromClause outer commons schemas params right
938 :: FromClause outer commons schemas params right
1000 -- ^ right
939 -- ^ right
1001− -> Condition outer 'Ungrouped commons schemas params (Join left right)
940+ -> Condition outer commons 'Ungrouped schemas params (Join left right)
1002 -- ^ @on@ condition
941 -- ^ @on@ condition
1003 -> FromClause outer commons schemas params left
942 -> FromClause outer commons schemas params left
1004 -- ^ left
943 -- ^ left
@@ -1053,125 +992,42 @@ instance (Has rel rels cols, Has col cols ty, bys ~ '[ '(rel, col)])
1053-- done on @NoGroups@ while all output `Expression`s must be aggregated
992-- done on @NoGroups@ while all output `Expression`s must be aggregated
1054-- in @Group Nil@. In general, all output `Expression`s in the
993-- in @Group Nil@. In general, all output `Expression`s in the
1055-- complement of @bys@ must be aggregated in @Group bys@.
994-- complement of @bys@ must be aggregated in @Group bys@.
1056−data GroupByClause grp from where
995+newtype GroupByClause grp from = UnsafeGroupByClause
1057− NoGroups :: GroupByClause 'Ungrouped from
996+ { renderGroupByClause :: ByteString }
1058− Group
997+ deriving (GHC.Generic,Show,Eq,Ord,NFData)
1059− :: SListI bys
1060− => NP (By from) bys
1061− -> GroupByClause ('Grouped bys) from
1062−
1063−-- | Renders a `GroupByClause`.
1064instance RenderSQL (GroupByClause grp from) where
998instance RenderSQL (GroupByClause grp from) where
1065− renderSQL = \case
999+ renderSQL = renderGroupByClause
1066− NoGroups -> ""
1000+noGroups :: GroupByClause 'Ungrouped from
1001+noGroups = UnsafeGroupByClause ""
1002+group
1003+ :: SListI bys
1004+ => NP (By from) bys
1005+ -> GroupByClause ('Grouped bys) from
1006+group bys = UnsafeGroupByClause $ case bys of
1067− Group Nil -> ""
1007+ Nil -> ""
1068− Group bys -> " GROUP BY" <+> renderCommaSeparated renderSQL bys
1008+ bys' -> " GROUP BY" <+> renderCommaSeparated renderSQL bys'
1069
1009
1070-- | A `HavingClause` is used to eliminate groups that are not of interest.
1010-- | A `HavingClause` is used to eliminate groups that are not of interest.
1071-- An `Ungrouped` `TableExpression` may only use `NoHaving` while a `Grouped`
1011-- An `Ungrouped` `TableExpression` may only use `NoHaving` while a `Grouped`
1072-- `TableExpression` must use `Having` whose conditions are combined with
1012-- `TableExpression` must use `Having` whose conditions are combined with
1073-- `.&&`.
1013-- `.&&`.
1074−data HavingClause outer grp commons schemas params from where
1014+data HavingClause outer commons grp schemas params from where
1075− NoHaving :: HavingClause outer 'Ungrouped commons schemas params from
1015+ NoHaving :: HavingClause outer commons 'Ungrouped schemas params from
1076 Having
1016 Having
1077− :: [Condition outer ('Grouped bys) commons schemas params from]
1017+ :: [Condition outer commons ('Grouped bys) schemas params from]
1078− -> HavingClause outer ('Grouped bys) commons schemas params from
1018+ -> HavingClause outer commons ('Grouped bys) schemas params from
1079−deriving instance Show (HavingClause outer grp commons schemas params from)
1019+deriving instance Show (HavingClause outer commons grp schemas params from)
1080−deriving instance Eq (HavingClause outer grp commons schemas params from)
1020+deriving instance Eq (HavingClause outer commons grp schemas params from)
1081−deriving instance Ord (HavingClause outer grp commons schemas params from)
1021+deriving instance Ord (HavingClause outer commons grp schemas params from)
1082
1022
1083-- | Render a `HavingClause`.
1023-- | Render a `HavingClause`.
1084−instance RenderSQL (HavingClause outer grp commons schemas params from) where
1024+instance RenderSQL (HavingClause outer commons grp schemas params from) where
1085 renderSQL = \case
1025 renderSQL = \case
1086 NoHaving -> ""
1026 NoHaving -> ""
1087 Having [] -> ""
1027 Having [] -> ""
1088 Having conditions ->
1028 Having conditions ->
1089 " HAVING" <+> commaSeparated (renderSQL <$> conditions)
1029 " HAVING" <+> commaSeparated (renderSQL <$> conditions)
1090
1030
1091−{- |
1092−The argument of `exists` is an arbitrary subquery. The subquery is evaluated
1093−to determine whether it returns any rows. If it returns at least one row,
1094−the result of `exists` is `true`; if the subquery returns no rows,
1095−the result of `exists` is `false`.
1096−
1097−The subquery can refer to variables from the surrounding query,
1098−which will act as constants during any one evaluation of the subquery.
1099−
1100−The subquery will generally only be executed long enough to determine whether
1101−at least one row is returned, not all the way to completion.
1102−-}
1103−exists
1104− :: Query (Join outer from) commons schemas params row
1105− -> Condition outer grp commons schemas params from
1106−exists query = UnsafeExpression $ "EXISTS" <+> parenthesized (renderSQL query)
1107−
1108−{- |
1109−The right-hand side is a parenthesized subquery, which must return
1110−exactly one column. The left-hand expression is evaluated and compared to each
1111−row of the subquery result using the given `Operator`,
1112−which must yield a Boolean result. The result of `subAll` is `true`
1113−if all rows yield true (including the case where the subquery returns no rows).
1114−The result is `false` if any `false` result is found.
1115−The result is `null_` if no comparison with a subquery row returns `false`,
1116−and at least one comparison returns `null_`.
1117−
1118−>>> printSQL $ subAll true (.==) (values_ (true `as` #foo))
1119−(TRUE = ALL (SELECT * FROM (VALUES (TRUE)) AS t ("foo")))
1120−-}
1121−subAll
1122− :: Expression outer grp commons schemas params from ty1 -- ^ expression
1123− -> Operator ty1 ty2 ('Null 'PGbool) -- ^ operator
1124− -> Query (Join outer from) commons schemas params '[col ::: ty2] -- ^ subquery
1125− -> Condition outer grp commons schemas params from
1126−subAll expr (?) qry = expr ?
1127− (UnsafeExpression $ "ALL" <+> parenthesized (renderSQL qry))
1128−
1129−{- |
1130−The right-hand side is a parenthesized subquery, which must return exactly one column.
1131−The left-hand expression is evaluated and compared to each row of the subquery result
1132−using the given `Operator`, which must yield a Boolean result. The result of `subAny` is `true`
1133−if any `true` result is obtained. The result is `false` if no true result is found
1134−(including the case where the subquery returns no rows).
1135−
1136−>>> printSQL $ subAll "foo" like (values_ ("foobar" `as` #foo))
1137−(E'foo' LIKE ALL (SELECT * FROM (VALUES (E'foobar')) AS t ("foo")))
1138−-}
1139−subAny
1140− :: Expression outer grp commons schemas params from ty1 -- ^ expression
1141− -> Operator ty1 ty2 ('Null 'PGbool) -- ^ operator
1142− -> Query (Join outer from) commons schemas params '[col ::: ty2] -- ^ subquery
1143− -> Condition outer grp commons schemas params from
1144−subAny expr (?) qry = expr ?
1145− (UnsafeExpression $ "ANY" <+> parenthesized (renderSQL qry))
1146−
1147−{- |
1148−The result is `true` if the left-hand expression's result is equal
1149−to any of the right-hand expressions.
1150−
1151−>>> printSQL $ true `in_` [true, false, null_]
1152−TRUE IN (TRUE, FALSE, NULL)
1153−-}
1154−in_
1155− :: Expression outer grp commons schemas params from ty -- ^ expression
1156− -> [Expression outer grp commons schemas params from ty]
1157− -> Condition outer grp commons schemas params from
1158−expr `in_` exprs = UnsafeExpression $ renderSQL expr <+> "IN"
1159− <+> parenthesized (commaSeparated (renderSQL <$> exprs))
1160−
1161−{- |
1162−The result is `true` if the left-hand expression's result is not equal
1163−to any of the right-hand expressions.
1164−
1165−>>> printSQL $ true `notIn` [false, null_]
1166−TRUE NOT IN (FALSE, NULL)
1167−-}
1168−notIn
1169− :: Expression outer grp commons schemas params from ty -- ^ expression
1170− -> [Expression outer grp commons schemas params from ty]
1171− -> Condition outer grp commons schemas params from
1172−expr `notIn` exprs = UnsafeExpression $ renderSQL expr <+> "NOT IN"
1173− <+> parenthesized (commaSeparated (renderSQL <$> exprs))
1174−
1175-- | A `CommonTableExpression` is an auxiliary statement in a `with` clause.
1031-- | A `CommonTableExpression` is an auxiliary statement in a `with` clause.
1176data CommonTableExpression statement
1032data CommonTableExpression statement
1177 (schemas :: SchemasType)
1033 (schemas :: SchemasType)
@@ -1193,8 +1049,8 @@ instance
1193 , commons1 ~ (cte ::: common ': commons)
1049 , commons1 ~ (cte ::: common ': commons)
1194 ) => Aliasable cte
1050 ) => Aliasable cte
1195 (statement commons schemas params common)
1051 (statement commons schemas params common)
1196− (AlignedList (CommonTableExpression statement schemas params) commons commons1) where
1052+ (Path (CommonTableExpression statement schemas params) commons commons1) where
1197− statement `as` cte = single (statement `as` cte)
1053+ statement `as` cte = csingleton (statement `as` cte)
1198
1054
1199instance (forall c s p r. RenderSQL (statement c s p r)) => RenderSQL
1055instance (forall c s p r. RenderSQL (statement c s p r)) => RenderSQL
1200 (CommonTableExpression statement schemas params commons0 commons1) where
1056 (CommonTableExpression statement schemas params commons0 commons1) where
@@ -1206,7 +1062,7 @@ instance (forall c s p r. RenderSQL (statement c s p r)) => RenderSQL
1206-- defining temporary tables that exist just for one query.
1062-- defining temporary tables that exist just for one query.
1207class With statement where
1063class With statement where
1208 with
1064 with
1209− :: AlignedList (CommonTableExpression statement schemas params) commons0 commons1
1065+ :: Path (CommonTableExpression statement schemas params) commons0 commons1
1210 -- ^ common table expressions
1066 -- ^ common table expressions
1211 -> statement commons1 schemas params row
1067 -> statement commons1 schemas params row
1212 -- ^ larger query
1068 -- ^ larger query
@@ -1214,4 +1070,29 @@ class With statement where
1214instance With (Query outer) where
1070instance With (Query outer) where
1215 with Done query = query
1071 with Done query = query
1216 with ctes query = UnsafeQuery $
1072 with ctes query = UnsafeQuery $
1073+ "WITH" <+> commaSeparated (ctoList renderSQL ctes) <+> renderSQL query
1074+
1075+{- |
1076+>>> import Data.Monoid (Sum (..))
1077+>>> import Data.Int (Int64)
1078+>>> :{
1079+ let
1080+ query :: Query_ schema () (Sum Int64)
1081+ query = withRecursive
1082+ ( values_ ((1 & astype int) `as` #n)
1083+ `unionAll`
1084+ select_ ((#n + 1) `as` #n)
1085+ (from (common #t) & where_ (#n .< 100)) `as` #t )
1086+ ( select_ (fromNull 0 (sum_ (All #n)) `as` #getSum) (from (common #t) & groupBy Nil))
1087+ in printSQL query
1088+:}
1089+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" < 100))) SELECT COALESCE(sum(ALL "n"), 0) AS "getSum" FROM "t" AS "t"
1090+-}
1091+withRecursive
1092+ :: Aliased (Query outer (recursive ': commons) schemas params) recursive
1093+ -> Query outer (recursive ': commons) schemas params row
1094+ -> Query outer commons schemas params row
1095+withRecursive (recursive `As` cte) query = UnsafeQuery $
1096+ "WITH RECURSIVE" <+> renderSQL cte
1097+ <+> "AS" <+> parenthesized (renderSQL recursive)
1217− "WITH" <+> renderSQL ctes <+> renderSQL query
1098+ <+> renderSQL query
squeal-postgresql/src/Squeal/PostgreSQL/Render.hs+39−6
@@ -10,31 +10,37 @@ Rendering helper functions.
10
10
11{-# LANGUAGE
11{-# LANGUAGE
12 AllowAmbiguousTypes
12 AllowAmbiguousTypes
13+ , ConstraintKinds
13 , FlexibleContexts
14 , FlexibleContexts
15+ , LambdaCase
14 , MagicHash
16 , MagicHash
15 , OverloadedStrings
17 , OverloadedStrings
16 , PolyKinds
18 , PolyKinds
17 , RankNTypes
19 , RankNTypes
18 , ScopedTypeVariables
20 , ScopedTypeVariables
21+ , TypeApplications
19#-}
22#-}
20
23
21module Squeal.PostgreSQL.Render
24module Squeal.PostgreSQL.Render
22 ( -- * Render
25 ( -- * Render
26+ RenderSQL (..)
27+ , printSQL
28+ , escape
23− parenthesized
29+ , parenthesized
30+ , bracketed
24 , (<+>)
31 , (<+>)
25 , commaSeparated
32 , commaSeparated
26 , doubleQuoted
33 , doubleQuoted
27 , singleQuotedText
34 , singleQuotedText
28 , singleQuotedUtf8
35 , singleQuotedUtf8
29 , renderCommaSeparated
36 , renderCommaSeparated
37+ , renderCommaSeparatedConstraint
30 , renderCommaSeparatedMaybe
38 , renderCommaSeparatedMaybe
31 , renderNat
39 , renderNat
32 , renderSymbol
40 , renderSymbol
33− , RenderSQL (..)
34− , printSQL
35 ) where
41 ) where
36
42
37−import Control.Monad.Base
43+import Control.Monad.IO.Class (MonadIO (..))
38import Data.ByteString (ByteString)
44import Data.ByteString (ByteString)
39import Data.Maybe (catMaybes)
45import Data.Maybe (catMaybes)
40import Data.Monoid ((<>))
46import Data.Monoid ((<>))
@@ -52,6 +58,10 @@ import qualified Data.ByteString.Char8 as Char8
52parenthesized :: ByteString -> ByteString
58parenthesized :: ByteString -> ByteString
53parenthesized str = "(" <> str <> ")"
59parenthesized str = "(" <> str <> ")"
54
60
61+-- | Square bracket a `ByteString`
62+bracketed :: ByteString -> ByteString
63+bracketed str = "[" <> str <> "]"
64+
55-- | Concatenate two `ByteString`s with a space between.
65-- | Concatenate two `ByteString`s with a space between.
56(<+>) :: ByteString -> ByteString -> ByteString
66(<+>) :: ByteString -> ByteString -> ByteString
57infixr 7 <+>
67infixr 7 <+>
@@ -84,6 +94,16 @@ renderCommaSeparated render
84 . hcollapse
94 . hcollapse
85 . hmap (K . render)
95 . hmap (K . render)
86
96
97+-- | Comma separate the renderings of a heterogeneous list.
98+renderCommaSeparatedConstraint
99+ :: forall c xs expression. (All c xs, SListI xs)
100+ => (forall x. c x => expression x -> ByteString)
101+ -> NP expression xs -> ByteString
102+renderCommaSeparatedConstraint render
103+ = commaSeparated
104+ . hcollapse
105+ . hcmap (Proxy @c) (K . render)
106+
87-- | Comma separate the `Maybe` renderings of a heterogeneous list, dropping
107-- | Comma separate the `Maybe` renderings of a heterogeneous list, dropping
88-- `Nothing`s.
108-- `Nothing`s.
89renderCommaSeparatedMaybe
109renderCommaSeparatedMaybe
@@ -108,5 +128,18 @@ renderSymbol = fromString (symbolVal' (proxy# :: Proxy# s))
108class RenderSQL sql where renderSQL :: sql -> ByteString
128class RenderSQL sql where renderSQL :: sql -> ByteString
109
129
110-- | Print SQL.
130-- | Print SQL.
111−printSQL :: (RenderSQL sql, MonadBase IO io) => sql -> io ()
131+printSQL :: (RenderSQL sql, MonadIO io) => sql -> io ()
112−printSQL = liftBase . Char8.putStrLn . renderSQL
132+printSQL = liftIO . Char8.putStrLn . renderSQL
133+
134+-- | `escape` a character to prevent injection
135+escape :: Char -> String
136+escape = \case
137+ '\NUL' -> "\\0"
138+ '\'' -> "''"
139+ '"' -> "\\\""
140+ '\b' -> "\\b"
141+ '\n' -> "\\n"
142+ '\r' -> "\\r"
143+ '\t' -> "\\t"
144+ '\\' -> "\\\\"
145+ c -> [c]
squeal-postgresql/src/Squeal/PostgreSQL/Schema.hs+180−376
@@ -1,16 +1,15 @@
1{-|
1{-|
2Module: Squeal.PostgreSQL.Schema
2Module: Squeal.PostgreSQL.Schema
3Description: Embedding of PostgreSQL type and alias system
3Description: Embedding of PostgreSQL type and alias system
4−Copyright: (c) Eitan Chatav, 2017
4+Copyright: (c) Eitan Chatav, 2019
5Maintainer: eitan@morphism.tech
5Maintainer: eitan@morphism.tech
6Stability: experimental
6Stability: experimental
7
7
8−This module provides a type-level DSL for kinds of Postgres types,
8+`Squeal.PostgreSQL.Schema` provides a type-level DSL for kinds of Postgres types,
9tables, schema, constraints, aliases, enumerated labels, and groupings.
9tables, schema, constraints, aliases, enumerated labels, and groupings.
10It also defines useful type families to operate on these. Finally,
10It also defines useful type families to operate on these. Finally,
11it defines an embedding of Haskell types into Postgres types.
11it defines an embedding of Haskell types into Postgres types.
12-}
12-}
13−{-# OPTIONS_GHC -fno-warn-unticked-promoted-constructors #-}
14{-# LANGUAGE
13{-# LANGUAGE
15 AllowAmbiguousTypes
14 AllowAmbiguousTypes
16 , ConstraintKinds
15 , ConstraintKinds
@@ -45,6 +44,10 @@ module Squeal.PostgreSQL.Schema
45 , ColumnsType
44 , ColumnsType
46 , TableType
45 , TableType
47 , SchemumType (..)
46 , SchemumType (..)
47+ , IndexType (..)
48+ , FunctionType
49+ , OperatorType (..)
50+ , ReturnsType (..)
48 , SchemaType
51 , SchemaType
49 , SchemasType
52 , SchemasType
50 , Public
53 , Public
@@ -54,53 +57,30 @@ module Squeal.PostgreSQL.Schema
54 , TableConstraint (..)
57 , TableConstraint (..)
55 , TableConstraints
58 , TableConstraints
56 , Uniquely
59 , Uniquely
57− -- * Aliases
58− , (:::)
59− , Alias (..)
60− , IsLabel (..)
61− , Aliased (As)
62− , Aliasable (as)
63− , renderAliased
64− , Has
65− , HasUnique
66− , HasAll
67− , QualifiedAlias (..)
68− , IsQualified (..)
69− , HasIn
70− , IsNotElem
71− , AllUnique
72− , DefaultAliasable (..)
73 -- * Enumerated Labels
60 -- * Enumerated Labels
74 , IsPGlabel (..)
61 , IsPGlabel (..)
75 , PGlabel (..)
62 , PGlabel (..)
76− -- * Grouping
77− , Grouping (..)
78− , GroupedBy
79− -- * Aligned lists
80− , AlignedList (..)
81− , single
82 -- * Data Definitions
63 -- * Data Definitions
83 , Create
64 , Create
65+ , CreateIfNotExists
66+ , CreateOrReplace
84 , Drop
67 , Drop
68+ , DropSchemum
69+ , DropIfExists
70+ , DropSchemumIfExists
85 , Alter
71 , Alter
72+ , AlterIfExists
86 , Rename
73 , Rename
74+ , RenameIfExists
75+ , ConstraintInvolves
87 , DropIfConstraintsInvolve
76 , DropIfConstraintsInvolve
88− -- * Lists
77+ , IsNotElem
89− , Join
78+ , AllUnique
90− , disjoin
91− , Elem
92− , In
93− , Length
94− , (*:)
95 -- * Type Classifications
79 -- * Type Classifications
96− , HasOid (..)
97 , PGNum
80 , PGNum
98 , PGIntegral
81 , PGIntegral
99 , PGFloating
82 , PGFloating
100 , PGTypeOf
83 , PGTypeOf
101− , PGArrayOf
102− , PGArray
103− , PGTextArray
104 , PGJsonType
84 , PGJsonType
105 , PGJsonKey
85 , PGJsonKey
106 , SamePGType
86 , SamePGType
@@ -117,25 +97,22 @@ module Squeal.PostgreSQL.Schema
117 ) where
97 ) where
118
98
119import Control.Category
99import Control.Category
120−import Control.DeepSeq
121−import Data.ByteString (ByteString)
122import Data.Kind
100import Data.Kind
123import Data.Monoid hiding (All)
101import Data.Monoid hiding (All)
124−import Data.String
125import Data.Type.Bool
102import Data.Type.Bool
126−import Data.Word (Word32)
127import Generics.SOP
103import Generics.SOP
128−import GHC.OverloadedLabels
129import GHC.TypeLits
104import GHC.TypeLits
130import Prelude hiding (id, (.))
105import Prelude hiding (id, (.))
131
106
132−import qualified GHC.Generics as GHC
107+import Squeal.PostgreSQL.Alias
133−
108+import Squeal.PostgreSQL.List
134import Squeal.PostgreSQL.Render
109import Squeal.PostgreSQL.Render
135
110
111+-- $setup
112+-- >>> import Squeal.PostgreSQL
113+
136-- | `PGType` is the promoted datakind of PostgreSQL types.
114-- | `PGType` is the promoted datakind of PostgreSQL types.
137--
115--
138−-- >>> import Squeal.PostgreSQL.Schema
139-- >>> :kind 'PGbool
116-- >>> :kind 'PGbool
140-- 'PGbool :: PGType
117-- 'PGbool :: PGType
141data PGType
118data PGType
@@ -166,37 +143,11 @@ data PGType
166 | PGenum [Symbol] -- ^ enumerated (enum) types are data types that comprise a static, ordered set of values.
143 | PGenum [Symbol] -- ^ enumerated (enum) types are data types that comprise a static, ordered set of values.
167 | PGcomposite RowType -- ^ a composite type represents the structure of a row or record; it is essentially just a list of field names and their data types.
144 | PGcomposite RowType -- ^ a composite type represents the structure of a row or record; it is essentially just a list of field names and their data types.
168 | PGtsvector -- ^ 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.
145 | PGtsvector -- ^ 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.
169− | PGtsquery -- ^ A tsquery value stores lexemes that are to be searched for
146+ | PGtsquery -- ^ A tsquery value stores lexemes that are to be searched for.
147+ | PGoid -- Object identifiers (OIDs) are used internally by PostgreSQL as primary keys for various system tables.
148+ | PGrange PGType -- ^ Range types are data types representing a range of values of some element type (called the range's subtype).
170 | UnsafePGType Symbol -- ^ an escape hatch for unsupported PostgreSQL types
149 | UnsafePGType Symbol -- ^ an escape hatch for unsupported PostgreSQL types
171
150
172−-- | The object identifier of a `PGType`.
173−--
174−-- >>> :set -XTypeApplications
175−-- >>> oid @'PGbool
176−-- 16
177−class HasOid (ty :: PGType) where oid :: Word32
178−instance HasOid 'PGbool where oid = 16
179−instance HasOid 'PGint2 where oid = 21
180−instance HasOid 'PGint4 where oid = 23
181−instance HasOid 'PGint8 where oid = 20
182−instance HasOid 'PGnumeric where oid = 1700
183−instance HasOid 'PGfloat4 where oid = 700
184−instance HasOid 'PGfloat8 where oid = 701
185−instance HasOid ('PGchar n) where oid = 18
186−instance HasOid ('PGvarchar n) where oid = 1043
187−instance HasOid 'PGtext where oid = 25
188−instance HasOid 'PGbytea where oid = 17
189−instance HasOid 'PGtimestamp where oid = 1114
190−instance HasOid 'PGtimestamptz where oid = 1184
191−instance HasOid 'PGdate where oid = 1082
192−instance HasOid 'PGtime where oid = 1083
193−instance HasOid 'PGtimetz where oid = 1266
194−instance HasOid 'PGinterval where oid = 1186
195−instance HasOid 'PGuuid where oid = 2950
196−instance HasOid 'PGinet where oid = 869
197−instance HasOid 'PGjson where oid = 114
198−instance HasOid 'PGjsonb where oid = 3802
199−
200-- | `NullityType` encodes the potential presence or definite absence of a
151-- | `NullityType` encodes the potential presence or definite absence of a
201-- @NULL@ allowing operations which are sensitive to such to be well typed.
152-- @NULL@ allowing operations which are sensitive to such to be well typed.
202--
153--
@@ -215,11 +166,6 @@ data NullityType
215type (:=>) constraint ty = '(constraint,ty)
166type (:=>) constraint ty = '(constraint,ty)
216infixr 7 :=>
167infixr 7 :=>
217
168
218−-- | The alias operator `:::` is like a promoted version of `As`,
219−-- a type level pair between an alias and some type.
220−type (:::) (alias :: Symbol) ty = '(alias,ty)
221−infixr 6 :::
222−
223-- | `ColumnConstraint` encodes the availability of @DEFAULT@ for inserts and updates.
169-- | `ColumnConstraint` encodes the availability of @DEFAULT@ for inserts and updates.
224-- A column can be assigned a default value.
170-- A column can be assigned a default value.
225-- A data `Squeal.PostgreSQL.Manipulations.Manipulation` command can also
171-- A data `Squeal.PostgreSQL.Manipulations.Manipulation` command can also
@@ -314,9 +260,19 @@ type FromType = [(Symbol,RowType)]
314
260
315-- | `ColumnsToRow` removes column constraints.
261-- | `ColumnsToRow` removes column constraints.
316type family ColumnsToRow (columns :: ColumnsType) :: RowType where
262type family ColumnsToRow (columns :: ColumnsType) :: RowType where
317− ColumnsToRow '[] = '[]
263+ ColumnsToRow (column ::: _ :=> ty ': column1 ::: _ :=> ty1 ': column2 ::: _ :=> ty2 ': column3 ::: _ :=> ty3 ': column4 ::: _ :=> ty4 ': column5 ::: _ :=> ty5 ': columns) =
318− ColumnsToRow (column ::: constraint :=> ty ': columns) =
264+ column ::: ty ': column1 ::: ty1 ': column2 ::: ty2 ': column3 ::: ty3 ': column4 ::: ty4 ': column5 ::: ty5 ': ColumnsToRow columns
265+ ColumnsToRow (column ::: _ :=> ty ': column1 ::: _ :=> ty1 ': column2 ::: _ :=> ty2 ': column3 ::: _ :=> ty3 ': column4 ::: _ :=> ty4 ': columns) =
266+ column ::: ty ': column1 ::: ty1 ': column2 ::: ty2 ': column3 ::: ty3 ': column4 ::: ty4 ': ColumnsToRow columns
267+ ColumnsToRow (column ::: _ :=> ty ': column1 ::: _ :=> ty1 ': column2 ::: _ :=> ty2 ': column3 ::: _ :=> ty3 ': columns) =
268+ column ::: ty ': column1 ::: ty1 ': column2 ::: ty2 ': column3 ::: ty3 ': ColumnsToRow columns
269+ ColumnsToRow (column ::: _ :=> ty ': column1 ::: _ :=> ty1 ': column2 ::: _ :=> ty2 ': columns) =
270+ column ::: ty ': column1 ::: ty1 ': column2 ::: ty2 ': ColumnsToRow columns
271+ ColumnsToRow (column ::: _ :=> ty ': column1 ::: _ :=> ty1 ': columns) =
272+ column ::: ty ': column1 ::: ty1 ': ColumnsToRow columns
273+ ColumnsToRow (column ::: _ :=> ty ': columns) =
319 column ::: ty ': ColumnsToRow columns
274 column ::: ty ': ColumnsToRow columns
275+ ColumnsToRow '[] = '[]
320
276
321-- | `TableToColumns` removes table constraints.
277-- | `TableToColumns` removes table constraints.
322type family TableToColumns (table :: TableType) :: ColumnsType where
278type family TableToColumns (table :: TableType) :: ColumnsType where
@@ -326,212 +282,6 @@ type family TableToColumns (table :: TableType) :: ColumnsType where
326type family TableToRow (table :: TableType) :: RowType where
282type family TableToRow (table :: TableType) :: RowType where
327 TableToRow tab = ColumnsToRow (TableToColumns tab)
283 TableToRow tab = ColumnsToRow (TableToColumns tab)
328
284
329−-- | `Grouping` is an auxiliary namespace, created by
330−-- @GROUP BY@ clauses (`Squeal.PostgreSQL.Query.group`), and used
331−-- for typesafe aggregation
332−data Grouping
333− = Ungrouped -- ^ no aggregation permitted
334− | Grouped [(Symbol,Symbol)] -- ^ aggregation required for any column which is not grouped
335−
336−{- | A `GroupedBy` constraint indicates that a table qualified column is
337−a member of the auxiliary namespace created by @GROUP BY@ clauses and thus,
338−may be called in an output `Squeal.PostgreSQL.Expression.Expression` without aggregating.
339−-}
340−class (KnownSymbol table, KnownSymbol column)
341− => GroupedBy table column bys where
342−instance {-# OVERLAPPING #-} (KnownSymbol table, KnownSymbol column)
343− => GroupedBy table column ('(table,column) ': bys)
344−instance {-# OVERLAPPABLE #-}
345− ( KnownSymbol table
346− , KnownSymbol column
347− , GroupedBy table column bys
348− ) => GroupedBy table column (tabcol ': bys)
349−
350−-- | `Alias`es are proxies for a type level string or `Symbol`
351−-- and have an `IsLabel` instance so that with @-XOverloadedLabels@
352−--
353−-- >>> :set -XOverloadedLabels
354−-- >>> #foobar :: Alias "foobar"
355−-- Alias
356−data Alias (alias :: Symbol) = Alias
357− deriving (Eq,GHC.Generic,Ord,Show,NFData)
358−instance alias1 ~ alias2 => IsLabel alias1 (Alias alias2) where
359− fromLabel = Alias
360−instance aliases ~ '[alias] => IsLabel alias (NP Alias aliases) where
361− fromLabel = fromLabel :* Nil
362−-- | >>> printSQL (#jimbob :: Alias "jimbob")
363−-- "jimbob"
364−instance KnownSymbol alias => RenderSQL (Alias alias) where
365− renderSQL = doubleQuoted . fromString . symbolVal
366−
367−-- | >>> import Generics.SOP (NP(..))
368−-- >>> printSQL (#jimbob :* #kandi :: NP Alias '["jimbob", "kandi"])
369−-- "jimbob", "kandi"
370−instance All KnownSymbol aliases => RenderSQL (NP Alias aliases) where
371− renderSQL
372− = commaSeparated
373− . hcollapse
374− . hcmap (Proxy @KnownSymbol) (K . renderSQL)
375−
376−-- | The `As` operator is used to name an expression. `As` is like a demoted
377−-- version of `:::`.
378−--
379−-- >>> Just "hello" `As` #hi :: Aliased Maybe ("hi" ::: String)
380−-- As (Just "hello") Alias
381−data Aliased expression aliased where
382− As
383− :: KnownSymbol alias
384− => expression ty
385− -> Alias alias
386− -> Aliased expression (alias ::: ty)
387−deriving instance Show (expression ty)
388− => Show (Aliased expression (alias ::: ty))
389−deriving instance Eq (expression ty)
390− => Eq (Aliased expression (alias ::: ty))
391−deriving instance Ord (expression ty)
392− => Ord (Aliased expression (alias ::: ty))
393−instance (alias0 ~ alias1, alias0 ~ alias2, KnownSymbol alias2)
394− => IsLabel alias0 (Aliased Alias (alias1 ::: alias2)) where
395− fromLabel = fromLabel @alias2 `As` fromLabel @alias1
396−
397−-- | The `Aliasable` class provides a way to scrap your `Nil`s
398−-- in an `NP` list of `Aliased` expressions.
399−class KnownSymbol alias => Aliasable alias expression aliased
400− | aliased -> expression
401− , aliased -> alias
402− where as :: expression -> Alias alias -> aliased
403−instance (KnownSymbol alias, aliased ~ (alias ::: ty)) => Aliasable alias
404− (expression ty)
405− (Aliased expression aliased)
406− where
407− as = As
408−instance (KnownSymbol alias, tys ~ '[alias ::: ty]) => Aliasable alias
409− (expression ty)
410− (NP (Aliased expression) tys)
411− where
412− expression `as` alias = expression `As` alias :* Nil
413−
414−-- | >>> let renderMaybe = fromString . maybe "Nothing" (const "Just")
415−-- >>> renderAliased renderMaybe (Just (3::Int) `As` #an_int)
416−-- "Just AS \"an_int\""
417−renderAliased
418− :: (forall ty. expression ty -> ByteString)
419− -> Aliased expression aliased
420− -> ByteString
421−renderAliased render (expression `As` alias) =
422− render expression <> " AS " <> renderSQL alias
423−
424−-- | @HasUnique alias fields field@ is a constraint that proves that
425−-- @fields@ is a singleton of @alias ::: field@.
426−type HasUnique alias fields field = fields ~ '[alias ::: field]
427−
428−-- | @Has alias fields field@ is a constraint that proves that
429−-- @fields@ has a field of @alias ::: field@, inferring @field@
430−-- from @alias@ and @fields@.
431−class KnownSymbol alias =>
432− Has (alias :: Symbol) (fields :: [(Symbol,kind)]) (field :: kind)
433− | alias fields -> field where
434−instance {-# OVERLAPPING #-} KnownSymbol alias
435− => Has alias (alias ::: field ': fields) field
436−instance {-# OVERLAPPABLE #-} (KnownSymbol alias, Has alias fields field)
437− => Has alias (field' ': fields) field
438−
439−{-| @HasIn fields (alias ::: field)@ is a constraint that proves that
440−@fields@ has a field of @alias ::: field@. It is used in @UPDATE@s to
441−choose which subfields to update.
442−-}
443−class HasIn fields field where
444−instance (Has alias fields field) => HasIn fields (alias ::: field) where
445−
446−-- | Utility class for `AllUnique` to provide nicer error messages.
447−class IsNotElem x isElem where
448−instance IsNotElem x 'False where
449−instance (TypeError ( 'Text "Cannot assign to "
450− ':<>: 'ShowType alias
451− ':<>: 'Text " more than once"))
452− => IsNotElem '(alias, a) 'True where
453−
454−-- | No elem of @xs@ appears more than once, in the context of assignment.
455−class AllUnique (xs :: [(Symbol, a)]) where
456−instance AllUnique '[] where
457−instance (IsNotElem x (Elem x xs), AllUnique xs) => AllUnique (x ': xs) where
458−
459−{- |
460−The `DefaultAliasable` class is intended to help with Scrap your Nils
461−for default inserts and updates.
462−-}
463−class KnownSymbol alias
464− => DefaultAliasable alias aliased | aliased -> alias where
465− defaultAs :: Alias alias -> aliased
466−
467−-- | `HasAll` extends `Has` to take lists of @aliases@ and @fields@ and infer
468−-- a list of @subfields@.
469−class
470− ( All KnownSymbol aliases
471− ) => HasAll
472− (aliases :: [Symbol])
473− (fields :: [(Symbol,kind)])
474− (subfields :: [(Symbol,kind)])
475− | aliases fields -> subfields where
476−instance {-# OVERLAPPING #-} HasAll '[] fields '[]
477−instance {-# OVERLAPPABLE #-}
478− (Has alias fields field, HasAll aliases fields subfields)
479− => HasAll (alias ': aliases) fields (alias ::: field ': subfields)
480−
481−-- | Analagous to `IsLabel`, the constraint
482−-- `IsQualified` defines `!` for a column alias qualified
483−-- by a table alias.
484−class IsQualified table column expression where
485− (!) :: Alias table -> Alias column -> expression
486− infixl 9 !
487−instance IsQualified table column (Alias table, Alias column) where (!) = (,)
488−
489−{-| `QualifiedAlias`es enables multi-schema support by allowing a reference
490−to a `Table`, `Typedef` or `View` to be qualified by their schemas. By default,
491−a qualifier of @public@ is provided.
492−
493−>>> :{
494−let
495− alias1 :: QualifiedAlias "sch" "tab"
496− alias1 = #sch ! #tab
497− alias2 :: QualifiedAlias "public" "vw"
498− alias2 = #vw
499−in printSQL alias1 >> printSQL alias2
500−:}
501−"sch"."tab"
502−"vw"
503−-}
504−data QualifiedAlias (qualifier :: Symbol) (alias :: Symbol) = QualifiedAlias
505− deriving (Eq,GHC.Generic,Ord,Show,NFData)
506−instance (q ~ q', a ~ a') => IsQualified q a (QualifiedAlias q' a') where
507− _!_ = QualifiedAlias
508−instance (q' ~ "public", a ~ a') => IsLabel a (QualifiedAlias q' a') where
509− fromLabel = QualifiedAlias
510−instance (q0 ~ q1, a0 ~ a1, a1 ~ a2, KnownSymbol a2) =>
511− IsQualified q0 a0 (Aliased (QualifiedAlias q1) (a1 ::: a2)) where
512− _!_ = QualifiedAlias `As` Alias
513−instance (q ~ "public", a0 ~ a1, a1 ~ a2, KnownSymbol a2) =>
514− IsLabel a0 (Aliased (QualifiedAlias q) (a1 ::: a2)) where
515− fromLabel = QualifiedAlias `As` Alias
516−
517−instance (KnownSymbol q, KnownSymbol a)
518− => RenderSQL (QualifiedAlias q a) where
519− renderSQL _ =
520− let
521− qualifier = renderSQL (Alias @q)
522− alias = renderSQL (Alias @a)
523− in
524− if qualifier == "\"public\"" then alias else qualifier <> "." <> alias
525−
526−-- | @Elem@ is a promoted `Data.List.elem`.
527−type family Elem x xs where
528− Elem x '[] = 'False
529− Elem x (x ': xs) = 'True
530− Elem x (_ ': xs) = Elem x xs
531−
532−-- | @In x xs@ is a constraint that proves that @x@ is in @xs@.
533−type family In x xs :: Constraint where In x xs = Elem x xs ~ 'True
534−
535-- | Numeric Postgres types.
285-- | Numeric Postgres types.
536type PGNum =
286type PGNum =
537 '[ 'PGint2, 'PGint4, 'PGint8, 'PGnumeric, 'PGfloat4, 'PGfloat8]
287 '[ 'PGint2, 'PGint4, 'PGint8, 'PGnumeric, 'PGfloat4, 'PGfloat8]
@@ -542,37 +292,6 @@ type PGFloating = '[ 'PGfloat4, 'PGfloat8, 'PGnumeric]
542-- | Integral Postgres types.
292-- | Integral Postgres types.
543type PGIntegral = '[ 'PGint2, 'PGint4, 'PGint8]
293type PGIntegral = '[ 'PGint2, 'PGint4, 'PGint8]
544
294
545−-- | Error message helper for displaying unavailable\/unknown\/placeholder type
546−-- variables whose kind is known.
547−type Placeholder k = 'Text "(_::" :<>: 'ShowType k :<>: 'Text ")"
548−
549−type ErrArrayOf arr ty = arr :<>: 'Text " " :<>: ty
550−type ErrPGfixarrayOf t = ErrArrayOf ('ShowType 'PGfixarray :<>: 'Text " " :<>: Placeholder Nat) t
551−type ErrPGvararrayOf t = ErrArrayOf ('ShowType 'PGvararray) t
552−
553−-- | Ensure a type is a valid array type.
554−type family PGArray name arr :: Constraint where
555− PGArray name ('PGvararray x) = ()
556− PGArray name ('PGfixarray n x) = ()
557− PGArray name val = TypeError
558− ('Text name :<>: 'Text ": Unsatisfied PGArray constraint. Expected either: "
559− :$$: 'Text " • " :<>: ErrPGvararrayOf (Placeholder PGType)
560− :$$: 'Text " • " :<>: ErrPGfixarrayOf (Placeholder PGType)
561− :$$: 'Text "But got: " :<>: 'ShowType val)
562−
563−-- | Ensure a type is a valid array type with a specific element type.
564−type family PGArrayOf name arr ty :: Constraint where
565− PGArrayOf name ('PGvararray x) ty = x ~ ty
566− PGArrayOf name ('PGfixarray n x) ty = x ~ ty
567− PGArrayOf name val ty = TypeError
568− ( 'Text name :<>: 'Text "Unsatisfied PGArrayOf constraint. Expected either: "
569− :$$: 'Text " • " :<>: ErrPGvararrayOf ( 'ShowType ty )
570− :$$: 'Text " • " :<>: ErrPGfixarrayOf ( 'ShowType ty )
571− :$$: 'Text "But got: " :<>: 'ShowType val)
572−
573−-- | Ensure a type is a valid array type whose elements are text.
574−type PGTextArray name arr = PGArrayOf name arr ('NotNull 'PGtext)
575−
576-- | `PGTypeOf` forgets about @NULL@ and any column constraints.
295-- | `PGTypeOf` forgets about @NULL@ and any column constraints.
577type family PGTypeOf (ty :: NullityType) :: PGType where
296type family PGTypeOf (ty :: NullityType) :: PGType where
578 PGTypeOf (nullity pg) = pg
297 PGTypeOf (nullity pg) = pg
@@ -586,14 +305,24 @@ instance ty0 ~ ty1 => SamePGType
586
305
587-- | `AllNotNull` is a constraint that proves a `ColumnsType` has no @NULL@s.
306-- | `AllNotNull` is a constraint that proves a `ColumnsType` has no @NULL@s.
588type family AllNotNull (columns :: ColumnsType) :: Constraint where
307type family AllNotNull (columns :: ColumnsType) :: Constraint where
308+ AllNotNull (_ ::: _ :=> 'NotNull _ ': _ ::: _ :=> 'NotNull _ ': _ ::: _ :=> 'NotNull _ ': _ ::: _ :=> 'NotNull _ ': _ ::: _ :=> 'NotNull _ ': _ ::: _ :=> 'NotNull _ ': columns) = AllNotNull columns
309+ AllNotNull (_ ::: _ :=> 'NotNull _ ': _ ::: _ :=> 'NotNull _ ': _ ::: _ :=> 'NotNull _ ': _ ::: _ :=> 'NotNull _ ': _ ::: _ :=> 'NotNull _ ': columns) = AllNotNull columns
310+ AllNotNull (_ ::: _ :=> 'NotNull _ ': _ ::: _ :=> 'NotNull _ ': _ ::: _ :=> 'NotNull _ ': _ ::: _ :=> 'NotNull _ ': columns) = AllNotNull columns
311+ AllNotNull (_ ::: _ :=> 'NotNull _ ': _ ::: _ :=> 'NotNull _ ': _ ::: _ :=> 'NotNull _ ': columns) = AllNotNull columns
312+ AllNotNull (_ ::: _ :=> 'NotNull _ ': _ ::: _ :=> 'NotNull _ ': columns) = AllNotNull columns
313+ AllNotNull (_ ::: _ :=> 'NotNull _ ': columns) = AllNotNull columns
589 AllNotNull '[] = ()
314 AllNotNull '[] = ()
590− AllNotNull (column ::: def :=> 'NotNull ty ': columns) = AllNotNull columns
591
315
592-- | `NotAllNull` is a constraint that proves a `ColumnsType` has some
316-- | `NotAllNull` is a constraint that proves a `ColumnsType` has some
593-- @NOT NULL@.
317-- @NOT NULL@.
594type family NotAllNull (columns :: ColumnsType) :: Constraint where
318type family NotAllNull (columns :: ColumnsType) :: Constraint where
595− NotAllNull (column ::: def :=> 'NotNull ty ': columns) = ()
319+ NotAllNull (_ ::: _ :=> _ _ ': _ ::: _ :=> _ _ ': _ ::: _ :=> _ _ ': _ ::: _ :=> _ _ ': _ ::: _ :=> _ _ ': _ ::: _ :=> 'NotNull _ ': _) = ()
320+ NotAllNull (_ ::: _ :=> _ _ ': _ ::: _ :=> _ _ ': _ ::: _ :=> _ _ ': _ ::: _ :=> _ _ ': _ ::: _ :=> 'NotNull _ ': _) = ()
321+ NotAllNull (_ ::: _ :=> _ _ ': _ ::: _ :=> _ _ ': _ ::: _ :=> _ _ ': _ ::: _ :=> 'NotNull _ ': _) = ()
322+ NotAllNull (_ ::: _ :=> _ _ ': _ ::: _ :=> _ _ ': _ ::: _ :=> 'NotNull _ ': _) = ()
323+ NotAllNull (_ ::: _ :=> _ _ ': _ ::: _ :=> 'NotNull _ ': _) = ()
324+ NotAllNull (_ ::: _ :=> 'NotNull _ ': _) = ()
596− NotAllNull (column ::: def :=> 'Null ty ': columns) = NotAllNull columns
325+ NotAllNull (_ ::: _ :=> 'Null _ ': columns) = NotAllNull columns
597
326
598-- | `NullifyType` is an idempotent that nullifies a `NullityType`.
327-- | `NullifyType` is an idempotent that nullifies a `NullityType`.
599type family NullifyType (ty :: NullityType) :: NullityType where
328type family NullifyType (ty :: NullityType) :: NullityType where
@@ -602,33 +331,37 @@ type family NullifyType (ty :: NullityType) :: NullityType where
602
331
603-- | `NullifyRow` is an idempotent that nullifies a `RowType`.
332-- | `NullifyRow` is an idempotent that nullifies a `RowType`.
604type family NullifyRow (columns :: RowType) :: RowType where
333type family NullifyRow (columns :: RowType) :: RowType where
605− NullifyRow '[] = '[]
334+ NullifyRow (column ::: ty ': column1 ::: ty1 ': column2 ::: ty2 ': column3 ::: ty3 ': column4 ::: ty4 ': column5 ::: ty5 ': columns) =
335+ column ::: NullifyType ty ': column1 ::: NullifyType ty1 ': column2 ::: NullifyType ty2 ': column3 ::: NullifyType ty3 ': column4 ::: NullifyType ty4 ': column5 ::: NullifyType ty5 ': NullifyRow columns
336+ NullifyRow (column ::: ty ': column1 ::: ty1 ': column2 ::: ty2 ': column3 ::: ty3 ': column4 ::: ty4 ': columns) =
337+ column ::: NullifyType ty ': column1 ::: NullifyType ty1 ': column2 ::: NullifyType ty2 ': column3 ::: NullifyType ty3 ': column4 ::: NullifyType ty4 ': NullifyRow columns
338+ NullifyRow (column ::: ty ': column1 ::: ty1 ': column2 ::: ty2 ': column3 ::: ty3 ': columns) =
339+ column ::: NullifyType ty ': column1 ::: NullifyType ty1 ': column2 ::: NullifyType ty2 ': column3 ::: NullifyType ty3 ': NullifyRow columns
340+ NullifyRow (column ::: ty ': column1 ::: ty1 ': column2 ::: ty2 ': columns) =
341+ column ::: NullifyType ty ': column1 ::: NullifyType ty1 ': column2 ::: NullifyType ty2 ': NullifyRow columns
342+ NullifyRow (column ::: ty ': column1 ::: ty1 ': columns) =
343+ column ::: NullifyType ty ': column1 ::: NullifyType ty1 ': NullifyRow columns
606 NullifyRow (column ::: ty ': columns) =
344 NullifyRow (column ::: ty ': columns) =
607 column ::: NullifyType ty ': NullifyRow columns
345 column ::: NullifyType ty ': NullifyRow columns
346+ NullifyRow '[] = '[]
608
347
609-- | `NullifyFrom` is an idempotent that nullifies a `FromType`
348-- | `NullifyFrom` is an idempotent that nullifies a `FromType`
610-- used to nullify the left or right hand side of an outer join
349-- used to nullify the left or right hand side of an outer join
611-- in a `Squeal.PostgreSQL.Query.FromClause`.
350-- in a `Squeal.PostgreSQL.Query.FromClause`.
612type family NullifyFrom (tables :: FromType) :: FromType where
351type family NullifyFrom (tables :: FromType) :: FromType where
613− NullifyFrom '[] = '[]
352+ NullifyFrom (table ::: columns ': table1 ::: columns1 ': table2 ::: columns2 ': table3 ::: columns3 ': table4 ::: columns4 ': table5 ::: columns5 ': tables) =
353+ table ::: NullifyRow columns ': table1 ::: NullifyRow columns1 ': table2 ::: NullifyRow columns2 ': table3 ::: NullifyRow columns3 ': table4 ::: NullifyRow columns5 ': table5 ::: NullifyRow columns4 ': NullifyFrom tables
354+ NullifyFrom (table ::: columns ': table1 ::: columns1 ': table2 ::: columns2 ': table3 ::: columns3 ': table4 ::: columns4 ': tables) =
355+ table ::: NullifyRow columns ': table1 ::: NullifyRow columns1 ': table2 ::: NullifyRow columns2 ': table3 ::: NullifyRow columns3 ': table4 ::: NullifyRow columns4 ': NullifyFrom tables
356+ NullifyFrom (table ::: columns ': table1 ::: columns1 ': table2 ::: columns2 ': table3 ::: columns3 ': tables) =
357+ table ::: NullifyRow columns ': table1 ::: NullifyRow columns1 ': table2 ::: NullifyRow columns2 ': table3 ::: NullifyRow columns3 ': NullifyFrom tables
358+ NullifyFrom (table ::: columns ': table1 ::: columns1 ': table2 ::: columns2 ': tables) =
359+ table ::: NullifyRow columns ': table1 ::: NullifyRow columns1 ': table2 ::: NullifyRow columns2 ': NullifyFrom tables
360+ NullifyFrom (table ::: columns ': table1 ::: columns1 ': tables) =
361+ table ::: NullifyRow columns ': table1 ::: NullifyRow columns1 ': NullifyFrom tables
614 NullifyFrom (table ::: columns ': tables) =
362 NullifyFrom (table ::: columns ': tables) =
615 table ::: NullifyRow columns ': NullifyFrom tables
363 table ::: NullifyRow columns ': NullifyFrom tables
616−
364+ NullifyFrom '[] = '[]
617−-- | `Join` is simply promoted `++` and is used in @JOIN@s in
618−-- `Squeal.PostgreSQL.Query.FromClause`s.
619−type family Join xs ys where
620− Join '[] ys = ys
621− Join (x ': xs) ys = x ': Join xs ys
622−
623−-- | `disjoin` is a utility function for splitting an `NP` list into pieces.
624−disjoin
625− :: forall xs ys expr. SListI xs
626− => NP expr (Join xs ys)
627− -> (NP expr xs, NP expr ys)
628−disjoin = case sList @xs of
629− SNil -> \ys -> (Nil, ys)
630− SCons -> \(x :* xsys) ->
631− case disjoin xsys of (xs,ys) -> (x :* xs, ys)
632
365
633-- | @Create alias x xs@ adds @alias ::: x@ to the end of @xs@ and is used in
366-- | @Create alias x xs@ adds @alias ::: x@ to the end of @xs@ and is used in
634-- `Squeal.PostgreSQL.Definition.createTable` statements and in @ALTER TABLE@
367-- `Squeal.PostgreSQL.Definition.createTable` statements and in @ALTER TABLE@
@@ -638,30 +371,101 @@ type family Create alias x xs where
638 Create alias x (alias ::: y ': xs) = TypeError
371 Create alias x (alias ::: y ': xs) = TypeError
639 ('Text "Create: alias "
372 ('Text "Create: alias "
640 ':<>: 'ShowType alias
373 ':<>: 'ShowType alias
641− ':<>: 'Text "already in use")
374+ ':<>: 'Text "already exists")
642 Create alias y (x ': xs) = x ': Create alias y xs
375 Create alias y (x ': xs) = x ': Create alias y xs
643
376
377+type family CreateIfNotExists alias x xs where
378+ CreateIfNotExists alias x '[] = '[alias ::: x]
379+ CreateIfNotExists alias x (alias ::: y ': xs) = alias ::: y ': xs
380+ CreateIfNotExists alias y (x ': xs) = x ': CreateIfNotExists alias y xs
381+
382+type family CreateOrReplace alias x xs where
383+ CreateOrReplace alias x '[] = '[alias ::: x]
384+ CreateOrReplace alias x (alias ::: x ': xs) = alias ::: x ': xs
385+ CreateOrReplace alias x (alias ::: y ': xs) = TypeError
386+ ('Text "CreateOrReplace: expected type "
387+ ':<>: 'ShowType x
388+ ':<>: 'Text " but alias "
389+ ':<>: 'ShowType alias
390+ ':<>: 'Text " has type "
391+ ':<>: 'ShowType y)
392+ CreateOrReplace alias y (x ': xs) = x ': CreateOrReplace alias y xs
393+
644-- | @Drop alias xs@ removes the type associated with @alias@ in @xs@
394-- | @Drop alias xs@ removes the type associated with @alias@ in @xs@
645-- and is used in `Squeal.PostgreSQL.Definition.dropTable` statements
395-- and is used in `Squeal.PostgreSQL.Definition.dropTable` statements
646-- and in @ALTER TABLE@ `Squeal.PostgreSQL.Definition.dropColumn` statements.
396-- and in @ALTER TABLE@ `Squeal.PostgreSQL.Definition.dropColumn` statements.
647type family Drop alias xs where
397type family Drop alias xs where
398+ Drop alias '[] = TypeError
399+ ('Text "Drop: alias "
400+ ':<>: 'ShowType alias
401+ ':<>: 'Text " does not exist" )
648− Drop alias ((alias ::: x) ': xs) = xs
402+ Drop alias (alias ::: x ': xs) = xs
649 Drop alias (x ': xs) = x ': Drop alias xs
403 Drop alias (x ': xs) = x ': Drop alias xs
650
404
405+type family DropSchemum alias sch xs where
406+ DropSchemum alias sch '[] = TypeError
407+ ('Text "DropSchemum: alias "
408+ ':<>: 'ShowType alias
409+ ':<>: 'Text " does not exist" )
410+ DropSchemum alias sch (alias ::: sch x ': xs) = xs
411+ DropSchemum alias sch0 (alias ::: sch1 x ': xs) = TypeError
412+ ('Text "DropSchemum: expected schemum "
413+ ':<>: 'ShowType sch0
414+ ':<>: 'Text " but alias "
415+ ':<>: 'ShowType alias
416+ ':<>: 'Text " has schemum "
417+ ':<>: 'ShowType sch1)
418+ DropSchemum alias sch (x ': xs) = x ': DropSchemum alias sch xs
419+
420+type family DropIfExists alias xs where
421+ DropIfExists alias '[] = '[]
422+ DropIfExists alias (alias ::: x ': xs) = xs
423+ DropIfExists alias (x ': xs) = x ': DropIfExists alias xs
424+
425+type family DropSchemumIfExists alias sch xs where
426+ DropSchemumIfExists alias sch '[] = '[]
427+ DropSchemumIfExists alias sch (alias ::: sch x ': xs) = xs
428+ DropSchemumIfExists alias sch0 (alias ::: sch1 x ': xs) = TypeError
429+ ('Text "DropSchemumIfExists: expected schemum "
430+ ':<>: 'ShowType sch1
431+ ':<>: 'Text " but alias "
432+ ':<>: 'ShowType alias
433+ ':<>: 'Text " has schemum "
434+ ':<>: 'ShowType sch0)
435+ DropSchemumIfExists alias sch (x ': xs) = x ': DropSchemumIfExists alias sch xs
436+
651-- | @Alter alias x xs@ replaces the type associated with an @alias@ in @xs@
437-- | @Alter alias x xs@ replaces the type associated with an @alias@ in @xs@
652-- with the type @x@ and is used in `Squeal.PostgreSQL.Definition.alterTable`
438-- with the type @x@ and is used in `Squeal.PostgreSQL.Definition.alterTable`
653-- and `Squeal.PostgreSQL.Definition.alterColumn`.
439-- and `Squeal.PostgreSQL.Definition.alterColumn`.
654type family Alter alias x xs where
440type family Alter alias x xs where
441+ Alter alias x '[] = TypeError
442+ ('Text "Alter: alias "
443+ ':<>: 'ShowType alias
444+ ':<>: 'Text " does not exist" )
655 Alter alias x1 (alias ::: x0 ': xs) = alias ::: x1 ': xs
445 Alter alias x1 (alias ::: x0 ': xs) = alias ::: x1 ': xs
656 Alter alias x1 (x0 ': xs) = x0 ': Alter alias x1 xs
446 Alter alias x1 (x0 ': xs) = x0 ': Alter alias x1 xs
657
447
448+type family AlterIfExists alias x xs where
449+ AlterIfExists alias x '[] = '[]
450+ AlterIfExists alias x1 (alias ::: x0 ': xs) = alias ::: x1 ': xs
451+ AlterIfExists alias x1 (x0 ': xs) = x0 ': AlterIfExists alias x1 xs
452+
658-- | @Rename alias0 alias1 xs@ replaces the alias @alias0@ by @alias1@ in @xs@
453-- | @Rename alias0 alias1 xs@ replaces the alias @alias0@ by @alias1@ in @xs@
659-- and is used in `Squeal.PostgreSQL.Definition.alterTableRename` and
454-- and is used in `Squeal.PostgreSQL.Definition.alterTableRename` and
660-- `Squeal.PostgreSQL.Definition.renameColumn`.
455-- `Squeal.PostgreSQL.Definition.renameColumn`.
661type family Rename alias0 alias1 xs where
456type family Rename alias0 alias1 xs where
457+ Rename alias0 alias1 '[] = TypeError
458+ ('Text "Rename: alias "
459+ ':<>: 'ShowType alias0
460+ ':<>: 'Text " does not exist" )
662 Rename alias0 alias1 ((alias0 ::: x0) ': xs) = (alias1 ::: x0) ': xs
461 Rename alias0 alias1 ((alias0 ::: x0) ': xs) = (alias1 ::: x0) ': xs
663 Rename alias0 alias1 (x ': xs) = x ': Rename alias0 alias1 xs
462 Rename alias0 alias1 (x ': xs) = x ': Rename alias0 alias1 xs
664
463
464+type family RenameIfExists alias0 alias1 xs where
465+ RenameIfExists alias x '[] = '[]
466+ RenameIfExists alias0 alias1 ((alias0 ::: x0) ': xs) = (alias1 ::: x0) ': xs
467+ RenameIfExists alias0 alias1 (x ': xs) = x ': RenameIfExists alias0 alias1 xs
468+
665-- | Check if a `TableConstraint` involves a column
469-- | Check if a `TableConstraint` involves a column
666type family ConstraintInvolves column constraint where
470type family ConstraintInvolves column constraint where
667 ConstraintInvolves column ('Check columns) = column `Elem` columns
471 ConstraintInvolves column ('Check columns) = column `Elem` columns
@@ -678,22 +482,35 @@ type family DropIfConstraintsInvolve column constraints where
678 (DropIfConstraintsInvolve column constraints)
482 (DropIfConstraintsInvolve column constraints)
679 (alias ::: constraint ': DropIfConstraintsInvolve column constraints)
483 (alias ::: constraint ': DropIfConstraintsInvolve column constraints)
680
484
681−{- | Calculate the `Length` of a type level list
682−
683−>>> :kind! Length '[Char,String,Bool,Double]
684−Length '[Char,String,Bool,Double] :: Nat
685−= 4
686−-}
687−type family Length (xs :: [k]) :: Nat where
688− Length (x : xs) = 1 + Length xs
689− Length '[] = 0
690−
691-- | A `SchemumType` is a user-defined type, either a `Table`,
485-- | A `SchemumType` is a user-defined type, either a `Table`,
692-- `View` or `Typedef`.
486-- `View` or `Typedef`.
693data SchemumType
487data SchemumType
694 = Table TableType
488 = Table TableType
695 | View RowType
489 | View RowType
696 | Typedef PGType
490 | Typedef PGType
491+ | Index IndexType
492+ | Function FunctionType
493+ | Operator OperatorType
494+ | UnsafeSchemum Symbol
495+
496+type FunctionType = ([NullityType], ReturnsType)
497+
498+data IndexType
499+ = Btree
500+ | Hash
501+ | Gist
502+ | Spgist
503+ | Gin
504+ | Brin
505+
506+data ReturnsType
507+ = Returns NullityType
508+ | ReturnsTable RowType
509+
510+data OperatorType
511+ = BinaryOp NullityType NullityType NullityType
512+ | LeftOp NullityType NullityType
513+ | RightOp NullityType NullityType
697
514
698{- | The schema of a database consists of a list of aliased,
515{- | The schema of a database consists of a list of aliased,
699user-defined `SchemumType`s.
516user-defined `SchemumType`s.
@@ -736,9 +553,7 @@ There are several reasons why one might want to use schemas:
736-}
553-}
737type SchemasType = [(Symbol,SchemaType)]
554type SchemasType = [(Symbol,SchemaType)]
738
555
739−{-|
556+-- | A type family to use for a single schema database.
740−
741−-}
742type family Public (schema :: SchemaType) :: SchemasType
557type family Public (schema :: SchemaType) :: SchemasType
743 where Public schema = '["public" ::: schema]
558 where Public schema = '["public" ::: schema]
744
559
@@ -767,26 +582,15 @@ type PGJsonKey = '[ 'PGint2, 'PGint4, 'PGtext ]
767-- | Is a type a valid JSON type?
582-- | Is a type a valid JSON type?
768type PGJsonType = '[ 'PGjson, 'PGjsonb ]
583type PGJsonType = '[ 'PGjson, 'PGjsonb ]
769
584
770−-- | An `AlignedList` is a type-aligned list or free category.
585+-- | Utility class for `AllUnique` to provide nicer error messages.
771−data AlignedList p x0 x1 where
586+class IsNotElem x isElem where
772− Done :: AlignedList p x x
587+instance IsNotElem x 'False where
773− (:>>) :: p x0 x1 -> AlignedList p x1 x2 -> AlignedList p x0 x2
588+instance (TypeError ( 'Text "Cannot assign to "
774−infixr 7 :>>
589+ ':<>: 'ShowType alias
775−instance Category (AlignedList p) where
590+ ':<>: 'Text " more than once"))
776− id = Done
591+ => IsNotElem '(alias, a) 'True where
777− (.) list = \case
592+
778− Done -> list
593+-- | No elem of @xs@ appears more than once, in the context of assignment.
779− step :>> steps -> step :>> (steps >>> list)
594+class AllUnique (xs :: [(Symbol, a)]) where
780−instance (forall t0 t1. RenderSQL (p t0 t1))
595+instance AllUnique '[] where
781− => RenderSQL (AlignedList p x0 x1) where
596+instance (IsNotElem x (Elem x xs), AllUnique xs) => AllUnique (x ': xs) where
782− renderSQL = \case
783− Done -> ""
784− step :>> Done -> renderSQL step
785− step :>> steps -> renderSQL step <> ", " <> renderSQL steps
786−
787−-- | A `single` step.
788−single :: p x0 x1 -> AlignedList p x0 x1
789−single step = step :>> Done
790−
791−(*:) :: f x -> f y -> NP f '[x,y]
792−x *: y = x :* y :* Nil
squeal-postgresql/src/Squeal/PostgreSQL/Transaction.hs+78−48
@@ -1,7 +1,7 @@
1{-|
1{-|
2Module: Squeal.PostgreSQL.Transaction
2Module: Squeal.PostgreSQL.Transaction
3Description: Squeal transaction control language
3Description: Squeal transaction control language
4−Copyright: (c) Eitan Chatav, 2017
4+Copyright: (c) Eitan Chatav, 2019
5Maintainer: eitan@morphism.tech
5Maintainer: eitan@morphism.tech
6Stability: experimental
6Stability: experimental
7
7
@@ -20,11 +20,12 @@ module Squeal.PostgreSQL.Transaction
20 ( -- * Transaction
20 ( -- * Transaction
21 transactionally
21 transactionally
22 , transactionally_
22 , transactionally_
23+ , transactionallyRetry
24+ , ephemerally
25+ , ephemerally_
23 , begin
26 , begin
24 , commit
27 , commit
25 , rollback
28 , rollback
26− , transactionallySchema
27− , transactionallySchema_
28 -- * Transaction Mode
29 -- * Transaction Mode
29 , TransactionMode (..)
30 , TransactionMode (..)
30 , defaultMode
31 , defaultMode
@@ -34,70 +35,99 @@ module Squeal.PostgreSQL.Transaction
34 , DeferrableMode (..)
35 , DeferrableMode (..)
35 ) where
36 ) where
36
37
37−import Control.Exception.Lifted
38+import UnliftIO
38−import Control.Monad.Base
39−import Control.Monad.Trans.Control
40−import Generics.SOP
41−
42−import qualified Database.PostgreSQL.LibPQ as LibPQ
43
39
44import Squeal.PostgreSQL.Manipulation
40import Squeal.PostgreSQL.Manipulation
45import Squeal.PostgreSQL.Render
41import Squeal.PostgreSQL.Render
46import Squeal.PostgreSQL.PQ
42import Squeal.PostgreSQL.PQ
47−import Squeal.PostgreSQL.Schema
48
43
49−-- | Run a schema invariant computation `transactionally`.
44+{- | Run a computation `transactionally`;
45+first `begin`,
46+then run the computation,
47+`onException` `rollback` and rethrow the exception,
48+otherwise `commit` and `return` the result.
49+-}
50transactionally
50transactionally
51− :: (MonadBaseControl IO tx, MonadPQ schemas tx)
51+ :: (MonadUnliftIO tx, MonadPQ schemas tx)
52 => TransactionMode
52 => TransactionMode
53 -> tx x -- ^ run inside a transaction
53 -> tx x -- ^ run inside a transaction
54 -> tx x
54 -> tx x
55transactionally mode tx = mask $ \restore -> do
55transactionally mode tx = mask $ \restore -> do
56− _ <- begin mode
56+ manipulate_ $ begin mode
57− result <- restore tx `onException` rollback
57+ result <- restore tx `onException` (manipulate_ rollback)
58− _ <- commit
58+ manipulate_ commit
59 return result
59 return result
60
60
61−-- | Run a schema invariant computation `transactionally_` in `defaultMode`.
61+-- | Run a computation `transactionally_`, in `defaultMode`.
62transactionally_
62transactionally_
63− :: (MonadBaseControl IO tx, MonadPQ schemas tx)
63+ :: (MonadUnliftIO tx, MonadPQ schemas tx)
64 => tx x -- ^ run inside a transaction
64 => tx x -- ^ run inside a transaction
65 -> tx x
65 -> tx x
66transactionally_ = transactionally defaultMode
66transactionally_ = transactionally defaultMode
67
67
68−-- | @BEGIN@ a transaction.
68+{- |
69+`transactionallyRetry` a computation;
70+
71+* first `begin`,
72+* then `try` the computation,
73+ - if it raises a serialization failure then `rollback` and restart the transaction,
74+ - if it raises any other exception then `rollback` and rethrow the exception,
75+ - otherwise `commit` and `return` the result.
76+-}
77+transactionallyRetry
78+ :: (MonadUnliftIO tx, MonadPQ schemas tx)
69−begin :: MonadPQ schemas tx => TransactionMode -> tx (K Result ('[] :: RowType))
79+ => TransactionMode
70−begin mode = manipulate . UnsafeManipulation $
80+ -> tx x -- ^ run inside a transaction
71− "BEGIN" <+> renderSQL mode <> ";"
81+ -> tx x
82+transactionallyRetry mode tx = mask $ \restore ->
83+ loop . try $ do
84+ x <- restore tx
85+ manipulate_ commit
86+ return x
87+ where
88+ loop attempt = do
89+ manipulate_ $ begin mode
90+ attempt >>= \case
91+ Left (PQException (PQState _ (Just "40001") _)) -> do
92+ manipulate_ rollback
93+ loop attempt
94+ Left err -> do
95+ manipulate_ rollback
96+ throwIO err
97+ Right x -> return x
98+
99+{- | Run a computation `ephemerally`;
100+Like `transactionally` but always `rollback`, useful in testing.
101+-}
102+ephemerally
103+ :: (MonadUnliftIO tx, MonadPQ schemas tx)
104+ => TransactionMode
105+ -> tx x -- ^ run inside an ephemeral transaction
106+ -> tx x
107+ephemerally mode tx = mask $ \restore -> do
108+ manipulate_ $ begin mode
109+ result <- restore tx `onException` (manipulate_ rollback)
110+ manipulate_ rollback
111+ return result
72
112
73−-- | @COMMIT@ a schema invariant transaction.
113+{- | Run a computation `ephemerally` in `defaultMode`. -}
114+ephemerally_
74−commit :: MonadPQ schemas tx => tx (K Result ('[] :: RowType))
115+ :: (MonadUnliftIO tx, MonadPQ schemas tx)
116+ => tx x -- ^ run inside an ephemeral transaction
117+ -> tx x
118+ephemerally_ = ephemerally defaultMode
119+
120+-- | @BEGIN@ a transaction.
121+begin :: TransactionMode -> Manipulation_ schemas () ()
75−commit = manipulate $ UnsafeManipulation "COMMIT;"
122+begin mode = UnsafeManipulation $ "BEGIN" <+> renderSQL mode
76
123
77−-- | @ROLLBACK@ a schema invariant transaction.
124+-- | @COMMIT@ a transaction.
78−rollback :: MonadPQ schemas tx => tx (K Result ('[] :: RowType))
125+commit :: Manipulation_ schemas () ()
79−rollback = manipulate $ UnsafeManipulation "ROLLBACK;"
126+commit = UnsafeManipulation "COMMIT"
80
127
81−-- | Run a schema changing computation `transactionallySchema`.
128+-- | @ROLLBACK@ a transaction.
82−transactionallySchema
129+rollback :: Manipulation_ schemas () ()
83− :: MonadBaseControl IO io
130+rollback = UnsafeManipulation "ROLLBACK"
84− => TransactionMode
85− -> PQ schemas0 schemas1 io x
86− -> PQ schemas0 schemas1 io x
87−transactionallySchema mode u = PQ $ \ conn -> mask $ \ restore -> do
88− _ <- liftBase . LibPQ.exec (unK conn) $
89− "BEGIN" <+> renderSQL mode <> ";"
90− x <- restore (unPQ u conn)
91− `onException` (liftBase (LibPQ.exec (unK conn) "ROLLBACK"))
92− _ <- liftBase $ LibPQ.exec (unK conn) "COMMIT"
93− return x
94−
95−-- | Run a schema changing computation `transactionallySchema_` in `defaultMode`.
96−transactionallySchema_
97− :: MonadBaseControl IO io
98− => PQ schemas0 schemas1 io x
99− -> PQ schemas0 schemas1 io x
100−transactionallySchema_ = transactionallySchema defaultMode
101
131
102-- | The available transaction characteristics are the transaction `IsolationLevel`,
132-- | The available transaction characteristics are the transaction `IsolationLevel`,
103-- the transaction `AccessMode` (`ReadWrite` or `ReadOnly`), and the `DeferrableMode`.
133-- the transaction `AccessMode` (`ReadWrite` or `ReadOnly`), and the `DeferrableMode`.
@@ -110,7 +140,7 @@ data TransactionMode = TransactionMode
110-- | `TransactionMode` with a `Serializable` `IsolationLevel`,
140-- | `TransactionMode` with a `Serializable` `IsolationLevel`,
111-- `ReadWrite` `AccessMode` and `NotDeferrable` `DeferrableMode`.
141-- `ReadWrite` `AccessMode` and `NotDeferrable` `DeferrableMode`.
112defaultMode :: TransactionMode
142defaultMode :: TransactionMode
113−defaultMode = TransactionMode Serializable ReadWrite NotDeferrable
143+defaultMode = TransactionMode ReadCommitted ReadWrite NotDeferrable
114
144
115-- | `TransactionMode` with a `Serializable` `IsolationLevel`,
145-- | `TransactionMode` with a `Serializable` `IsolationLevel`,
116-- `ReadOnly` `AccessMode` and `Deferrable` `DeferrableMode`.
146-- `ReadOnly` `AccessMode` and `Deferrable` `DeferrableMode`.
squeal-postgresql/test/Doc.hsnew file+6
@@ -0,0 +1,6 @@
1+module Main (main) where
2+
3+import Test.DocTest
4+
5+main :: IO ()
6+main = doctest [ "-isrc", "src" ]
squeal-postgresql/test/DocTest.hsdeleted−18
@@ -1,18 +0,0 @@
1−module Main (main) where
2−
3−import Test.DocTest
4−
5−main :: IO ()
6−main = doctest
7− [ "-isrc"
8− , "src/Squeal/PostgreSQL.hs"
9− , "src/Squeal/PostgreSQL/Binary.hs"
10− , "src/Squeal/PostgreSQL/Definition.hs"
11− , "src/Squeal/PostgreSQL/Manipulation.hs"
12− , "src/Squeal/PostgreSQL/Query.hs"
13− , "src/Squeal/PostgreSQL/Expression.hs"
14− , "src/Squeal/PostgreSQL/PQ.hs"
15− , "src/Squeal/PostgreSQL/Migration.hs"
16− , "src/Squeal/PostgreSQL/Transaction.hs"
17− , "src/Squeal/PostgreSQL/Pool.hs"
18− ]
squeal-postgresql/test/Property.hsnew file+166
@@ -0,0 +1,166 @@
1+{-# LANGUAGE
2+ DataKinds
3+ , GADTs
4+ , LambdaCase
5+ , OverloadedLabels
6+ , OverloadedStrings
7+ , TypeApplications
8+ , TypeOperators
9+#-}
10+
11+module Main (main) where
12+
13+import Control.Monad.Trans
14+import Data.ByteString (ByteString)
15+import Data.ByteString.Char8 (unpack)
16+import Data.Scientific (fromFloatDigits)
17+import Data.Fixed (Fixed(MkFixed), Micro, Pico)
18+import Data.String (IsString(fromString))
19+import Data.Time
20+import Squeal.PostgreSQL hiding (check, defaultMain, Group)
21+import Hedgehog hiding (Range)
22+import qualified Hedgehog.Gen as Gen
23+import qualified Hedgehog.Main as Main
24+import qualified Hedgehog.Range as Range
25+
26+main :: IO ()
27+main = Main.defaultMain [checkSequential roundtrips]
28+
29+roundtrips :: Group
30+roundtrips = Group "roundtrips"
31+ [ roundtrip int2 genInt16
32+ , roundtrip int4 genInt32
33+ , roundtrip int8 genInt64
34+ , roundtrip bool Gen.bool
35+ , roundtrip numeric genScientific
36+ , roundtrip float4 genFloat
37+ , roundtrip float8 genDouble
38+ , roundtripOn normalizeTimeOfDay time genTimeOfDay
39+ -- , roundtrip timetz genTimeWithZone normalizeTimeWithZone
40+ , roundtripOn normalizeLocalTime timestamp genLocalTime
41+ , roundtrip timestamptz genUTCTime
42+ , roundtrip date genDay
43+ , roundtrip interval genDiffTime
44+ , roundtripOn normalizeIntRange int4range (genRange genInt32)
45+ , roundtripOn normalizeIntRange int8range (genRange genInt64)
46+ , roundtrip numrange (genRange genScientific)
47+ , roundtripOn (fmap normalizeLocalTime) tsrange (genRange genLocalTime)
48+ , roundtrip tstzrange (genRange genUTCTime)
49+ , roundtripOn normalizeIntRange daterange (genRange genDay)
50+ ]
51+ where
52+ genInt16 = Gen.int16 Range.exponentialBounded
53+ genInt32 = Gen.int32 Range.exponentialBounded
54+ genInt64 = Gen.int64 Range.exponentialBounded
55+ genScientific = fromFloatDigits <$> genFloat
56+ genPosFloat = Gen.float
57+ (Range.exponentialFloatFrom 1 minPosFloat maxPosFloat)
58+ genFloat = Gen.prune $ Gen.choice
59+ [ genPosFloat
60+ , negate <$> genPosFloat
61+ , Gen.element [0,1/0] ]
62+ genPosDouble = Gen.double
63+ (Range.exponentialFloatFrom 1 minPosFloat maxPosFloat)
64+ genDouble = Gen.prune $ Gen.choice
65+ [ genPosDouble
66+ , negate <$> genPosDouble
67+ , Gen.element [0,1/0] ]
68+ genRange gen = do
69+ lb <- gen
70+ ub <- Gen.filter (lb <) gen
71+ Gen.element
72+ [ Empty, singleton lb, whole
73+ , lb <=..<= ub , lb <=..< ub, lb <..<= ub, lb <..< ub
74+ , atLeast lb, moreThan lb, atMost ub, lessThan ub ]
75+ genDay = do
76+ y <- toInteger <$> Gen.int (Range.constant 2000 2019)
77+ m <- Gen.int (Range.constant 1 12)
78+ d <- Gen.int (Range.constant 1 28)
79+ return $ fromGregorian y m d
80+ genDiffTime = secondsToDiffTime . toInteger <$>
81+ Gen.int (Range.constant 0 86401)
82+ genUTCTime = UTCTime <$> genDay <*> genDiffTime
83+ genTimeOfDay = do
84+ h <- Gen.int (Range.constant 0 23)
85+ m <- Gen.int (Range.constant 0 59)
86+ s <- MkFixed . toInteger <$> Gen.int (Range.constant 0 59)
87+ return $ TimeOfDay h m s
88+ genLocalTime = LocalTime <$> genDay <*> genTimeOfDay
89+ -- genTimeZone = Gen.element $ map (read @TimeZone)
90+ -- [ "UTC", "UT", "GMT", "EST", "EDT", "CST"
91+ -- , "CDT", "MST", "MDT", "PST", "PDT" ]
92+ -- genTimeWithZone = (,) <$> genTimeOfDay <*> genTimeZone
93+
94+roundtrip
95+ :: (OidOf ty, ToParam x ty, FromValue ty x, Show x, Eq x)
96+ => TypeExpression schemas ('NotNull ty)
97+ -> Gen x
98+ -> (PropertyName, Property)
99+roundtrip = roundtripOn id
100+
101+roundtripOn
102+ :: (OidOf ty, ToParam x ty, FromValue ty x, Show x, Eq x)
103+ => (x -> x)
104+ -> TypeExpression schemas ('NotNull ty)
105+ -> Gen x
106+ -> (PropertyName, Property)
107+roundtripOn norm ty gen = propertyWithName $ do
108+ x <- forAll gen
109+ Just (Only y) <- lift . withConnection connectionString $
110+ firstRow =<< runQueryParams
111+ (values_ (parameter @1 ty `as` #fromOnly)) (Only x)
112+ norm x === y
113+ where
114+ propertyWithName prop =
115+ (fromString (unpack (renderSQL ty)), property prop)
116+
117+maxPosFloat :: RealFloat a => a
118+maxPosFloat = x
119+ where
120+ n = floatDigits x
121+ b = floatRadix x
122+ (_, u) = floatRange x
123+ x = encodeFloat (b^n - 1) (u - n)
124+
125+minPosFloat :: RealFloat a => a
126+minPosFloat = x
127+ where
128+ n = floatDigits x
129+ b = floatRadix x
130+ (l, _) = floatRange x
131+ x = encodeFloat (b^n - 1) (l - n - 1)
132+
133+connectionString :: ByteString
134+connectionString = "host=localhost port=5432 dbname=exampledb"
135+
136+normalizeIntRange :: (Enum int, Ord int) => Range int -> Range int
137+normalizeIntRange = \case
138+ Empty -> Empty
139+ NonEmpty l u ->
140+ let
141+ l' = normalizeL l
142+ u' = normalizeU u
143+ in if emptyNormalized l' u' then Empty else NonEmpty l' u'
144+ where
145+ normalizeL = \case
146+ Open l -> Closed (succ l)
147+ normalized -> normalized
148+ normalizeU = \case
149+ Closed u -> Open (succ u)
150+ normalized -> normalized
151+ emptyNormalized (Closed l) (Open u) = l >= u
152+ emptyNormalized _ _ = False
153+
154+normalizeTimeOfDay :: TimeOfDay -> TimeOfDay
155+normalizeTimeOfDay (TimeOfDay h m s) = TimeOfDay h m
156+ . fromRational @Pico
157+ . toRational @Micro
158+ . fromRational @Micro
159+ . toRational @Pico
160+ $ s
161+
162+normalizeLocalTime :: LocalTime -> LocalTime
163+normalizeLocalTime (LocalTime d t) = LocalTime d (normalizeTimeOfDay t)
164+
165+-- normalizeTimeWithZone :: (TimeOfDay, TimeZone) -> (TimeOfDay, TimeZone)
166+-- normalizeTimeWithZone (t, z) = (normalizeTimeOfDay t, z)
squeal-postgresql/test/Spec.hsnew file+136
@@ -0,0 +1,136 @@
1+{-# LANGUAGE
2+ DataKinds
3+ , DeriveAnyClass
4+ , DeriveGeneric
5+ , DerivingStrategies
6+ , DuplicateRecordFields
7+ , FlexibleContexts
8+ , OverloadedLabels
9+ , OverloadedLists
10+ , OverloadedStrings
11+ , TypeApplications
12+ , TypeFamilies
13+ , TypeInType
14+ , TypeOperators
15+#-}
16+
17+module Main (main) where
18+
19+import Control.Concurrent.Async (replicateConcurrently)
20+import Data.ByteString (ByteString)
21+import Data.Int (Int32)
22+import Data.Text (Text)
23+import Test.Hspec
24+
25+import qualified Generics.SOP as SOP
26+import qualified GHC.Generics as GHC
27+
28+import Squeal.PostgreSQL
29+
30+main :: IO ()
31+main = hspec spec
32+
33+type Schemas = Public
34+ '[ "users" ::: 'Table (
35+ '[ "pk_users" ::: 'PrimaryKey '["id"]
36+ , "unique_names" ::: 'Unique '["name"]
37+ ] :=>
38+ '[ "id" ::: 'Def :=> 'NotNull 'PGint4
39+ , "name" ::: 'NoDef :=> 'NotNull 'PGtext ] ) ]
40+
41+data User = User
42+ { userName :: Text
43+ } deriving stock (Eq, Show, GHC.Generic)
44+ deriving anyclass (SOP.Generic, SOP.HasDatatypeInfo)
45+
46+insertUser :: Manipulation_ Schemas User ()
47+insertUser = insertInto_ #users
48+ (Values_ (Default `as` #id :* Set (param @1) `as` #name))
49+
50+setup :: Definition (Public '[]) Schemas
51+setup =
52+ createTable #users
53+ ( serial `as` #id :*
54+ notNullable text `as` #name )
55+ ( primaryKey #id `as` #pk_users :*
56+ unique #name `as` #unique_names )
57+
58+teardown :: Definition Schemas (Public '[])
59+teardown = dropTable #users
60+
61+silence :: MonadPQ schemas pq => pq ()
62+silence = manipulate_ $
63+ UnsafeManipulation "SET client_min_messages TO WARNING;"
64+
65+setupDB :: IO ()
66+setupDB = withConnection connectionString $
67+ silence & pqThen (define setup)
68+
69+dropDB :: IO ()
70+dropDB = withConnection connectionString $
71+ silence & pqThen (define teardown)
72+
73+connectionString :: ByteString
74+connectionString = "host=localhost port=5432 dbname=exampledb"
75+
76+spec :: Spec
77+spec = before_ setupDB . after_ dropDB $ do
78+
79+ describe "Exceptions" $ do
80+
81+ let
82+ testUser = User "TestUser"
83+ newUser = manipulateParams_ insertUser
84+ insertUserTwice = newUser testUser >> newUser testUser
85+ err23505 = PQException $ PQState FatalError (Just "23505")
86+ (Just "ERROR: duplicate key value violates unique constraint \"unique_names\"\nDETAIL: Key (name)=(TestUser) already exists.\n")
87+
88+ it "should be thrown for constraint violation" $
89+ withConnection connectionString insertUserTwice
90+ `shouldThrow` (== err23505)
91+
92+ it "should be rethrown for constraint violation in a transaction" $
93+ withConnection connectionString (transactionally_ insertUserTwice)
94+ `shouldThrow` (== err23505)
95+
96+ describe "Pools" $
97+
98+ it "should manage concurrent transactions" $ do
99+ pool <- createConnectionPool
100+ "host=localhost port=5432 dbname=exampledb" 1 0.5 10
101+ let
102+ query :: Query_ (Public '[]) () (Only Char)
103+ query = values_ (literal 'a' `as` #fromOnly)
104+ session = usingConnectionPool pool . transactionally_ $ do
105+ result <- runQuery query
106+ Just (Only chr) <- firstRow result
107+ return chr
108+ chrs <- replicateConcurrently 10 session
109+ chrs `shouldSatisfy` all (== 'a')
110+
111+ describe "Ranges" $
112+
113+ it "should correctly decode ranges" $ do
114+
115+ rangesOut <- withConnection connectionString $ do
116+ let
117+ query :: Query_ (Public '[]) () (Only (Range Int32))
118+ query = values
119+ ( range int4range (atLeast 3) `as` #fromOnly )
120+ [ range int4range (3 <=..< 5) `as` #fromOnly
121+ , range int4range Empty `as` #fromOnly
122+ , range int4range whole `as` #fromOnly ]
123+ getRows =<< runQuery query
124+ (fromOnly <$> rangesOut :: [Range Int32]) `shouldBe`
125+ [ atLeast 3, 3 <=..< 5, Empty, whole ]
126+
127+ describe "Parameters" $ do
128+
129+ it "should run queries that don't reference all their parameters" $ do
130+
131+ out <- withConnection connectionString $ do
132+ let
133+ query :: Query_ (Public '[]) (Char,Int32) (Only Int32)
134+ query = values_ (param @2 `as` #fromOnly)
135+ firstRow =<< runQueryParams query ('a', 3 :: Int32)
136+ (fromOnly <$> out :: Maybe Int32) `shouldBe` Just 3
squeal-postgresql/test/Specs/ExceptionHandling.hsdeleted−126
@@ -1,126 +0,0 @@
1−{-# LANGUAGE DataKinds #-}
2−{-# LANGUAGE DeriveGeneric #-}
3−{-# LANGUAGE DuplicateRecordFields #-}
4−{-# LANGUAGE FlexibleContexts #-}
5−{-# LANGUAGE OverloadedLabels #-}
6−{-# LANGUAGE OverloadedLists #-}
7−{-# LANGUAGE OverloadedStrings #-}
8−{-# LANGUAGE TypeApplications #-}
9−{-# LANGUAGE TypeFamilies #-}
10−{-# LANGUAGE TypeInType #-}
11−{-# LANGUAGE TypeOperators #-}
12−module ExceptionHandling
13− ( specs
14− , User (..)
15− )
16−where
17−
18−import Control.Monad (void)
19−import Control.Monad.Base (MonadBase)
20−import qualified Data.ByteString.Char8 as Char8
21−import Data.Int (Int16)
22−import Data.Text (Text)
23−import Data.Vector (Vector)
24−import qualified Generics.SOP as SOP
25−import qualified GHC.Generics as GHC
26−import Squeal.PostgreSQL
27−import Squeal.PostgreSQL.Migration
28−import Test.Hspec
29−
30−type Schema =
31− '[ "users" ::: 'Table (
32− '[ "pk_users" ::: 'PrimaryKey '["id"]
33− , "unique_names" ::: 'Unique '["name"]
34− ] :=>
35− '[ "id" ::: 'Def :=> 'NotNull 'PGint4
36− , "name" ::: 'NoDef :=> 'NotNull 'PGtext
37− , "vec" ::: 'NoDef :=> 'NotNull ('PGvararray ('Null 'PGint2))
38− ])
39− , "emails" ::: 'Table (
40− '[ "pk_emails" ::: 'PrimaryKey '["id"]
41− , "fk_user_id" ::: 'ForeignKey '["user_id"] "users" '["id"]
42− ] :=>
43− '[ "id" ::: 'Def :=> 'NotNull 'PGint4
44− , "user_id" ::: 'NoDef :=> 'NotNull 'PGint4
45− , "email" ::: 'NoDef :=> 'Null 'PGtext
46− ])
47− ]
48−
49−type Schemas = Public Schema
50−
51−data User =
52− User { userName :: Text
53− , userEmail :: Maybe Text
54− , userVec :: VarArray (Vector (Maybe Int16)) }
55− deriving (Show, GHC.Generic)
56−instance SOP.Generic User
57−instance SOP.HasDatatypeInfo User
58−
59−insertUser :: Manipulation '[] Schemas '[ 'NotNull 'PGtext, 'NotNull ('PGvararray ('Null 'PGint2))]
60− '[ "fromOnly" ::: 'NotNull 'PGint4 ]
61−insertUser = insertInto #users
62− (Values_ (defaultAs #id :* param @1 `as` #name :* param @2 `as` #vec))
63− OnConflictDoRaise (Returning (#id `as` #fromOnly))
64−
65−setup :: Definition (Public '[]) Schemas
66−setup =
67− createTable #users
68− ( serial `as` #id :*
69− (text & notNullable) `as` #name :*
70− (vararray int2 & notNullable) `as` #vec )
71− ( primaryKey #id `as` #pk_users
72− :* unique #name `as` #unique_names )
73− >>>
74− createTable #emails
75− ( serial `as` #id :*
76− (int & notNullable) `as` #user_id :*
77− (text & nullable) `as` #email )
78− ( primaryKey #id `as` #pk_emails :*
79− foreignKey #user_id #users #id
80− OnDeleteCascade OnUpdateCascade `as` #fk_user_id )
81−
82−teardown :: Definition Schemas (Public '[])
83−teardown = dropTable #emails >>> dropTable #users
84−
85−migration :: Migration IO (Public '[]) Schemas
86−migration = Migration { name = "test"
87− , up = void $ define setup
88− , down = void $ define teardown }
89−
90−setupDB :: IO ()
91−setupDB = void . withConnection connectionString $
92− manipulate (UnsafeManipulation "SET client_min_messages TO WARNING;")
93− & pqThen (migrateUp (single migration))
94−
95−dropDB :: IO ()
96−dropDB = void . withConnection connectionString $
97− manipulate (UnsafeManipulation "SET client_min_messages TO WARNING;")
98− & pqThen (migrateDown (single migration))
99−
100−connectionString :: Char8.ByteString
101−connectionString = "host=localhost port=5432 dbname=exampledb"
102−
103−testUser :: User
104−testUser = User "TestUser" Nothing (VarArray [])
105−
106−newUser :: (MonadBase IO m, MonadPQ Schemas m) => User -> m ()
107−newUser u = void $ manipulateParams insertUser (userName u, userVec u)
108−
109−insertUserTwice :: (MonadBase IO m, MonadPQ Schemas m) => m ()
110−insertUserTwice = newUser testUser >> newUser testUser
111−
112−specs :: SpecWith ()
113−specs = before_ setupDB $ after_ dropDB $
114− describe "Exceptions" $ do
115−
116− let
117− dupKeyErr = PQException FatalError (Just "23505")
118− (Just "ERROR: duplicate key value violates unique constraint \"unique_names\"\nDETAIL: Key (name)=(TestUser) already exists.\n")
119−
120− it "should be thrown for unique constraint violation in a manipulation" $
121− withConnection connectionString insertUserTwice
122− `shouldThrow` (== dupKeyErr)
123−
124− it "should be rethrown for unique constraint violation in a manipulation by a transaction" $
125− withConnection connectionString (transactionally_ insertUserTwice)
126− `shouldThrow` (== dupKeyErr)
squeal-postgresql/test/Specs/Specs.hsdeleted−7
@@ -1,7 +0,0 @@
1−module Specs where
2−
3−import Test.Hspec
4−import qualified ExceptionHandling
5−
6−main :: IO ()
7−main = hspec ExceptionHandling.specs
stack.yaml+6−1
@@ -1,3 +1,8 @@
1−resolver: lts-13.8
1+resolver: nightly-2019-07-14
2packages:
2packages:
3- squeal-postgresql
3- squeal-postgresql
4+
5+extra-deps:
6+- unliftio-pool-0.2.1.0
7+- github: morphismtech/free-categories
8+ commit: c0e555fbefb5c21619e532264c4dfeac556d0630