7399003...master · typeable/postgresql-simple

git.iko.soy/typeable/postgresql-simple

on master help sign in

.github/workflows/haskell-ci.yml+106−47

since splitsnapshots

unifiedsplit

@@ -8,9 +8,9 @@

9# For more information, see https://github.com/haskell-CI/haskell-ci

10#

11−# version: 0.12

11+# version: 0.17.20231110

12#

13−# REGENDATA ("0.12",["github","cabal.project"])

13+# REGENDATA ("0.17.20231110",["github","cabal.project"])

14#

15name: Haskell-CI

16on:

@@ -23,12 +23,14 @@ on:

23jobs:

24 linux:

25 name: Haskell-CI - Linux - ${{ matrix.compiler }}

26− runs-on: ubuntu-18.04

26+ runs-on: ubuntu-20.04

27+ timeout-minutes:

28+ 60

27 container:

29 container:

28 image: buildpack-deps:bionic

30 image: buildpack-deps:bionic

29 services:

31 services:

30 postgres:

32 postgres:

31− image: postgres:10

33+ image: postgres:14

32 env:

34 env:

33 POSTGRES_PASSWORD: postgres

35 POSTGRES_PASSWORD: postgres

34 options: --health-cmd pg_isready --health-interval 10s --health-timeout 5s --health-retries 5

36 options: --health-cmd pg_isready --health-interval 10s --health-timeout 5s --health-retries 5

@@ -36,59 +38,105 @@ jobs:

36 strategy:

38 strategy:

37 matrix:

39 matrix:

38 include:

40 include:

39− - compiler: ghc-9.0.1

41+ - compiler: ghc-9.8.1

42+ compilerKind: ghc

43+ compilerVersion: 9.8.1

44+ setup-method: ghcup

40 allow-failure: false

45 allow-failure: false

41− - compiler: ghc-8.10.4

46+ - compiler: ghc-9.6.3

47+ compilerKind: ghc

48+ compilerVersion: 9.6.3

49+ setup-method: ghcup

42 allow-failure: false

50 allow-failure: false

43− - compiler: ghc-8.8.4

51+ - compiler: ghc-9.4.8

44− allow-failure: false

52+ compilerKind: ghc

45− - compiler: ghc-8.6.5

53+ compilerVersion: 9.4.8

54+ setup-method: ghcup

46 allow-failure: false

55 allow-failure: false

47− - compiler: ghc-8.4.4

56+ - compiler: ghc-9.2.8

57+ compilerKind: ghc

58+ compilerVersion: 9.2.8

59+ setup-method: ghcup

48 allow-failure: false

60 allow-failure: false

49− - compiler: ghc-8.2.2

61+ - compiler: ghc-9.0.2

62+ compilerKind: ghc

63+ compilerVersion: 9.0.2

64+ setup-method: ghcup

50 allow-failure: false

65 allow-failure: false

51− - compiler: ghc-8.0.2

66+ - compiler: ghc-8.10.7

67+ compilerKind: ghc

68+ compilerVersion: 8.10.7

69+ setup-method: ghcup

52 allow-failure: false

70 allow-failure: false

53− - compiler: ghc-7.10.3

71+ - compiler: ghc-8.8.4

54− allow-failure: false

72+ compilerKind: ghc

55− - compiler: ghc-7.8.4

73+ compilerVersion: 8.8.4

74+ setup-method: hvr-ppa

56 allow-failure: false

75 allow-failure: false

57− - compiler: ghc-7.6.3

76+ - compiler: ghc-8.6.5

77+ compilerKind: ghc

78+ compilerVersion: 8.6.5

79+ setup-method: hvr-ppa

58 allow-failure: false

80 allow-failure: false

59 fail-fast: false

81 fail-fast: false

60 steps:

82 steps:

61 - name: apt

83 - name: apt

62 run: |

84 run: |

63 apt-get update

85 apt-get update

64− apt-get install -y --no-install-recommends gnupg ca-certificates dirmngr curl git software-properties-common

86+ apt-get install -y --no-install-recommends gnupg ca-certificates dirmngr curl git software-properties-common libtinfo5

87+ if [ "${{ matrix.setup-method }}" = ghcup ]; then

88+ mkdir -p "$HOME/.ghcup/bin"

89+ curl -sL https://downloads.haskell.org/ghcup/0.1.20.0/x86_64-linux-ghcup-0.1.20.0 > "$HOME/.ghcup/bin/ghcup"

90+ chmod a+x "$HOME/.ghcup/bin/ghcup"

91+ "$HOME/.ghcup/bin/ghcup" install ghc "$HCVER" || (cat "$HOME"/.ghcup/logs/*.* && false)

92+ "$HOME/.ghcup/bin/ghcup" install cabal 3.10.2.0 || (cat "$HOME"/.ghcup/logs/*.* && false)

93+ else

65− apt-add-repository -y 'ppa:hvr/ghc'

94+ apt-add-repository -y 'ppa:hvr/ghc'

66− apt-get update

95+ apt-get update

67− apt-get install -y $CC cabal-install-3.4

96+ apt-get install -y "$HCNAME"

97+ mkdir -p "$HOME/.ghcup/bin"

98+ curl -sL https://downloads.haskell.org/ghcup/0.1.20.0/x86_64-linux-ghcup-0.1.20.0 > "$HOME/.ghcup/bin/ghcup"

99+ chmod a+x "$HOME/.ghcup/bin/ghcup"

100+ "$HOME/.ghcup/bin/ghcup" install cabal 3.10.2.0 || (cat "$HOME"/.ghcup/logs/*.* && false)

101+ fi

68 env:

102 env:

103+ HCKIND: ${{ matrix.compilerKind }}

69− CC: ${{ matrix.compiler }}

104+ HCNAME: ${{ matrix.compiler }}

105+ HCVER: ${{ matrix.compilerVersion }}

70 - name: Set PATH and environment variables

106 - name: Set PATH and environment variables

71 run: |

107 run: |

72 echo "$HOME/.cabal/bin" >> $GITHUB_PATH

108 echo "$HOME/.cabal/bin" >> $GITHUB_PATH

73− echo "LANG=C.UTF-8" >> $GITHUB_ENV

109+ echo "LANG=C.UTF-8" >> "$GITHUB_ENV"

74− echo "CABAL_DIR=$HOME/.cabal" >> $GITHUB_ENV

110+ echo "CABAL_DIR=$HOME/.cabal" >> "$GITHUB_ENV"

75− echo "CABAL_CONFIG=$HOME/.cabal/config" >> $GITHUB_ENV

111+ echo "CABAL_CONFIG=$HOME/.cabal/config" >> "$GITHUB_ENV"

76− HCDIR=$(echo "/opt/$CC" | sed 's/-/\//')

112+ HCDIR=/opt/$HCKIND/$HCVER

77− HCNAME=ghc

113+ if [ "${{ matrix.setup-method }}" = ghcup ]; then

78− HC=$HCDIR/bin/$HCNAME

114+ HC=$("$HOME/.ghcup/bin/ghcup" whereis ghc "$HCVER")

79− echo "HC=$HC" >> $GITHUB_ENV

115+ HCPKG=$(echo "$HC" | sed 's#ghc$#ghc-pkg#')

80− echo "HCPKG=$HCDIR/bin/$HCNAME-pkg" >> $GITHUB_ENV

116+ HADDOCK=$(echo "$HC" | sed 's#ghc$#haddock#')

81− echo "HADDOCK=$HCDIR/bin/haddock" >> $GITHUB_ENV

117+ echo "HC=$HC" >> "$GITHUB_ENV"

118+ echo "HCPKG=$HCPKG" >> "$GITHUB_ENV"

119+ echo "HADDOCK=$HADDOCK" >> "$GITHUB_ENV"

120+ echo "CABAL=$HOME/.ghcup/bin/cabal-3.10.2.0 -vnormal+nowrap" >> "$GITHUB_ENV"

121+ else

122+ HC=$HCDIR/bin/$HCKIND

123+ echo "HC=$HC" >> "$GITHUB_ENV"

124+ echo "HCPKG=$HCDIR/bin/$HCKIND-pkg" >> "$GITHUB_ENV"

125+ echo "HADDOCK=$HCDIR/bin/haddock" >> "$GITHUB_ENV"

82− echo "CABAL=/opt/cabal/3.4/bin/cabal -vnormal+nowrap" >> $GITHUB_ENV

126+ echo "CABAL=$HOME/.ghcup/bin/cabal-3.10.2.0 -vnormal+nowrap" >> "$GITHUB_ENV"

127+ fi

128+

83 HCNUMVER=$(${HC} --numeric-version|perl -ne '/^(\d+)\.(\d+)\.(\d+)(\.(\d+))?$/; print(10000 * $1 + 100 * $2 + ($3 == 0 ? $5 != 1 : $3))')

129 HCNUMVER=$(${HC} --numeric-version|perl -ne '/^(\d+)\.(\d+)\.(\d+)(\.(\d+))?$/; print(10000 * $1 + 100 * $2 + ($3 == 0 ? $5 != 1 : $3))')

84− echo "HCNUMVER=$HCNUMVER" >> $GITHUB_ENV

130+ echo "HCNUMVER=$HCNUMVER" >> "$GITHUB_ENV"

85− echo "ARG_TESTS=--enable-tests" >> $GITHUB_ENV

131+ echo "ARG_TESTS=--enable-tests" >> "$GITHUB_ENV"

86− echo "ARG_BENCH=--enable-benchmarks" >> $GITHUB_ENV

132+ echo "ARG_BENCH=--enable-benchmarks" >> "$GITHUB_ENV"

87− echo "HEADHACKAGE=false" >> $GITHUB_ENV

133+ echo "HEADHACKAGE=false" >> "$GITHUB_ENV"

88− echo "ARG_COMPILER=--$HCNAME --with-compiler=$HC" >> $GITHUB_ENV

134+ echo "ARG_COMPILER=--$HCKIND --with-compiler=$HC" >> "$GITHUB_ENV"

89− echo "GHCJSARITH=0" >> $GITHUB_ENV

135+ echo "GHCJSARITH=0" >> "$GITHUB_ENV"

90 env:

136 env:

137+ HCKIND: ${{ matrix.compilerKind }}

91− CC: ${{ matrix.compiler }}

138+ HCNAME: ${{ matrix.compiler }}

139+ HCVER: ${{ matrix.compilerVersion }}

92 - name: env

140 - name: env

93 run: |

141 run: |

94 env

142 env

@@ -111,6 +159,10 @@ jobs:

111 repository hackage.haskell.org

159 repository hackage.haskell.org

112 url: http://hackage.haskell.org/

160 url: http://hackage.haskell.org/

113 EOF

161 EOF

162+ cat >> $CABAL_CONFIG <<EOF

163+ program-default-options

164+ ghc-options: $GHCJOBS +RTS -M3G -RTS

165+ EOF

114 cat $CABAL_CONFIG

166 cat $CABAL_CONFIG

115 - name: versions

167 - name: versions

116 run: |

168 run: |

@@ -123,14 +175,14 @@ jobs:

123 - name: install cabal-plan

175 - name: install cabal-plan

124 run: |

176 run: |

125 mkdir -p $HOME/.cabal/bin

177 mkdir -p $HOME/.cabal/bin

126− curl -sL https://github.com/haskell-hvr/cabal-plan/releases/download/v0.6.2.0/cabal-plan-0.6.2.0-x86_64-linux.xz > cabal-plan.xz

178+ curl -sL https://github.com/haskell-hvr/cabal-plan/releases/download/v0.7.3.0/cabal-plan-0.7.3.0-x86_64-linux.xz > cabal-plan.xz

127− echo 'de73600b1836d3f55e32d80385acc055fd97f60eaa0ab68a755302685f5d81bc cabal-plan.xz' | sha256sum -c -

179+ echo 'f62ccb2971567a5f638f2005ad3173dba14693a45154c1508645c52289714cb2 cabal-plan.xz' | sha256sum -c -

128 xz -d < cabal-plan.xz > $HOME/.cabal/bin/cabal-plan

180 xz -d < cabal-plan.xz > $HOME/.cabal/bin/cabal-plan

129 rm -f cabal-plan.xz

181 rm -f cabal-plan.xz

130 chmod a+x $HOME/.cabal/bin/cabal-plan

182 chmod a+x $HOME/.cabal/bin/cabal-plan

131 cabal-plan --version

183 cabal-plan --version

132 - name: checkout

184 - name: checkout

133− uses: actions/checkout@v2

185+ uses: actions/checkout@v3

134 with:

186 with:

135 path: source

187 path: source

136 - name: initial cabal.project for sdist

188 - name: initial cabal.project for sdist

@@ -149,12 +201,13 @@ jobs:

149 - name: generate cabal.project

201 - name: generate cabal.project

150 run: |

202 run: |

151 PKGDIR_postgresql_simple="$(find "$GITHUB_WORKSPACE/unpacked" -maxdepth 1 -type d -regex '.*/postgresql-simple-[0-9.]*')"

203 PKGDIR_postgresql_simple="$(find "$GITHUB_WORKSPACE/unpacked" -maxdepth 1 -type d -regex '.*/postgresql-simple-[0-9.]*')"

152− echo "PKGDIR_postgresql_simple=${PKGDIR_postgresql_simple}" >> $GITHUB_ENV

204+ echo "PKGDIR_postgresql_simple=${PKGDIR_postgresql_simple}" >> "$GITHUB_ENV"

205+ rm -f cabal.project cabal.project.local

153 touch cabal.project

206 touch cabal.project

154 touch cabal.project.local

207 touch cabal.project.local

155 echo "packages: ${PKGDIR_postgresql_simple}" >> cabal.project

208 echo "packages: ${PKGDIR_postgresql_simple}" >> cabal.project

156− if [ $((HCNUMVER >= 80200)) -ne 0 ] ; then echo "package postgresql-simple" >> cabal.project ; fi

209+ echo "package postgresql-simple" >> cabal.project

157− if [ $((HCNUMVER >= 80200)) -ne 0 ] ; then echo " ghc-options: -Werror=missing-methods" >> cabal.project ; fi

210+ echo " ghc-options: -Werror=missing-methods" >> cabal.project

158 cat >> cabal.project <<EOF

211 cat >> cabal.project <<EOF

159 allow-newer: cryptohash-md5-0.11.100.1:base

212 allow-newer: cryptohash-md5-0.11.100.1:base

160 EOF

213 EOF

@@ -165,8 +218,8 @@ jobs:

165 run: |

218 run: |

166 $CABAL v2-build $ARG_COMPILER $ARG_TESTS $ARG_BENCH --dry-run all

219 $CABAL v2-build $ARG_COMPILER $ARG_TESTS $ARG_BENCH --dry-run all

167 cabal-plan

220 cabal-plan

168− - name: cache

221+ - name: restore cache

169− uses: actions/cache@v2

222+ uses: actions/cache/restore@v3

170 with:

223 with:

171 key: ${{ runner.os }}-${{ matrix.compiler }}-${{ github.sha }}

224 key: ${{ runner.os }}-${{ matrix.compiler }}-${{ github.sha }}

172 path: ~/.cabal/store

225 path: ~/.cabal/store

@@ -190,8 +243,14 @@ jobs:

190 ${CABAL} -vnormal check

243 ${CABAL} -vnormal check

191 - name: haddock

244 - name: haddock

192 run: |

245 run: |

193− $CABAL v2-haddock $ARG_COMPILER --with-haddock $HADDOCK $ARG_TESTS $ARG_BENCH all

246+ $CABAL v2-haddock --disable-documentation --haddock-all $ARG_COMPILER --with-haddock $HADDOCK $ARG_TESTS $ARG_BENCH all

194 - name: unconstrained build

247 - name: unconstrained build

195 run: |

248 run: |

196 rm -f cabal.project.local

249 rm -f cabal.project.local

197 $CABAL v2-build $ARG_COMPILER --disable-tests --disable-benchmarks all

250 $CABAL v2-build $ARG_COMPILER --disable-tests --disable-benchmarks all

251+ - name: save cache

252+ uses: actions/cache/save@v3

253+ if: always()

254+ with:

255+ key: ${{ runner.os }}-${{ matrix.compiler }}-${{ github.sha }}

256+ path: ~/.cabal/store

.github/workflows/simple.ymlnew file+58

@@ -0,0 +1,58 @@

1+name: Simple

2+on:

3+ push:

4+ branches:

5+ - master

6+ pull_request:

7+ branches:

8+ - master

10+jobs:

11+ native:

12+ name: "Simple: GHC ${{ matrix.ghc }} on ${{ matrix.os }}"

13+ runs-on: ${{ matrix.os }}

14+ strategy:

15+ matrix:

16+ os: [macos-latest, windows-latest]

17+ ghc: ['8.10','9.0','9.2','9.4.8','9.6.3','9.8.1']

18+ fail-fast: false

19+ timeout-minutes:

20+ 60

21+ steps:

22+ - name: Set git to use LF

23+ run: |

24+ git config --global core.autocrlf false

25+ git config --global core.eol lf

26+

27+ - name: Set up Haskell

28+ id: setup-haskell

29+ uses: haskell/actions/setup@v2

30+ with:

31+ ghc-version: ${{ matrix.ghc }}

32+ cabal-version: '3.10.2.0'

33+

34+ - name: Set up PostgreSQL

35+ uses: ikalnytskyi/action-setup-postgres@v3

36+ id: postgres

37+ with:

38+ username: ci

39+ password: sw0rdfish

40+ database: test

41+

42+ - name: Checkout

43+ uses: actions/checkout@v3.0.2

44+

45+ - name: Cache

46+ uses: actions/cache@v2.1.3

47+ with:

48+ path: ${{ steps.setup-haskell.outputs.cabal-store }}

49+ key: ${{ runner.os }}-${{ matrix.ghc }}-${{ github.sha }}

50+ restore-keys: ${{ runner.os }}-${{ matrix.ghc }}-

51+

52+ - name: Build

53+ run: cabal build all --enable-tests

54+

55+ - name: Test

56+ run: cabal test all --enable-tests --test-show-details=direct

57+ env:

58+ DATABASE_CONNSTRING: ${{ steps.postgres.outputs.connection-uri }}

CHANGES.md+22−4

@@ -1,3 +1,21 @@

1+### Version 0.7.0.0 (2023-07-31)

3+ * Remove Eq Null instance. (Future `base` may break it, we remove it profilacticly).

4+ * Use `postgresql-libpq >=0.10.0.0`. It includes critical fixes,

5+ by using `postgresql-simple >=0.7` you won't get older `postgresql-libpq`.

6+ * Drop support for GHC prior 8.6

7+ * Added a class for `postgresql-simple` exceptions: `SomePostgreSqlException`.

8+ This allows to catch all `postgresql-simple` exceptions at once.

9+ (c.f. `AsyncException` in `base).

10+

11+### Version 0.6.5.1 (2023-07-09)

12+

13+ * Support `aeson-2.2.0.0`

14+

15+### Version 0.6.5 (2022-10-30)

16+

17+ * Add `withConnect`

18+

1### Version 0.6.4 (2021-01-06)

19### Version 0.6.4 (2021-01-06)

3 * Add foldCopyData helper function

21 * Add foldCopyData helper function

@@ -253,7 +271,7 @@

253 support UTF8 except for Mule Internal Code, the Multilingual

271 support UTF8 except for Mule Internal Code, the Multilingual

254 Extensions for Emacs. An exception should be raised upon

272 Extensions for Emacs. An exception should be raised upon

255 connecting to a database by the backend if the backend cannot

273 connecting to a database by the backend if the backend cannot

256− accomodate this requirement.

274+ accommodate this requirement.

257

275

258 * Added `Eq` and `Typeable` instances for `Connection`.

276 * Added `Eq` and `Typeable` instances for `Connection`.

259

277

@@ -391,7 +409,7 @@

391

409

392 * Changed the Identifier and QualifiedIdentifier to use Text in

410 * Changed the Identifier and QualifiedIdentifier to use Text in

393 order to avoid encoding errors. Technically this requires a

411 order to avoid encoding errors. Technically this requires a

394− major verson bump, but let's pretend 0.4.1.0 didn't happen.

412+ major version bump, but let's pretend 0.4.1.0 didn't happen.

395

413

396 * Removed non-exhaustive cases in the ToField instance for Values,

414 * Removed non-exhaustive cases in the ToField instance for Values,

397 and tweaked error messages.

415 and tweaked error messages.

@@ -551,7 +569,7 @@

551

569

552 * Added a brand new TypeInfo system that gives FromField instances

570 * Added a brand new TypeInfo system that gives FromField instances

553 convenient and efficient access to the pg_type metatable. This

571 convenient and efficient access to the pg_type metatable. This

554− replaced the older typename cache, and was neccesary to properly

572+ replaced the older typename cache, and was necessary to properly

555 support postgres array types. Thanks to Bas van Dijk for his

573 support postgres array types. Thanks to Bas van Dijk for his

556 work on this feature.

574 work on this feature.

557

575

@@ -643,7 +661,7 @@

643 now the preferred way of dealing with `timestamp` (without time zone).

661 now the preferred way of dealing with `timestamp` (without time zone).

644

662

645 * `Database.PostgreSQL.Simple.Time` is a new module that offers types

663 * `Database.PostgreSQL.Simple.Time` is a new module that offers types

646− that accomodate PostgreSQL's infinities.

664+ that accommodate PostgreSQL's infinities.

647

665

648 * All time-related `FromField`/`ToField` instances are now based on new,

666 * All time-related `FromField`/`ToField` instances are now based on new,

649 higher-speed parsers and printers instead of those provided by the

667 higher-speed parsers and printers instead of those provided by the

appveyor.ymldeleted−80

@@ -1,80 +0,0 @@

1−clone_folder: "c:\\WORK"

2−

3−branches:

4− only:

5− - master

6−

7−services:

8− - postgresql96

9−

10−environment:

11− global:

12− CABOPTS: "--store-dir=C:\\SR --http-transport=plain-http"

13− PGUSER: postgres

14− PGPASSWORD: Password12!

15− PGPORT: "5432"

16− DATABASE_CONNSTRING: appveyor

17− matrix:

18− # 64 bit builds

19− - GHCVER: "8.8.1"

20− CHOCOPTS:

21− - GHCVER: "8.6.5"

22− CHOCOPTS:

23− - GHCVER: "8.4.4"

24− CHOCOPTS:

25− - GHCVER: "8.2.2"

26− CHOCOPTS:

27− - GHCVER: "8.0.2"

28− CHOCOPTS:

29− - GHCVER: "7.10.3.2"

30− CHOCOPTS:

31−

32− # Fails to link

33− #

34− # - GHCVER: "7.8.4.1"

35− # CHOCOPTS:

36−

37− # 32 bit builds

38−

39− # Linker errors...

40−

41− # - GHCVER: "8.6.5"

42− # CHOCOPTS: --forcex86

43− # - GHCVER: "8.4.4"

44− # CHOCOPTS: --forcex86

45− # - GHCVER: "8.2.2"

46− # CHOCOPTS: --forcex86

47−

48− # older segfault?

49−

50−cache:

51−- "C:\\SR"

52−

53−install:

54− - "choco install -y ghc --version %GHCVER% %CHOCOPTS%"

55− - "choco install -y cabal %CHOCOPTS%"

56− - "refreshenv"

57− - "set PATH=C:\\ghc\\ghc-%GHCVER%:C:\\msys64\\mingw64\\bin;C:\\msys64\\usr\\bin;%PATH%"

58− - "cabal --version"

59− - "ghc --version"

60−

61− - set PATH=C:\Progra~1\PostgreSQL\9.6\bin\;%PATH%

62−

63−build: off

64−

65−test_script:

66− - "cabal %CABOPTS% update -v"

67− - createdb TestDb

68− - IF EXIST configure.ac bash -c "autoreconf -i"

69− - "move cabal.project.local.win cabal.project.local"

70−

71− - "cabal %CABOPTS% v2-build -j1 libs test"

72− # - "cabal %CABOPTS% v2-test -j1 all"

73− - "cabal %CABOPTS% v2-run test"

74− # - "cabal %CABOPTS% v2-run inspection" # only GHC-8.0 (or GHC-8.2+)

75−

76− # Build from sdist

77− - "rmdir /Q /S dist-newstyle"

78− - "cabal v2-sdist"

79− - "sh -c 'echo packages: dist-newstyle/sdist/*.tar.gz > cabal.project'"

80− - "cabal v2-build -j1 postgresql-simple" # TODO: unfortunately the package name have to be here

postgresql-simple.cabal+26−48

@@ -1,7 +1,7 @@

1cabal-version: 1.12

2name: postgresql-simple

3−version: 0.6.4

3+version: 0.7.0.0

4−x-revision: 4

4+x-revision: 1

5synopsis: Mid-Level PostgreSQL client library

6description:

7 Mid-Level PostgreSQL client library, forked from mysql-simple.

@@ -24,17 +24,14 @@ extra-source-files:

24 test/results/unique-constraint-violation.expected

26tested-with:

27− GHC ==7.6.3

28− || ==7.8.4

29− || ==7.10.3

30− || ==8.0.2

31− || ==8.2.2

32− || ==8.4.4

33− || ==8.6.5

27+ GHC ==8.6.5

34 || ==8.8.4

28 || ==8.8.4

35 || ==8.10.7

29 || ==8.10.7

36− || ==9.0.1

30+ || ==9.0.2

37− || ==9.2.1

31+ || ==9.2.8

32+ || ==9.4.8

33+ || ==9.6.3

34+ || ==9.8.1

39library

36library

40 default-language: Haskell2010

37 default-language: Haskell2010

@@ -80,34 +77,25 @@ library

81 -- GHC bundled libs

78 -- GHC bundled libs

82 build-depends:

79 build-depends:

83− base >=4.6.0.0 && <4.17

80+ base >=4.12.0.0 && <4.20

84− , bytestring >=0.10.0.0 && <0.12

81+ , bytestring >=0.10.8.2 && <0.13

85− , containers >=0.5.0.0 && <0.7

82+ , containers >=0.6.0.1 && <0.7

86− , template-haskell >=2.8.0.0 && <2.19

83+ , template-haskell >=2.14.0.0 && <2.22

87− , text >=1.2.3.0 && <1.3

84+ , text >=1.2.3.0 && <1.3 || >=2.0 && <2.2

88 , time-compat >=1.9.5 && <1.12

85 , time-compat >=1.9.5 && <1.12

89− , transformers >=0.3.0.0 && <0.6

86+ , transformers >=0.5.6.2 && <0.7

91 -- Other dependencies

88 -- Other dependencies

92 build-depends:

89 build-depends:

93− aeson >=1.4.1.0 && <1.6 || >=2.0.0.0 && <2.1

90+ aeson >=2.1.2.1 && <2.3

94− , attoparsec >=0.13.2.2 && <0.15

91+ , attoparsec >=0.14.4 && <0.15

95− , bytestring-builder >=0.10.8.1.0 && <0.11

96− , case-insensitive >=1.2.0.11 && <1.3

92+ , case-insensitive >=1.2.1.0 && <1.3

97− , hashable >=1.2.7.0 && <1.5

93+ , hashable >=1.4.3.0 && <1.5

98− , Only >=0.1 && <0.1.1

94+ , Only >=0.1 && <0.1.1

99− , postgresql-libpq >=0.9.4.3 && <0.10

95+ , postgresql-libpq >=0.10.0.0 && <0.11

100− , scientific >=0.3.6.2 && <0.4

96+ , scientific >=0.3.7.0 && <0.4

101− , uuid-types >=1.0.3 && <1.1

97+ , uuid-types >=1.0.5 && <1.1

102− , vector >=0.12.0.1 && <0.13

98+ , vector >=0.13.0.0 && <0.14

103−

104− if !impl(ghc >=8.0)

105− build-depends:

106− fail >=4.9.0.0 && <4.10

107− , semigroups >=0.18.5 && <0.20

108−

109− if !impl(ghc >=7.6)

110− build-depends: ghc-prim

111

112 default-extensions:

100 default-extensions:

113 BangPatterns

101 BangPatterns

@@ -122,22 +110,14 @@ source-repository head

122 type: git

110 type: git

123 location: http://github.com/haskellari/postgresql-simple

111 location: http://github.com/haskellari/postgresql-simple

124

112

125−source-repository this

126− type: git

127− location: http://github.com/haskellari/postgresql-simple

128− tag: v0.6.3

129−

130test-suite inspection

113test-suite inspection

131− if !impl(ghc >=8.0)

132− buildable: False

133−

134 default-language: Haskell2010

114 default-language: Haskell2010

135 type: exitcode-stdio-1.0

115 type: exitcode-stdio-1.0

136 hs-source-dirs: test

116 hs-source-dirs: test

137 main-is: Inspection.hs

117 main-is: Inspection.hs

138 build-depends:

118 build-depends:

139 base

119 base

140− , inspection-testing >=0.4.1.1 && <0.5

120+ , inspection-testing >=0.4.1.1 && <0.6

141 , postgresql-libpq

121 , postgresql-libpq

142 , postgresql-simple

122 , postgresql-simple

143 , tasty

123 , tasty

@@ -150,10 +130,11 @@ test-suite test

150 main-is: Main.hs

130 main-is: Main.hs

151 other-modules:

131 other-modules:

152 Common

132 Common

133+ Exception

134+ Interval

153 Notify

135 Notify

154 Serializable

136 Serializable

155 Time

137 Time

156− Interval

157

138

158 ghc-options: -threaded

139 ghc-options: -threaded

159 ghc-options: -Wall -fno-warn-name-shadowing -fno-warn-unused-do-bind

140 ghc-options: -Wall -fno-warn-name-shadowing -fno-warn-unused-do-bind

@@ -183,9 +164,6 @@ test-suite test

183 , time-compat

164 , time-compat

184 , vector

165 , vector

185

166

186− if !impl(ghc >=7.6)

187− build-depends: ghc-prim

188−

189benchmark select

167benchmark select

190 default-language: Haskell2010

168 default-language: Haskell2010

191 type: exitcode-stdio-1.0

169 type: exitcode-stdio-1.0

src/Database/PostgreSQL/Simple.hs+3−1

@@ -64,6 +64,7 @@ module Database.PostgreSQL.Simple

64 , Only(..)

65 , (:.)(..)

66 -- ** Exceptions

67+ , SomePostgreSqlException(..)

67 , SqlError(..)

68 , SqlError(..)

68 , PQ.ExecStatus(..)

69 , PQ.ExecStatus(..)

69 , FormatError(..)

70 , FormatError(..)

@@ -73,6 +74,7 @@ module Database.PostgreSQL.Simple

73 , Base.connectPostgreSQL

74 , Base.connectPostgreSQL

74 , Base.close

75 , Base.close

75 , Base.connect

76 , Base.connect

77+ , Base.withConnect

76 , Base.ConnectInfo(..)

78 , Base.ConnectInfo(..)

77 , Base.defaultConnectInfo

79 , Base.defaultConnectInfo

78 , Base.postgreSQLConnectionString

80 , Base.postgreSQLConnectionString

@@ -900,7 +902,7 @@ forEachWith_ parser conn template = foldWith_ parser conn template () . const

900-- all values of the given PostgreSQL type is considered \"compatible\".

902-- all values of the given PostgreSQL type is considered \"compatible\".

901-- For instance, you can always extract a PostgreSQL 16-bit @SMALLINT@

903-- For instance, you can always extract a PostgreSQL 16-bit @SMALLINT@

902-- column to a Haskell 'Int'. The Haskell 'Float' type can accurately

904-- column to a Haskell 'Int'. The Haskell 'Float' type can accurately

903−-- represent a @SMALLINT@, so it is considered compatble with those types.

905+-- represent a @SMALLINT@, so it is considered compatible with those types.

904--

906--

905-- * A numeric compatibility check is based only on the type of a

907-- * A numeric compatibility check is based only on the type of a

906-- column, /not/ on its values. For instance, a PostgreSQL 64-bit

908-- column, /not/ on its values. For instance, a PostgreSQL 64-bit

src/Database/PostgreSQL/Simple/Compat.hs−53

@@ -12,36 +12,13 @@ module Database.PostgreSQL.Simple.Compat

12 ) where

14import qualified Control.Exception as E

15−import Data.Monoid

16import Data.ByteString (ByteString)

15import Data.ByteString (ByteString)

17−#if MIN_VERSION_bytestring(0,10,0)

18import Data.ByteString.Lazy (toStrict)

16import Data.ByteString.Lazy (toStrict)

19−#else

20−import qualified Data.ByteString as B

21−import Data.ByteString.Lazy (toChunks)

22−#endif

23import Data.ByteString.Builder (Builder, toLazyByteString)

17import Data.ByteString.Builder (Builder, toLazyByteString)

24−

25−#if MIN_VERSION_scientific(0,3,0)

26import Data.Text.Lazy.Builder.Scientific (scientificBuilder)

18import Data.Text.Lazy.Builder.Scientific (scientificBuilder)

27−#else

28−import Data.Scientific (scientificBuilder)

29−#endif

30−

31−#if __GLASGOW_HASKELL__ >= 702

32import System.IO.Unsafe (unsafeDupablePerformIO)

19import System.IO.Unsafe (unsafeDupablePerformIO)

33−#elif __GLASGOW_HASKELL__ >= 611

34−import GHC.IO (unsafeDupablePerformIO)

35−#else

36−import GHC.IOBase (unsafeDupablePerformIO)

37−#endif

38−

39import Data.Fixed (Pico)

20import Data.Fixed (Pico)

40−#if MIN_VERSION_base(4,7,0)

41import Data.Fixed (Fixed(MkFixed))

21import Data.Fixed (Fixed(MkFixed))

42−#else

43−import Unsafe.Coerce (unsafeCoerce)

44−#endif

46-- | Like 'E.mask', but backported to base before version 4.3.0.

23-- | Like 'E.mask', but backported to base before version 4.3.0.

47--

24--

@@ -51,44 +28,14 @@ import Unsafe.Coerce (unsafeCoerce)

51-- 'withTransactionMode' function calls the restore callback only once, so we

28-- 'withTransactionMode' function calls the restore callback only once, so we

52-- don't need that polymorphism.

29-- don't need that polymorphism.

53mask :: ((IO a -> IO a) -> IO b) -> IO b

30mask :: ((IO a -> IO a) -> IO b) -> IO b

54−#if MIN_VERSION_base(4,3,0)

55mask io = E.mask $ \restore -> io restore

31mask io = E.mask $ \restore -> io restore

56−#else

57−mask io = do

58− b <- E.blocked

59− E.block $ io $ \m -> if b then m else E.unblock m

60−#endif

61{-# INLINE mask #-}

32{-# INLINE mask #-}

63−#if !MIN_VERSION_base(4,5,0)

64−infixr 6 <>

65−

66−(<>) :: Monoid m => m -> m -> m

67−(<>) = mappend

68−{-# INLINE (<>) #-}

69−#endif

70−

71toByteString :: Builder -> ByteString

34toByteString :: Builder -> ByteString

72−#if MIN_VERSION_bytestring(0,10,0)

73toByteString x = toStrict (toLazyByteString x)

35toByteString x = toStrict (toLazyByteString x)

74−#else

75−toByteString x = B.concat (toChunks (toLazyByteString x))

76−#endif

77−

78−#if MIN_VERSION_base(4,7,0)

80toPico :: Integer -> Pico

37toPico :: Integer -> Pico

81toPico = MkFixed

38toPico = MkFixed

83fromPico :: Pico -> Integer

40fromPico :: Pico -> Integer

84fromPico (MkFixed i) = i

41fromPico (MkFixed i) = i

85−

86−#else

87−

88−toPico :: Integer -> Pico

89−toPico = unsafeCoerce

90−

91−fromPico :: Pico -> Integer

92−fromPico = unsafeCoerce

93−

94−#endif

src/Database/PostgreSQL/Simple/Copy.hs+1−5

@@ -55,7 +55,7 @@ import Database.PostgreSQL.Simple.Internal hiding (result, row)

55-- | Issue a @COPY FROM STDIN@ or @COPY TO STDOUT@ query. In the former

56-- case, the connection's state will change to @CopyIn@; in the latter,

57-- @CopyOut@. The connection must be in the ready state in order

58−-- to call this function. Performs parameter subsitution.

58+-- to call this function. Performs parameter substitution.

60copy :: ( ToRow params ) => Connection -> Query -> params -> IO ()

61copy conn template qs = do

@@ -86,12 +86,8 @@ doCopy funcName conn template q = do

86 PQ.TuplesOk -> err

87 PQ.CopyOut -> return ()

88 PQ.CopyIn -> return ()

89−#if MIN_VERSION_postgresql_libpq(0,9,3)

90 PQ.CopyBoth -> errMsg "COPY BOTH is not supported"

89 PQ.CopyBoth -> errMsg "COPY BOTH is not supported"

91−#endif

92−#if MIN_VERSION_postgresql_libpq(0,9,2)

93 PQ.SingleTuple -> errMsg "single-row mode is not supported"

90 PQ.SingleTuple -> errMsg "single-row mode is not supported"

94−#endif

95 PQ.BadResponse -> throwResultError funcName result status

91 PQ.BadResponse -> throwResultError funcName result status

96 PQ.NonfatalError -> throwResultError funcName result status

92 PQ.NonfatalError -> throwResultError funcName result status

97 PQ.FatalError -> throwResultError funcName result status

93 PQ.FatalError -> throwResultError funcName result status

src/Database/PostgreSQL/Simple/Errors.hs+4−3

@@ -25,7 +25,6 @@ module Database.PostgreSQL.Simple.Errors

25 )

26 where

28−import Control.Applicative

29import Control.Exception as E

28import Control.Exception as E

31import Data.Attoparsec.ByteString.Char8

30import Data.Attoparsec.ByteString.Char8

@@ -60,11 +59,13 @@ data ConstraintViolation

60 deriving (Show, Eq, Ord, Typeable)

59 deriving (Show, Eq, Ord, Typeable)

62-- Default instance should be enough

61-- Default instance should be enough

63−instance Exception ConstraintViolation

62+instance Exception ConstraintViolation where

63+ toException = postgresqlExceptionToException

64+ fromException = postgresqlExceptionFromException

66-- | Tries to convert 'SqlError' to 'ConstrainViolation', checks sqlState and

67-- | Tries to convert 'SqlError' to 'ConstrainViolation', checks sqlState and

67−-- succeedes only if able to parse sqlErrorMsg.

68+-- succeeds only if able to parse sqlErrorMsg.

68--

69--

69-- > createUser = handleJust constraintViolation handler $ execute conn ...

70-- > createUser = handleJust constraintViolation handler $ execute conn ...

70-- > where

71-- > where

src/Database/PostgreSQL/Simple/FromField.hs+7−5

@@ -118,10 +118,8 @@ module Database.PostgreSQL.Simple.FromField

118

119import Control.Applicative ( Const(Const), (<|>), (<$>), pure, (*>), (<*) )

120import Control.Concurrent.MVar (MVar, newMVar)

121−import Control.Exception (Exception)

121+import Control.Exception (Exception (toException, fromException))

122import qualified Data.Aeson as JSON

123−import qualified Data.Aeson.Internal as JSON

124−import qualified Data.Aeson.Parser as JSON (value')

125import Data.Attoparsec.ByteString.Char8 hiding (Result)

123import Data.Attoparsec.ByteString.Char8 hiding (Result)

126import Data.ByteString (ByteString)

124import Data.ByteString (ByteString)

127import qualified Data.ByteString.Char8 as B

125import qualified Data.ByteString.Char8 as B

@@ -156,6 +154,8 @@ import qualified Data.UUID.Types as UUID

156import Data.Scientific (Scientific)

154import Data.Scientific (Scientific)

157import GHC.Real (infinity, notANumber)

155import GHC.Real (infinity, notANumber)

158

156

157+import qualified Data.Aeson.Types as JSON

158+

159-- | Exception thrown if conversion from a SQL value to a Haskell

160-- value fails.

161data ResultError = Incompatible { errSQLType :: String

@@ -182,7 +182,9 @@ data ResultError = Incompatible { errSQLType :: String

182 -- between metadata and actual data in a row).

183 deriving (Eq, Show, Typeable)

184

185−instance Exception ResultError

185+instance Exception ResultError where

186+ toException = postgresqlExceptionToException

187+ fromException = postgresqlExceptionFromException

186

188

187left :: Exception a => a -> Conversion b

189left :: Exception a => a -> Conversion b

188left = conversionError

190left = conversionError

@@ -574,7 +576,7 @@ instance FromField UUID where

574-- | json, jsonb

576-- | json, jsonb

575instance FromField JSON.Value where

577instance FromField JSON.Value where

576 fromField f mbs = parseBS =<< fromFieldJSONByteString f mbs

578 fromField f mbs = parseBS =<< fromFieldJSONByteString f mbs

577− where parseBS bs = case parseOnly (JSON.value' <* endOfInput) bs of

579+ where parseBS bs = case JSON.eitherDecodeStrict' bs of

578 Left err -> returnError ConversionFailed f err

580 Left err -> returnError ConversionFailed f err

579 Right val -> pure val

581 Right val -> pure val

580

582

src/Database/PostgreSQL/Simple/HStore/Implementation.hs−6

@@ -22,9 +22,6 @@ import Data.ByteString.Builder (Builder, byteString, char8)

22import qualified Data.ByteString.Builder as BU

23import Data.ByteString.Internal (c2w, w2c)

24import qualified Data.ByteString.Lazy as BL

25−#if !MIN_VERSION_bytestring(0,10,0)

26−import qualified Data.ByteString.Lazy.Internal as BL (foldrChunks)

27−#endif

28import Data.Map(Map)

25import Data.Map(Map)

29import qualified Data.Map as Map

26import qualified Data.Map as Map

30import Data.Text(Text)

27import Data.Text(Text)

@@ -69,9 +66,6 @@ instance Semigroup HStoreBuilder where

70instance Monoid HStoreBuilder where

67instance Monoid HStoreBuilder where

71 mempty = Empty

68 mempty = Empty

72−#if !(MIN_VERSION_base(4,11,0))

73− mappend = (<>)

74−#endif

76class ToHStoreText a where

70class ToHStoreText a where

77 toHStoreText :: a -> HStoreText

71 toHStoreText :: a -> HStoreText

src/Database/PostgreSQL/Simple/Internal.hs+37−7

@@ -1,6 +1,8 @@

1{-# LANGUAGE CPP, BangPatterns, DoAndIfThenElse, RecordWildCards #-}

2{-# LANGUAGE DeriveDataTypeable, DeriveGeneric #-}

3{-# LANGUAGE GeneralizedNewtypeDeriving #-}

4+{-# LANGUAGE ExistentialQuantification #-}

5+{-# LANGUAGE InstanceSigs #-}

5------------------------------------------------------------------------------

7------------------------------------------------------------------------------

6-- |

8-- |

@@ -34,7 +36,6 @@ import Data.Int (Int64)

34import qualified Data.IntMap as IntMap

36import qualified Data.IntMap as IntMap

35import Data.IORef

37import Data.IORef

36import Data.Maybe(fromMaybe)

38import Data.Maybe(fromMaybe)

37−import Data.Monoid

38import Data.String

39import Data.String

39import qualified Data.Text as T

40import qualified Data.Text as T

40import qualified Data.Text.Encoding as TE

41import qualified Data.Text.Encoding as TE

@@ -82,6 +83,25 @@ data Connection = Connection {

82instance Eq Connection where

83instance Eq Connection where

83 x == y = connectionHandle x == connectionHandle y

84 x == y = connectionHandle x == connectionHandle y

86+-- | Superclass for postgresql exceptions

87+data SomePostgreSqlException = forall e. Exception e => SomePostgreSqlException e

88+ deriving Typeable

89+

90+postgresqlExceptionToException :: Exception e => e -> SomeException

91+postgresqlExceptionToException = toException . SomePostgreSqlException

92+

93+postgresqlExceptionFromException :: Exception e => SomeException -> Maybe e

94+postgresqlExceptionFromException x = do

95+ SomePostgreSqlException a <- fromException x

96+ cast a

97+

98+instance Show SomePostgreSqlException where

99+ showsPrec :: Int -> SomePostgreSqlException -> ShowS

100+ showsPrec p (SomePostgreSqlException e) = showsPrec p e

101+

102+instance Exception SomePostgreSqlException where

103+ displayException (SomePostgreSqlException e) = displayException e

104+

85data SqlError = SqlError {

105data SqlError = SqlError {

86 sqlState :: ByteString

106 sqlState :: ByteString

87 , sqlExecStatus :: ExecStatus

107 , sqlExecStatus :: ExecStatus

@@ -93,7 +113,10 @@ data SqlError = SqlError {

93fatalError :: ByteString -> SqlError

113fatalError :: ByteString -> SqlError

94fatalError msg = SqlError "" FatalError msg "" ""

114fatalError msg = SqlError "" FatalError msg "" ""

115

96−instance Exception SqlError

116+instance Exception SqlError where

117+ toException = postgresqlExceptionToException

118+ fromException = postgresqlExceptionFromException

119+

120

98-- | Exception thrown if 'query' is used to perform an @INSERT@-like

121-- | Exception thrown if 'query' is used to perform an @INSERT@-like

99-- operation, or 'execute' is used to perform a @SELECT@-like operation.

122-- operation, or 'execute' is used to perform a @SELECT@-like operation.

@@ -102,7 +125,9 @@ data QueryError = QueryError {

102 , qeQuery :: Query

125 , qeQuery :: Query

103 } deriving (Eq, Show, Typeable)

126 } deriving (Eq, Show, Typeable)

104

127

105−instance Exception QueryError

128+instance Exception QueryError where

129+ toException = postgresqlExceptionToException

130+ fromException = postgresqlExceptionFromException

106

131

107-- | Exception thrown if a 'Query' could not be formatted correctly.

132-- | Exception thrown if a 'Query' could not be formatted correctly.

108-- This may occur if the number of \'@?@\' characters in the query

133-- This may occur if the number of \'@?@\' characters in the query

@@ -113,7 +138,9 @@ data FormatError = FormatError {

113 , fmtParams :: [ByteString]

138 , fmtParams :: [ByteString]

114 } deriving (Eq, Show, Typeable)

139 } deriving (Eq, Show, Typeable)

115

140

116−instance Exception FormatError

141+instance Exception FormatError where

142+ toException = postgresqlExceptionToException

143+ fromException = postgresqlExceptionFromException

117

144

118data ConnectInfo = ConnectInfo {

145data ConnectInfo = ConnectInfo {

119 connectHost :: String

146 connectHost :: String

@@ -155,6 +182,12 @@ defaultConnectInfo = ConnectInfo {

155connect :: ConnectInfo -> IO Connection

182connect :: ConnectInfo -> IO Connection

156connect = connectPostgreSQL . postgreSQLConnectionString

183connect = connectPostgreSQL . postgreSQLConnectionString

157

184

185+-- | Memory bracket around 'connect' and 'close'.

186+--

187+-- @since 0.6.5

188+withConnect :: ConnectInfo -> (Connection -> IO c) -> IO c

189+withConnect connInfo = bracket (connect connInfo) close

190+

158-- | Attempt to make a connection based on a libpq connection string.

191-- | Attempt to make a connection based on a libpq connection string.

159-- See <https://www.postgresql.org/docs/9.5/static/libpq-connect.html#LIBPQ-CONNSTRING>

192-- See <https://www.postgresql.org/docs/9.5/static/libpq-connect.html#LIBPQ-CONNSTRING>

160-- for more information. Also note that environment variables also affect

193-- for more information. Also note that environment variables also affect

@@ -484,9 +517,6 @@ instance Alternative Conversion where

484 Errors _ -> (oka <|>) <$> runConversion mb conn

517 Errors _ -> (oka <|>) <$> runConversion mb conn

485

518

486instance Monad Conversion where

519instance Monad Conversion where

487−#if !(MIN_VERSION_base(4,8,0))

488− return = pure

489−#endif

490 m >>= f = Conversion $ \conn -> do

520 m >>= f = Conversion $ \conn -> do

491 oka <- runConversion m conn

521 oka <- runConversion m conn

492 case oka of

522 case oka of

src/Database/PostgreSQL/Simple/Internal/PQResultUtils.hs−4

@@ -76,12 +76,8 @@ finishQueryWith' q result k = do

76 PQ.CommandOk -> queryErr "query resulted in a command response (did you mean to use `execute` or forget a RETURNING?)"

77 PQ.CopyOut -> queryErr "query: COPY TO is not supported"

78 PQ.CopyIn -> queryErr "query: COPY FROM is not supported"

79−#if MIN_VERSION_postgresql_libpq(0,9,3)

80 PQ.CopyBoth -> queryErr "query: COPY BOTH is not supported"

79 PQ.CopyBoth -> queryErr "query: COPY BOTH is not supported"

81−#endif

82−#if MIN_VERSION_postgresql_libpq(0,9,2)

83 PQ.SingleTuple -> queryErr "query: single-row mode is not supported"

80 PQ.SingleTuple -> queryErr "query: single-row mode is not supported"

84−#endif

85 PQ.BadResponse -> throwResultError "query" result status

81 PQ.BadResponse -> throwResultError "query" result status

86 PQ.NonfatalError -> throwResultError "query" result status

82 PQ.NonfatalError -> throwResultError "query" result status

87 PQ.FatalError -> throwResultError "query" result status

83 PQ.FatalError -> throwResultError "query" result status

src/Database/PostgreSQL/Simple/Notification.hs−17

@@ -47,8 +47,6 @@ import GHC.IO.Exception ( ioe_location )

48#if defined(mingw32_HOST_OS)

49import Control.Concurrent ( threadDelay )

50−#elif !MIN_VERSION_base(4,7,0)

51−import Control.Concurrent ( threadWaitRead )

52#else

50#else

53import GHC.Conc ( atomically )

51import GHC.Conc ( atomically )

54import Control.Concurrent ( threadWaitReadSTM )

52import Control.Concurrent ( threadWaitReadSTM )

@@ -94,21 +92,6 @@ getNotification conn = join $ withConnection conn fetch

94 -- with async exceptions, whereas threadDelay can.

92 -- with async exceptions, whereas threadDelay can.

95 Just _fd -> do

93 Just _fd -> do

96 return (threadDelay 1000000 >> loop)

94 return (threadDelay 1000000 >> loop)

97−#elif !MIN_VERSION_base(4,7,0)

98− -- Technically there's a race condition that is usually benign.

99− -- If the connection is closed or reset after we drop the

100− -- lock, and then the fd index is reallocated to a new

101− -- descriptor before we call threadWaitRead, then

102− -- we could end up waiting on the wrong descriptor.

103− --

104− -- Now, if the descriptor becomes readable promptly, then

105− -- it's no big deal as we'll wake up and notice the change

106− -- on the next iteration of the loop. But if are very

107− -- unlucky, then we could end up waiting a long time.

108− Just fd -> do

109− return $ do

110− threadWaitRead fd `catch` (throwIO . setIOErrorLocation)

111− loop

112#else

95#else

113 -- This case fixes the race condition above. By registering

96 -- This case fixes the race condition above. By registering

114 -- our interest in the descriptor before we drop the lock,

97 -- our interest in the descriptor before we drop the lock,

src/Database/PostgreSQL/Simple/Ok.hs−4

@@ -72,10 +72,6 @@ instance MonadPlus Ok where

72 mplus = (<|>)

74instance Monad Ok where

75−#if !(MIN_VERSION_base(4,8,0))

76− return = pure

77−#endif

78−

79 Errors es >>= _ = Errors es

75 Errors es >>= _ = Errors es

80 Ok a >>= f = f a

76 Ok a >>= f = f a

src/Database/PostgreSQL/Simple/ToField.hs+2−7

@@ -59,11 +59,7 @@ import qualified Data.Vector as V

59import qualified Database.PostgreSQL.LibPQ as PQ

60import Database.PostgreSQL.Simple.Time

61import Data.Scientific (Scientific)

62−#if MIN_VERSION_scientific(0,3,0)

63import Data.Text.Lazy.Builder.Scientific (scientificBuilder)

62import Data.Text.Lazy.Builder.Scientific (scientificBuilder)

64−#else

65−import Data.Scientific (scientificBuilder)

66−#endif

67import Foreign.C.Types (CUInt(..))

63import Foreign.C.Types (CUInt(..))

69-- | How to render an element when substituting it into a query.

65-- | How to render an element when substituting it into a query.

@@ -318,14 +314,13 @@ instance ToField UUID where

318instance ToField JSON.Value where

314instance ToField JSON.Value where

319 toField = toField . JSON.encode

315 toField = toField . JSON.encode

320

316

321−-- | Convert a Haskell value to a JSON 'JSON.Value' using

317+-- | Convert a Haskell value to JSON using 'JSON.toEncoding'.

322−-- 'JSON.toJSON' and convert that to a field using 'toField'.

323--

318--

324-- This can be used as the default implementation for the 'toField'

319-- This can be used as the default implementation for the 'toField'

325-- method for Haskell types that have a JSON representation in

320-- method for Haskell types that have a JSON representation in

326-- PostgreSQL.

321-- PostgreSQL.

327toJSONField :: JSON.ToJSON a => a -> Action

322toJSONField :: JSON.ToJSON a => a -> Action

328−toJSONField = toField . JSON.toJSON

323+toJSONField = toField . JSON.encode

329

324

330-- | Surround a string with single-quote characters: \"@'@\"

325-- | Surround a string with single-quote characters: \"@'@\"

331--

326--

src/Database/PostgreSQL/Simple/Types.hs−7

@@ -50,10 +50,6 @@ import Database.PostgreSQL.Simple.Compat (toByteString)

50data Null = Null

51 deriving (Read, Show, Typeable)

53−instance Eq Null where

54− _ == _ = False

55− _ /= _ = False

56−

57-- | A placeholder for the PostgreSQL @DEFAULT@ value.

53-- | A placeholder for the PostgreSQL @DEFAULT@ value.

58data Default = Default

54data Default = Default

59 deriving (Read, Show, Typeable)

55 deriving (Read, Show, Typeable)

@@ -97,9 +93,6 @@ instance Semigroup Query where

98instance Monoid Query where

94instance Monoid Query where

99 mempty = Query B.empty

95 mempty = Query B.empty

100−#if !(MIN_VERSION_base(4,11,0))

101− mappend = (<>)

102−#endif

103

104-- | Wrap a list of values for use in an @IN@ clause. Replaces a

97-- | Wrap a list of values for use in an @IN@ clause. Replaces a

105-- single \"@?@\" character with a parenthesized list of rendered

98-- single \"@?@\" character with a parenthesized list of rendered

test/Exception.hsnew file+70

@@ -0,0 +1,70 @@

1+{-# LANGUAGE CPP #-}

2+{-# LANGUAGE OverloadedStrings #-}

3+{-# LANGUAGE ScopedTypeVariables #-}

5+module Exception (testExceptions) where

7+import Database.PostgreSQL.Simple

8+import Test.Tasty.HUnit (Assertion, assertBool)

9+import Common (TestEnv)

10+import Control.Exception (Exception (..), SomeException)

11+import Data.Maybe (isJust)

12+import Data.Either (isLeft)

13+import Control.Exception (throwIO, try)

14+

15+testExceptions :: TestEnv -> Assertion

16+testExceptions _ = do

17+ let sqlError = SqlError

18+ { sqlState = ""

19+ , sqlExecStatus = FatalError

20+ , sqlErrorMsg = ""

21+ , sqlErrorDetail = ""

22+ , sqlErrorHint = ""

23+ }

24+ let sqlEx :: SomeException = toException sqlError

25+ assertBool "SqlError is SomePostgreSqlException" $ isJust (fromException sqlEx :: Maybe SomePostgreSqlException)

26+ assertBool "SqlError is SqlError" $ isJust (fromException sqlEx :: Maybe SqlError)

27+ eSqlError :: Either SqlError () <- try $ throwIO sqlEx

28+ assertBool "Can catch SqlError" $ isLeft eSqlError

29+ eSqlPostgreSqlEx :: Either SomePostgreSqlException () <- try $ throwIO sqlEx

30+ assertBool "Can catch SomePostgreSqlException from SqlError" $ isLeft eSqlPostgreSqlEx

31+

32+ let formatError = FormatError

33+ { fmtMessage = ""

34+ , fmtQuery = ""

35+ , fmtParams = []

36+ }

37+ let formatEx :: SomeException = toException formatError

38+ assertBool "FormatError is SomePostgreSqlException" $ isJust (fromException formatEx :: Maybe SomePostgreSqlException)

39+ assertBool "FormatError is FormatError" $ isJust (fromException formatEx :: Maybe FormatError)

40+ eFormatError :: Either FormatError () <- try $ throwIO formatEx

41+ assertBool "Can catch FormatError" $ isLeft eFormatError

42+ eFormatPostreSqlEx :: Either SomePostgreSqlException () <- try $ throwIO formatEx

43+ assertBool "Can catch SomePostgreSqlException from FormatError" $ isLeft eFormatPostreSqlEx

44+

45+ let queryError = QueryError

46+ { qeMessage = ""

47+ , qeQuery = ""

48+ }

49+ let queryEx :: SomeException = toException queryError

50+ assertBool "QueryError is SomePostgreSqlException" $ isJust (fromException queryEx :: Maybe SomePostgreSqlException)

51+ assertBool "QueryError is QueryError" $ isJust (fromException queryEx :: Maybe QueryError)

52+ eQueryError :: Either QueryError () <- try $ throwIO queryEx

53+ assertBool "Can catch QueryError" $ isLeft eQueryError

54+ eQueryPostgreSqlEx :: Either SomePostgreSqlException () <- try $ throwIO queryEx

55+ assertBool "Can catch SomePostgreSqlException from QueryError" $ isLeft eQueryPostgreSqlEx

56+

57+ let resultError = Incompatible

58+ { errSQLType = ""

59+ , errSQLTableOid = Nothing

60+ , errSQLField = ""

61+ , errHaskellType = ""

62+ , errMessage = ""

63+ }

64+ let resultEx :: SomeException = toException resultError

65+ assertBool "ResultError is SomePostgreSqlException" $ isJust (fromException resultEx :: Maybe SomePostgreSqlException)

66+ assertBool "ResultError is ResultError" $ isJust (fromException resultEx :: Maybe ResultError)

67+ eResultEx :: Either ResultError () <- try $ throwIO resultEx

68+ assertBool "Can catch ResultError" $ isLeft eResultEx

69+ eResultPostgreSqlEx :: Either SomePostgreSqlException () <- try $ throwIO resultEx

70+ assertBool "Can catch SomePostgreSqlException from ResultError" $ isLeft eResultPostgreSqlEx

test/Main.hs+5−2

@@ -55,6 +55,7 @@ import Notify

55import Serializable

56import Time

57import Interval

58+import Exception (testExceptions)

59tests :: TestEnv -> TestTree

60tests :: TestEnv -> TestTree

60tests env = testGroup "tests"

61tests env = testGroup "tests"

@@ -84,6 +85,7 @@ tests env = testGroup "tests"

84 , testCase "2-ary generic" . testGeneric2

85 , testCase "2-ary generic" . testGeneric2

85 , testCase "3-ary generic" . testGeneric3

86 , testCase "3-ary generic" . testGeneric3

86 , testCase "Timeout" . testTimeout

87 , testCase "Timeout" . testTimeout

88+ , testCase "Exceptions" . testExceptions

87 ]

89 ]

89testBytea :: TestEnv -> TestTree

91testBytea :: TestEnv -> TestTree

@@ -137,7 +139,7 @@ testFold TestEnv{..} = do

137 xs <- readIORef ref

139 xs <- readIORef ref

138 writeIORef ref $! (a,b):xs

140 writeIORef ref $! (a,b):xs

139 xs <- readIORef ref

141 xs <- readIORef ref

140− reverse xs @?= [(a,b) | a <- [1..100], b <- [1..50]]

142+ reverse xs @?= [(a,b) | b <- [1..50], a <- [1..100]]

141

143

142 -- Make sure fold propagates our exception.

144 -- Make sure fold propagates our exception.

143 ref <- newIORef []

145 ref <- newIORef []

@@ -472,12 +474,13 @@ testCopyFailures env = testGroup "Copy failures"

472

474

473goldenTest :: TestName -> IO BL.ByteString -> TestTree

475goldenTest :: TestName -> IO BL.ByteString -> TestTree

474goldenTest testName =

476goldenTest testName =

475− goldenVsString testName (resultsDir </> fileName<.>"expected")

477+ goldenVsStringDiff testName diff (resultsDir </> fileName<.>"expected")

476 where

478 where

477 resultsDir = "test" </> "results"

479 resultsDir = "test" </> "results"

478 fileName = map normalize testName

480 fileName = map normalize testName

479 normalize c | not (isAlpha c) = '-'

481 normalize c | not (isAlpha c) = '-'

480 | otherwise = c

482 | otherwise = c

483+ diff ref new = ["diff", "-u", ref, new]

481

484

482-- | Test that we provide a sensible error message on failure

485-- | Test that we provide a sensible error message on failure

483testCopyUniqueConstraintError :: TestEnv -> TestTree

486testCopyUniqueConstraintError :: TestEnv -> TestTree

test/results/malformed-input.expected+1−1

@@ -1,4 +1,4 @@

1user error (Database.PostgreSQL.Simple.Copy.putCopyEnd: failed to parse command status

2−Connection error: ERROR: invalid input syntax for integer: "z"

2+Connection error: ERROR: invalid input syntax for type integer: "z"

3CONTEXT: COPY copy_unique_constraint_error_test, line 3, column x: "z"