diff --git a/go.mod b/go.mod
index 126fbd4ee1e47a9dee7fa28f44ce84e736407c05..ae4e2537ac3a2d420eb1b13782066ebe0c805301 100644
--- a/go.mod
+++ b/go.mod
@@ -8,7 +8,7 @@ require (
github.com/coreos/go-systemd/v22 v22.3.2
github.com/go-ldap/ldap/v3 v3.4.4
github.com/go-sql-driver/mysql v1.7.0
- github.com/lib/pq v1.10.1
+ github.com/lib/pq v1.10.7
github.com/mattn/go-sqlite3 v1.14.16
github.com/prometheus/client_golang v1.12.2
golang.org/x/crypto v0.0.0-20220829220503-c86fa9a7ed90
diff --git a/go.sum b/go.sum
index 46ee6a84fc9bd483a356e96098e1fbee7ee6785b..b167ec8214c6a5e884dda0dbf18e114604ed0546 100644
--- a/go.sum
+++ b/go.sum
@@ -663,6 +663,8 @@ github.com/lib/pq v1.9.0 h1:L8nSXQQzAYByakOFMTwpjRoHsMJklur4Gi59b6VivR8=
github.com/lib/pq v1.9.0/go.mod h1:AlVN5x4E4T544tWzH6hKfbfQvm3HdbOxrmggDNAPY9o=
github.com/lib/pq v1.10.1 h1:6VXZrLU0jHBYyAqrSPa+MgPfnSvTPuMgK+k0o5kVFWo=
github.com/lib/pq v1.10.1/go.mod h1:AlVN5x4E4T544tWzH6hKfbfQvm3HdbOxrmggDNAPY9o=
+github.com/lib/pq v1.10.7 h1:p7ZhMD+KsSRozJr34udlUrhboJwWAgCg34+/ZZNvZZw=
+github.com/lib/pq v1.10.7/go.mod h1:AlVN5x4E4T544tWzH6hKfbfQvm3HdbOxrmggDNAPY9o=
github.com/lightstep/lightstep-tracer-common/golang/gogo v0.0.0-20190605223551-bc2310a04743/go.mod h1:qklhhLq1aX+mtWk9cPHPzaBjWImj5ULL6C7HFJtXQMM=
github.com/lightstep/lightstep-tracer-go v0.18.1/go.mod h1:jlF1pusYV4pidLvZ+XD0UBX0ZE6WURAspgAczcDHrL4=
github.com/lunixbochs/struc v0.0.0-20200707160740-784aaebc1d40 h1:EnfXoSqDfSNJv0VBNqY/88RNnhSGYkrHaO0mmFGbVsc=
diff --git a/vendor/github.com/lib/pq/.travis.sh b/vendor/github.com/lib/pq/.travis.sh
deleted file mode 100644
index ebf447030be0b69b51077358ca143102d33bf34f..0000000000000000000000000000000000000000
--- a/vendor/github.com/lib/pq/.travis.sh
+++ /dev/null
@@ -1,73 +0,0 @@
-#!/bin/bash
-
-set -eu
-
-client_configure() {
- sudo chmod 600 $PQSSLCERTTEST_PATH/postgresql.key
-}
-
-pgdg_repository() {
- local sourcelist='sources.list.d/postgresql.list'
-
- curl -sS 'https://www.postgresql.org/media/keys/ACCC4CF8.asc' | sudo apt-key add -
- echo deb http://apt.postgresql.org/pub/repos/apt/ $(lsb_release -cs)-pgdg main $PGVERSION | sudo tee "/etc/apt/$sourcelist"
- sudo apt-get -o Dir::Etc::sourcelist="$sourcelist" -o Dir::Etc::sourceparts='-' -o APT::Get::List-Cleanup='0' update
-}
-
-postgresql_configure() {
- sudo tee /etc/postgresql/$PGVERSION/main/pg_hba.conf > /dev/null <<-config
- local all all trust
- hostnossl all pqgossltest 127.0.0.1/32 reject
- hostnossl all pqgosslcert 127.0.0.1/32 reject
- hostssl all pqgossltest 127.0.0.1/32 trust
- hostssl all pqgosslcert 127.0.0.1/32 cert
- host all all 127.0.0.1/32 trust
- hostnossl all pqgossltest ::1/128 reject
- hostnossl all pqgosslcert ::1/128 reject
- hostssl all pqgossltest ::1/128 trust
- hostssl all pqgosslcert ::1/128 cert
- host all all ::1/128 trust
- config
-
- xargs sudo install -o postgres -g postgres -m 600 -t /var/lib/postgresql/$PGVERSION/main/ <<-certificates
- certs/root.crt
- certs/server.crt
- certs/server.key
- certificates
-
- sort -VCu <<-versions ||
- $PGVERSION
- 9.2
- versions
- sudo tee -a /etc/postgresql/$PGVERSION/main/postgresql.conf > /dev/null <<-config
- ssl_ca_file = 'root.crt'
- ssl_cert_file = 'server.crt'
- ssl_key_file = 'server.key'
- config
-
- echo 127.0.0.1 postgres | sudo tee -a /etc/hosts > /dev/null
-
- sudo service postgresql restart
-}
-
-postgresql_install() {
- xargs sudo apt-get -y -o Dpkg::Options::='--force-confdef' -o Dpkg::Options::='--force-confnew' install <<-packages
- postgresql-$PGVERSION
- postgresql-server-dev-$PGVERSION
- postgresql-contrib-$PGVERSION
- packages
-}
-
-postgresql_uninstall() {
- sudo service postgresql stop
- xargs sudo apt-get -y --purge remove <<-packages
- libpq-dev
- libpq5
- postgresql
- postgresql-client-common
- postgresql-common
- packages
- sudo rm -rf /var/lib/postgresql
-}
-
-$1
diff --git a/vendor/github.com/lib/pq/.travis.yml b/vendor/github.com/lib/pq/.travis.yml
deleted file mode 100644
index f378207f2049ceb6f5252daaa2e8da0d49342d42..0000000000000000000000000000000000000000
--- a/vendor/github.com/lib/pq/.travis.yml
+++ /dev/null
@@ -1,45 +0,0 @@
-language: go
-
-go:
- - 1.14.x
- - 1.15.x
- - master
-
-sudo: true
-
-env:
- global:
- - PGUSER=postgres
- - PQGOSSLTESTS=1
- - PQSSLCERTTEST_PATH=$PWD/certs
- - PGHOST=127.0.0.1
- - GODEBUG=x509ignoreCN=0
- matrix:
- - PGVERSION=10
- - PGVERSION=9.6
- - PGVERSION=9.5
- - PGVERSION=9.4
-
-before_install:
- - ./.travis.sh postgresql_uninstall
- - ./.travis.sh pgdg_repository
- - ./.travis.sh postgresql_install
- - ./.travis.sh postgresql_configure
- - ./.travis.sh client_configure
- - go get golang.org/x/tools/cmd/goimports
- - go get golang.org/x/lint/golint
- - GO111MODULE=on go get honnef.co/go/tools/cmd/staticcheck@2020.1.3
-
-before_script:
- - createdb pqgotest
- - createuser -DRS pqgossltest
- - createuser -DRS pqgosslcert
-
-script:
- - >
- goimports -d -e $(find -name '*.go') | awk '{ print } END { exit NR == 0 ? 0 : 1 }'
- - go vet ./...
- - staticcheck -go 1.13 ./...
- - golint ./...
- - PQTEST_BINARY_PARAMETERS=no go test -race -v ./...
- - PQTEST_BINARY_PARAMETERS=yes go test -race -v ./...
diff --git a/vendor/github.com/lib/pq/README.md b/vendor/github.com/lib/pq/README.md
index c972a86a5795a8010193b44406a3b3b77666ed5c..126ee5d35d186f7727987e512d80bdc7796ed485 100644
--- a/vendor/github.com/lib/pq/README.md
+++ b/vendor/github.com/lib/pq/README.md
@@ -27,4 +27,10 @@
## Status
-This package is effectively in maintenance mode and is not actively developed. Small patches and features are only rarely reviewed and merged. We recommend using [pgx](https://github.com/jackc/pgx) which is actively maintained.
+This package is currently in maintenance mode, which means:
+1. It generally does not accept new features.
+2. It does accept bug fixes and version compatability changes provided by the community.
+3. Maintainers usually do not resolve reported issues.
+4. Community members are encouraged to help each other with reported issues.
+
+For users that require new features or reliable resolution of reported bugs, we recommend using [pgx](https://github.com/jackc/pgx) which is under active development.
diff --git a/vendor/github.com/lib/pq/array.go b/vendor/github.com/lib/pq/array.go
index 7806a31f3bbd948bdf95474fb230b7c7ef30e613..39c8f7e2e0322ed7890302dbaa509bc0691103d2 100644
--- a/vendor/github.com/lib/pq/array.go
+++ b/vendor/github.com/lib/pq/array.go
@@ -587,8 +587,8 @@ func (a *Int32Array) scanBytes(src []byte) error {
} else {
b := make(Int32Array, len(elems))
for i, v := range elems {
- var x int
- if x, err = strconv.Atoi(string(v)); err != nil {
+ x, err := strconv.ParseInt(string(v), 10, 32)
+ if err != nil {
return fmt.Errorf("pq: parsing array element index %d: %v", i, err)
}
b[i] = int32(x)
diff --git a/vendor/github.com/lib/pq/conn.go b/vendor/github.com/lib/pq/conn.go
index b09a170474a191e37dcb3ab31b8481e652852d7f..e70b386ff09e0c0572f1e9365372ee24700d24f3 100644
--- a/vendor/github.com/lib/pq/conn.go
+++ b/vendor/github.com/lib/pq/conn.go
@@ -18,7 +18,7 @@ import (
"path/filepath"
"strconv"
"strings"
- "sync/atomic"
+ "sync"
"time"
"unicode"
@@ -31,8 +31,10 @@ var (
ErrNotSupported = errors.New("pq: Unsupported command")
ErrInFailedTransaction = errors.New("pq: Could not complete operation in a failed transaction")
ErrSSLNotSupported = errors.New("pq: SSL is not enabled on the server")
- ErrSSLKeyHasWorldPermissions = errors.New("pq: Private key file has group or world access. Permissions should be u=rw (0600) or less")
- ErrCouldNotDetectUsername = errors.New("pq: Could not detect default username. Please provide one explicitly")
+ ErrSSLKeyUnknownOwnership = errors.New("pq: Could not get owner information for private key, may not be properly protected")
+ ErrSSLKeyHasWorldPermissions = errors.New("pq: Private key has world access. Permissions should be u=rw,g=r (0640) if owned by root, or u=rw (0600), or less")
+
+ ErrCouldNotDetectUsername = errors.New("pq: Could not detect default username. Please provide one explicitly")
errUnexpectedReady = errors.New("unexpected ReadyForQuery")
errNoRowsAffected = errors.New("no RowsAffected available after the empty statement")
@@ -140,9 +142,10 @@ type conn struct {
saveMessageType byte
saveMessageBuffer []byte
- // If true, this connection is bad and all public-facing functions should
- // return ErrBadConn.
- bad *atomic.Value
+ // If an error is set, this connection is bad and all public-facing
+ // functions should return the appropriate error by calling get()
+ // (ErrBadConn) or getForNext().
+ err syncErr
// If set, this connection should never use the binary format when
// receiving query results from prepared statements. Only provided for
@@ -166,6 +169,40 @@ type conn struct {
gss GSS
}
+type syncErr struct {
+ err error
+ sync.Mutex
+}
+
+// Return ErrBadConn if connection is bad.
+func (e *syncErr) get() error {
+ e.Lock()
+ defer e.Unlock()
+ if e.err != nil {
+ return driver.ErrBadConn
+ }
+ return nil
+}
+
+// Return the error set on the connection. Currently only used by rows.Next.
+func (e *syncErr) getForNext() error {
+ e.Lock()
+ defer e.Unlock()
+ return e.err
+}
+
+// Set error, only if it isn't set yet.
+func (e *syncErr) set(err error) {
+ if err == nil {
+ panic("attempt to set nil err")
+ }
+ e.Lock()
+ defer e.Unlock()
+ if e.err == nil {
+ e.err = err
+ }
+}
+
// Handle driver-side settings in parsed connection string.
func (cn *conn) handleDriverSettings(o values) (err error) {
boolSetting := func(key string, val *bool) error {
@@ -287,7 +324,7 @@ func DialOpen(d Dialer, dsn string) (_ driver.Conn, err error) {
if err != nil {
return nil, err
}
- c.dialer = d
+ c.Dialer(d)
return c.open(context.Background())
}
@@ -306,12 +343,9 @@ func (c *Connector) open(ctx context.Context) (cn *conn, err error) {
o[k] = v
}
- bad := &atomic.Value{}
- bad.Store(false)
cn = &conn{
opts: o,
dialer: c.dialer,
- bad: bad,
}
err = cn.handleDriverSettings(o)
if err != nil {
@@ -516,22 +550,9 @@ func (cn *conn) isInTransaction() bool {
cn.txnStatus == txnStatusInFailedTransaction
}
-func (cn *conn) setBad() {
- if cn.bad != nil {
- cn.bad.Store(true)
- }
-}
-
-func (cn *conn) getBad() bool {
- if cn.bad != nil {
- return cn.bad.Load().(bool)
- }
- return false
-}
-
func (cn *conn) checkIsInTransaction(intxn bool) {
if cn.isInTransaction() != intxn {
- cn.setBad()
+ cn.err.set(driver.ErrBadConn)
errorf("unexpected transaction status %v", cn.txnStatus)
}
}
@@ -541,8 +562,8 @@ func (cn *conn) Begin() (_ driver.Tx, err error) {
}
func (cn *conn) begin(mode string) (_ driver.Tx, err error) {
- if cn.getBad() {
- return nil, driver.ErrBadConn
+ if err := cn.err.get(); err != nil {
+ return nil, err
}
defer cn.errRecover(&err)
@@ -552,11 +573,11 @@ func (cn *conn) begin(mode string) (_ driver.Tx, err error) {
return nil, err
}
if commandTag != "BEGIN" {
- cn.setBad()
+ cn.err.set(driver.ErrBadConn)
return nil, fmt.Errorf("unexpected command tag %s", commandTag)
}
if cn.txnStatus != txnStatusIdleInTransaction {
- cn.setBad()
+ cn.err.set(driver.ErrBadConn)
return nil, fmt.Errorf("unexpected transaction status %v", cn.txnStatus)
}
return cn, nil
@@ -570,8 +591,8 @@ func (cn *conn) closeTxn() {
func (cn *conn) Commit() (err error) {
defer cn.closeTxn()
- if cn.getBad() {
- return driver.ErrBadConn
+ if err := cn.err.get(); err != nil {
+ return err
}
defer cn.errRecover(&err)
@@ -592,12 +613,12 @@ func (cn *conn) Commit() (err error) {
_, commandTag, err := cn.simpleExec("COMMIT")
if err != nil {
if cn.isInTransaction() {
- cn.setBad()
+ cn.err.set(driver.ErrBadConn)
}
return err
}
if commandTag != "COMMIT" {
- cn.setBad()
+ cn.err.set(driver.ErrBadConn)
return fmt.Errorf("unexpected command tag %s", commandTag)
}
cn.checkIsInTransaction(false)
@@ -606,8 +627,8 @@ func (cn *conn) Commit() (err error) {
func (cn *conn) Rollback() (err error) {
defer cn.closeTxn()
- if cn.getBad() {
- return driver.ErrBadConn
+ if err := cn.err.get(); err != nil {
+ return err
}
defer cn.errRecover(&err)
return cn.rollback()
@@ -618,7 +639,7 @@ func (cn *conn) rollback() (err error) {
_, commandTag, err := cn.simpleExec("ROLLBACK")
if err != nil {
if cn.isInTransaction() {
- cn.setBad()
+ cn.err.set(driver.ErrBadConn)
}
return err
}
@@ -658,7 +679,7 @@ func (cn *conn) simpleExec(q string) (res driver.Result, commandTag string, err
case 'T', 'D':
// ignore any results
default:
- cn.setBad()
+ cn.err.set(driver.ErrBadConn)
errorf("unknown response for simple query: %q", t)
}
}
@@ -680,7 +701,7 @@ func (cn *conn) simpleQuery(q string) (res *rows, err error) {
// the user can close, though, to avoid connections from being
// leaked. A "rows" with done=true works fine for that purpose.
if err != nil {
- cn.setBad()
+ cn.err.set(driver.ErrBadConn)
errorf("unexpected message %q in simple query execution", t)
}
if res == nil {
@@ -707,7 +728,7 @@ func (cn *conn) simpleQuery(q string) (res *rows, err error) {
err = parseError(r)
case 'D':
if res == nil {
- cn.setBad()
+ cn.err.set(driver.ErrBadConn)
errorf("unexpected DataRow in simple query execution")
}
// the query didn't fail; kick off to Next
@@ -722,7 +743,7 @@ func (cn *conn) simpleQuery(q string) (res *rows, err error) {
// To work around a bug in QueryRow in Go 1.2 and earlier, wait
// until the first DataRow has been received.
default:
- cn.setBad()
+ cn.err.set(driver.ErrBadConn)
errorf("unknown response for simple query: %q", t)
}
}
@@ -815,8 +836,8 @@ func (cn *conn) prepareTo(q, stmtName string) *stmt {
}
func (cn *conn) Prepare(q string) (_ driver.Stmt, err error) {
- if cn.getBad() {
- return nil, driver.ErrBadConn
+ if err := cn.err.get(); err != nil {
+ return nil, err
}
defer cn.errRecover(&err)
@@ -854,8 +875,8 @@ func (cn *conn) Query(query string, args []driver.Value) (driver.Rows, error) {
}
func (cn *conn) query(query string, args []driver.Value) (_ *rows, err error) {
- if cn.getBad() {
- return nil, driver.ErrBadConn
+ if err := cn.err.get(); err != nil {
+ return nil, err
}
if cn.inCopy {
return nil, errCopyInProgress
@@ -888,8 +909,8 @@ func (cn *conn) query(query string, args []driver.Value) (_ *rows, err error) {
// Implement the optional "Execer" interface for one-shot queries
func (cn *conn) Exec(query string, args []driver.Value) (res driver.Result, err error) {
- if cn.getBad() {
- return nil, driver.ErrBadConn
+ if err := cn.err.get(); err != nil {
+ return nil, err
}
defer cn.errRecover(&err)
@@ -960,7 +981,7 @@ func (cn *conn) sendSimpleMessage(typ byte) (err error) {
// the message yourself.
func (cn *conn) saveMessage(typ byte, buf *readBuf) {
if cn.saveMessageType != 0 {
- cn.setBad()
+ cn.err.set(driver.ErrBadConn)
errorf("unexpected saveMessageType %d", cn.saveMessageType)
}
cn.saveMessageType = typ
@@ -1106,7 +1127,7 @@ func isDriverSetting(key string) bool {
return true
case "password":
return true
- case "sslmode", "sslcert", "sslkey", "sslrootcert", "sslinline":
+ case "sslmode", "sslcert", "sslkey", "sslrootcert", "sslinline", "sslsni":
return true
case "fallback_application_name":
return true
@@ -1330,8 +1351,8 @@ func (st *stmt) Close() (err error) {
if st.closed {
return nil
}
- if st.cn.getBad() {
- return driver.ErrBadConn
+ if err := st.cn.err.get(); err != nil {
+ return err
}
defer st.cn.errRecover(&err)
@@ -1344,14 +1365,14 @@ func (st *stmt) Close() (err error) {
t, _ := st.cn.recv1()
if t != '3' {
- st.cn.setBad()
+ st.cn.err.set(driver.ErrBadConn)
errorf("unexpected close response: %q", t)
}
st.closed = true
t, r := st.cn.recv1()
if t != 'Z' {
- st.cn.setBad()
+ st.cn.err.set(driver.ErrBadConn)
errorf("expected ready for query, but got: %q", t)
}
st.cn.processReadyForQuery(r)
@@ -1360,8 +1381,12 @@ func (st *stmt) Close() (err error) {
}
func (st *stmt) Query(v []driver.Value) (r driver.Rows, err error) {
- if st.cn.getBad() {
- return nil, driver.ErrBadConn
+ return st.query(v)
+}
+
+func (st *stmt) query(v []driver.Value) (r *rows, err error) {
+ if err := st.cn.err.get(); err != nil {
+ return nil, err
}
defer st.cn.errRecover(&err)
@@ -1373,8 +1398,8 @@ func (st *stmt) Query(v []driver.Value) (r driver.Rows, err error) {
}
func (st *stmt) Exec(v []driver.Value) (res driver.Result, err error) {
- if st.cn.getBad() {
- return nil, driver.ErrBadConn
+ if err := st.cn.err.get(); err != nil {
+ return nil, err
}
defer st.cn.errRecover(&err)
@@ -1460,7 +1485,7 @@ func (cn *conn) parseComplete(commandTag string) (driver.Result, string) {
if affectedRows == nil && strings.HasPrefix(commandTag, "INSERT ") {
parts := strings.Split(commandTag, " ")
if len(parts) != 3 {
- cn.setBad()
+ cn.err.set(driver.ErrBadConn)
errorf("unexpected INSERT command tag %s", commandTag)
}
affectedRows = &parts[len(parts)-1]
@@ -1472,7 +1497,7 @@ func (cn *conn) parseComplete(commandTag string) (driver.Result, string) {
}
n, err := strconv.ParseInt(*affectedRows, 10, 64)
if err != nil {
- cn.setBad()
+ cn.err.set(driver.ErrBadConn)
errorf("could not parse commandTag: %s", err)
}
return driver.RowsAffected(n), commandTag
@@ -1539,8 +1564,8 @@ func (rs *rows) Next(dest []driver.Value) (err error) {
}
conn := rs.cn
- if conn.getBad() {
- return driver.ErrBadConn
+ if err := conn.err.getForNext(); err != nil {
+ return err
}
defer conn.errRecover(&err)
@@ -1564,7 +1589,7 @@ func (rs *rows) Next(dest []driver.Value) (err error) {
case 'D':
n := rs.rb.int16()
if err != nil {
- conn.setBad()
+ conn.err.set(driver.ErrBadConn)
errorf("unexpected DataRow after error %s", err)
}
if n < len(dest) {
@@ -1758,7 +1783,7 @@ func (cn *conn) readReadyForQuery() {
cn.processReadyForQuery(r)
return
default:
- cn.setBad()
+ cn.err.set(driver.ErrBadConn)
errorf("unexpected message %q; expected ReadyForQuery", t)
}
}
@@ -1778,7 +1803,7 @@ func (cn *conn) readParseResponse() {
cn.readReadyForQuery()
panic(err)
default:
- cn.setBad()
+ cn.err.set(driver.ErrBadConn)
errorf("unexpected Parse response %q", t)
}
}
@@ -1803,7 +1828,7 @@ func (cn *conn) readStatementDescribeResponse() (paramTyps []oid.Oid, colNames [
cn.readReadyForQuery()
panic(err)
default:
- cn.setBad()
+ cn.err.set(driver.ErrBadConn)
errorf("unexpected Describe statement response %q", t)
}
}
@@ -1821,7 +1846,7 @@ func (cn *conn) readPortalDescribeResponse() rowsHeader {
cn.readReadyForQuery()
panic(err)
default:
- cn.setBad()
+ cn.err.set(driver.ErrBadConn)
errorf("unexpected Describe response %q", t)
}
panic("not reached")
@@ -1837,7 +1862,7 @@ func (cn *conn) readBindResponse() {
cn.readReadyForQuery()
panic(err)
default:
- cn.setBad()
+ cn.err.set(driver.ErrBadConn)
errorf("unexpected Bind response %q", t)
}
}
@@ -1864,7 +1889,7 @@ func (cn *conn) postExecuteWorkaround() {
cn.saveMessage(t, r)
return
default:
- cn.setBad()
+ cn.err.set(driver.ErrBadConn)
errorf("unexpected message during extended query execution: %q", t)
}
}
@@ -1877,7 +1902,7 @@ func (cn *conn) readExecuteResponse(protocolState string) (res driver.Result, co
switch t {
case 'C':
if err != nil {
- cn.setBad()
+ cn.err.set(driver.ErrBadConn)
errorf("unexpected CommandComplete after error %s", err)
}
res, commandTag = cn.parseComplete(r.string())
@@ -1891,7 +1916,7 @@ func (cn *conn) readExecuteResponse(protocolState string) (res driver.Result, co
err = parseError(r)
case 'T', 'D', 'I':
if err != nil {
- cn.setBad()
+ cn.err.set(driver.ErrBadConn)
errorf("unexpected %q after error %s", t, err)
}
if t == 'I' {
@@ -1899,7 +1924,7 @@ func (cn *conn) readExecuteResponse(protocolState string) (res driver.Result, co
}
// ignore any results
default:
- cn.setBad()
+ cn.err.set(driver.ErrBadConn)
errorf("unknown %s response: %q", protocolState, t)
}
}
@@ -1995,6 +2020,8 @@ func parseEnviron(env []string) (out map[string]string) {
accrue("sslkey")
case "PGSSLROOTCERT":
accrue("sslrootcert")
+ case "PGSSLSNI":
+ accrue("sslsni")
case "PGREQUIRESSL", "PGSSLCRL":
unsupported()
case "PGREQUIREPEER":
diff --git a/vendor/github.com/lib/pq/conn_go18.go b/vendor/github.com/lib/pq/conn_go18.go
index 2b9a9599e35c023a6cac2f9a87120bb90d327f9b..63d4ca6aaa0513eeb9f0c6600b888a667aee7e4c 100644
--- a/vendor/github.com/lib/pq/conn_go18.go
+++ b/vendor/github.com/lib/pq/conn_go18.go
@@ -7,10 +7,13 @@ import (
"fmt"
"io"
"io/ioutil"
- "sync/atomic"
"time"
)
+const (
+ watchCancelDialContextTimeout = time.Second * 10
+)
+
// Implement the "QueryerContext" interface
func (cn *conn) QueryContext(ctx context.Context, query string, args []driver.NamedValue) (driver.Rows, error) {
list := make([]driver.Value, len(args))
@@ -43,6 +46,14 @@ func (cn *conn) ExecContext(ctx context.Context, query string, args []driver.Nam
return cn.Exec(query, list)
}
+// Implement the "ConnPrepareContext" interface
+func (cn *conn) PrepareContext(ctx context.Context, query string) (driver.Stmt, error) {
+ if finish := cn.watchCancel(ctx); finish != nil {
+ defer finish()
+ }
+ return cn.Prepare(query)
+}
+
// Implement the "ConnBeginTx" interface
func (cn *conn) BeginTx(ctx context.Context, opts driver.TxOptions) (driver.Tx, error) {
var mode string
@@ -103,13 +114,13 @@ func (cn *conn) watchCancel(ctx context.Context) func() {
}
// Set the connection state to bad so it does not get reused.
- cn.setBad()
+ cn.err.set(ctx.Err())
// At this point the function level context is canceled,
// so it must not be used for the additional network
// request to cancel the query.
// Create a new context to pass into the dial.
- ctxCancel, cancel := context.WithTimeout(context.Background(), time.Second*10)
+ ctxCancel, cancel := context.WithTimeout(context.Background(), watchCancelDialContextTimeout)
defer cancel()
_ = cn.cancel(ctxCancel)
@@ -119,7 +130,7 @@ func (cn *conn) watchCancel(ctx context.Context) func() {
return func() {
select {
case <-finished:
- cn.setBad()
+ cn.err.set(ctx.Err())
cn.Close()
case finished <- struct{}{}:
}
@@ -145,11 +156,8 @@ func (cn *conn) cancel(ctx context.Context) error {
defer c.Close()
{
- bad := &atomic.Value{}
- bad.Store(false)
can := conn{
- c: c,
- bad: bad,
+ c: c,
}
err = can.ssl(o)
if err != nil {
@@ -172,3 +180,68 @@ func (cn *conn) cancel(ctx context.Context) error {
return err
}
}
+
+// Implement the "StmtQueryContext" interface
+func (st *stmt) QueryContext(ctx context.Context, args []driver.NamedValue) (driver.Rows, error) {
+ list := make([]driver.Value, len(args))
+ for i, nv := range args {
+ list[i] = nv.Value
+ }
+ finish := st.watchCancel(ctx)
+ r, err := st.query(list)
+ if err != nil {
+ if finish != nil {
+ finish()
+ }
+ return nil, err
+ }
+ r.finish = finish
+ return r, nil
+}
+
+// Implement the "StmtExecContext" interface
+func (st *stmt) ExecContext(ctx context.Context, args []driver.NamedValue) (driver.Result, error) {
+ list := make([]driver.Value, len(args))
+ for i, nv := range args {
+ list[i] = nv.Value
+ }
+
+ if finish := st.watchCancel(ctx); finish != nil {
+ defer finish()
+ }
+
+ return st.Exec(list)
+}
+
+// watchCancel is implemented on stmt in order to not mark the parent conn as bad
+func (st *stmt) watchCancel(ctx context.Context) func() {
+ if done := ctx.Done(); done != nil {
+ finished := make(chan struct{})
+ go func() {
+ select {
+ case <-done:
+ // At this point the function level context is canceled,
+ // so it must not be used for the additional network
+ // request to cancel the query.
+ // Create a new context to pass into the dial.
+ ctxCancel, cancel := context.WithTimeout(context.Background(), watchCancelDialContextTimeout)
+ defer cancel()
+
+ _ = st.cancel(ctxCancel)
+ finished <- struct{}{}
+ case <-finished:
+ }
+ }()
+ return func() {
+ select {
+ case <-finished:
+ case finished <- struct{}{}:
+ }
+ }
+ }
+ return nil
+}
+
+func (st *stmt) cancel(ctx context.Context) error {
+ return st.cn.cancel(ctx)
+}
diff --git a/vendor/github.com/lib/pq/connector.go b/vendor/github.com/lib/pq/connector.go
index d7d47261569a43299b590ba213f55ac5fd28023f..1145e12257ada53c57ed29453331da034739591f 100644
--- a/vendor/github.com/lib/pq/connector.go
+++ b/vendor/github.com/lib/pq/connector.go
@@ -27,6 +27,11 @@ func (c *Connector) Connect(ctx context.Context) (driver.Conn, error) {
return c.open(ctx)
}
+// Dialer allows change the dialer used to open connections.
+func (c *Connector) Dialer(dialer Dialer) {
+ c.dialer = dialer
+}
+
// Driver returns the underlying driver of this Connector.
func (c *Connector) Driver() driver.Driver {
return &Driver{}
diff --git a/vendor/github.com/lib/pq/copy.go b/vendor/github.com/lib/pq/copy.go
index bb3cbd7b996f531b19fbf7f1cc3976071e9c90ae..2f5c1ec8a6c464834dfa3fae688da02c2cd9a5bc 100644
--- a/vendor/github.com/lib/pq/copy.go
+++ b/vendor/github.com/lib/pq/copy.go
@@ -1,6 +1,7 @@
package pq
import (
+ "context"
"database/sql/driver"
"encoding/binary"
"errors"
@@ -49,12 +50,14 @@ type copyin struct {
buffer []byte
rowData chan []byte
done chan bool
- driver.Result
closed bool
- sync.Mutex // guards err
- err error
+ mu struct {
+ sync.Mutex
+ err error
+ driver.Result
+ }
}
const ciBufferSize = 64 * 1024
@@ -98,13 +101,13 @@ awaitCopyInResponse:
err = parseError(r)
case 'Z':
if err == nil {
- ci.setBad()
+ ci.setBad(driver.ErrBadConn)
errorf("unexpected ReadyForQuery in response to COPY")
}
cn.processReadyForQuery(r)
return nil, err
default:
- ci.setBad()
+ ci.setBad(driver.ErrBadConn)
errorf("unknown response for copy query: %q", t)
}
}
@@ -123,7 +126,7 @@ awaitCopyInResponse:
cn.processReadyForQuery(r)
return nil, err
default:
- ci.setBad()
+ ci.setBad(driver.ErrBadConn)
errorf("unknown response for CopyFail: %q", t)
}
}
@@ -144,7 +147,7 @@ func (ci *copyin) resploop() {
var r readBuf
t, err := ci.cn.recvMessage(&r)
if err != nil {
- ci.setBad()
+ ci.setBad(driver.ErrBadConn)
ci.setError(err)
ci.done <- true
return
@@ -166,7 +169,7 @@ func (ci *copyin) resploop() {
err := parseError(&r)
ci.setError(err)
default:
- ci.setBad()
+ ci.setBad(driver.ErrBadConn)
ci.setError(fmt.Errorf("unknown response during CopyIn: %q", t))
ci.done <- true
return
@@ -174,46 +177,41 @@ func (ci *copyin) resploop() {
}
}
-func (ci *copyin) setBad() {
- ci.Lock()
- ci.cn.setBad()
- ci.Unlock()
+func (ci *copyin) setBad(err error) {
+ ci.cn.err.set(err)
}
-func (ci *copyin) isBad() bool {
- ci.Lock()
- b := ci.cn.getBad()
- ci.Unlock()
- return b
+func (ci *copyin) getBad() error {
+ return ci.cn.err.get()
}
-func (ci *copyin) isErrorSet() bool {
- ci.Lock()
- isSet := (ci.err != nil)
- ci.Unlock()
- return isSet
+func (ci *copyin) err() error {
+ ci.mu.Lock()
+ err := ci.mu.err
+ ci.mu.Unlock()
+ return err
}
// setError() sets ci.err if one has not been set already. Caller must not be
// holding ci.Mutex.
func (ci *copyin) setError(err error) {
- ci.Lock()
- if ci.err == nil {
- ci.err = err
+ ci.mu.Lock()
+ if ci.mu.err == nil {
+ ci.mu.err = err
}
- ci.Unlock()
+ ci.mu.Unlock()
}
func (ci *copyin) setResult(result driver.Result) {
- ci.Lock()
- ci.Result = result
- ci.Unlock()
+ ci.mu.Lock()
+ ci.mu.Result = result
+ ci.mu.Unlock()
}
func (ci *copyin) getResult() driver.Result {
- ci.Lock()
- result := ci.Result
- ci.Unlock()
+ ci.mu.Lock()
+ result := ci.mu.Result
+ ci.mu.Unlock()
if result == nil {
return driver.RowsAffected(0)
}
@@ -240,13 +238,13 @@ func (ci *copyin) Exec(v []driver.Value) (r driver.Result, err error) {
return nil, errCopyInClosed
}
- if ci.isBad() {
- return nil, driver.ErrBadConn
+ if err := ci.getBad(); err != nil {
+ return nil, err
}
defer ci.cn.errRecover(&err)
- if ci.isErrorSet() {
- return nil, ci.err
+ if err := ci.err(); err != nil {
+ return nil, err
}
if len(v) == 0 {
@@ -276,14 +274,51 @@ func (ci *copyin) Exec(v []driver.Value) (r driver.Result, err error) {
return driver.RowsAffected(0), nil
}
+// CopyData inserts a raw string into the COPY stream. The insert is
+// asynchronous and CopyData can return errors from previous CopyData calls to
+// the same COPY stmt.
+//
+// You need to call Exec(nil) to sync the COPY stream and to get any
+// errors from pending data, since Stmt.Close() doesn't return errors
+// to the user.
+func (ci *copyin) CopyData(ctx context.Context, line string) (r driver.Result, err error) {
+ if ci.closed {
+ return nil, errCopyInClosed
+ }
+
+ if finish := ci.cn.watchCancel(ctx); finish != nil {
+ defer finish()
+ }
+
+ if err := ci.getBad(); err != nil {
+ return nil, err
+ }
+ defer ci.cn.errRecover(&err)
+
+ if err := ci.err(); err != nil {
+ return nil, err
+ }
+
+ ci.buffer = append(ci.buffer, []byte(line)...)
+ ci.buffer = append(ci.buffer, '\n')
+
+ if len(ci.buffer) > ciBufferFlushSize {
+ ci.flush(ci.buffer)
+ // reset buffer, keep bytes for message identifier and length
+ ci.buffer = ci.buffer[:5]
+ }
+
+ return driver.RowsAffected(0), nil
+}
+
func (ci *copyin) Close() (err error) {
if ci.closed { // Don't do anything, we're already closed
return nil
}
ci.closed = true
- if ci.isBad() {
- return driver.ErrBadConn
+ if err := ci.getBad(); err != nil {
+ return err
}
defer ci.cn.errRecover(&err)
@@ -299,8 +334,7 @@ func (ci *copyin) Close() (err error) {
<-ci.done
ci.cn.inCopy = false
- if ci.isErrorSet() {
- err = ci.err
+ if err := ci.err(); err != nil {
return err
}
return nil
diff --git a/vendor/github.com/lib/pq/encode.go b/vendor/github.com/lib/pq/encode.go
index c4dafe2705a391dec1538ba8d36f973a36824968..bffe6096aff653bb552d49249303abd802b4da00 100644
--- a/vendor/github.com/lib/pq/encode.go
+++ b/vendor/github.com/lib/pq/encode.go
@@ -200,11 +200,17 @@ func appendEscapedText(buf []byte, text string) []byte {
func mustParse(f string, typ oid.Oid, s []byte) time.Time {
str := string(s)
- // check for a 30-minute-offset timezone
- if (typ == oid.T_timestamptz || typ == oid.T_timetz) &&
- str[len(str)-3] == ':' {
- f += ":00"
+ // Check for a minute and second offset in the timezone.
+ if typ == oid.T_timestamptz || typ == oid.T_timetz {
+ for i := 3; i <= 6; i += 3 {
+ if str[len(str)-i] == ':' {
+ f += ":00"
+ continue
+ }
+ break
+ }
}
+
// Special case for 24:00 time.
// Unfortunately, golang does not parse 24:00 as a proper time.
// In this case, we want to try "round to the next day", to differentiate.
@@ -416,7 +422,7 @@ func ParseTimestamp(currentLocation *time.Location, str string) (time.Time, erro
if remainderIdx < len(str) && str[remainderIdx] == '.' {
fracStart := remainderIdx + 1
- fracOff := strings.IndexAny(str[fracStart:], "-+ ")
+ fracOff := strings.IndexAny(str[fracStart:], "-+Z ")
if fracOff < 0 {
fracOff = len(str) - fracStart
}
@@ -426,7 +432,7 @@ func ParseTimestamp(currentLocation *time.Location, str string) (time.Time, erro
remainderIdx += fracOff + 1
}
if tzStart := remainderIdx; tzStart < len(str) && (str[tzStart] == '-' || str[tzStart] == '+') {
- // time zone separator is always '-' or '+' (UTC is +00)
+ // time zone separator is always '-' or '+' or 'Z' (UTC is +00)
var tzSign int
switch c := str[tzStart]; c {
case '-':
@@ -448,7 +454,11 @@ func ParseTimestamp(currentLocation *time.Location, str string) (time.Time, erro
remainderIdx += 3
}
tzOff = tzSign * ((tzHours * 60 * 60) + (tzMin * 60) + tzSec)
+ } else if tzStart < len(str) && str[tzStart] == 'Z' {
+ // time zone Z separator indicates UTC is +00
+ remainderIdx += 1
}
+
var isoYear int
if isBC {
@@ -553,7 +563,7 @@ func parseBytea(s []byte) (result []byte, err error) {
if len(s) < 4 {
return nil, fmt.Errorf("invalid bytea sequence %v", s)
}
- r, err := strconv.ParseInt(string(s[1:4]), 8, 9)
+ r, err := strconv.ParseUint(string(s[1:4]), 8, 8)
if err != nil {
return nil, fmt.Errorf("could not parse bytea value: %s", err.Error())
}
diff --git a/vendor/github.com/lib/pq/error.go b/vendor/github.com/lib/pq/error.go
index c19c349f13d8f511ed67aedbaf4bfcd49546d9d7..f67c5a5fa641d17ac942915bcd8fb817b9ee94b8 100644
--- a/vendor/github.com/lib/pq/error.go
+++ b/vendor/github.com/lib/pq/error.go
@@ -402,6 +402,11 @@ func (err *Error) Fatal() bool {
return err.Severity == Efatal
}
+// SQLState returns the SQLState of the error.
+func (err *Error) SQLState() string {
+ return string(err.Code)
+}
+
// Get implements the legacy PGError interface. New code should use the fields
// of the Error struct directly.
func (err *Error) Get(k byte) (v string) {
@@ -444,7 +449,7 @@ func (err *Error) Get(k byte) (v string) {
return ""
}
-func (err Error) Error() string {
+func (err *Error) Error() string {
return "pq: " + err.Message
}
@@ -484,7 +489,7 @@ func (cn *conn) errRecover(err *error) {
case nil:
// Do nothing
case runtime.Error:
- cn.setBad()
+ cn.err.set(driver.ErrBadConn)
panic(v)
case *Error:
if v.Fatal() {
@@ -493,26 +498,26 @@ func (cn *conn) errRecover(err *error) {
*err = v
}
case *net.OpError:
- cn.setBad()
+ cn.err.set(driver.ErrBadConn)
*err = v
case *safeRetryError:
- cn.setBad()
+ cn.err.set(driver.ErrBadConn)
*err = driver.ErrBadConn
case error:
- if v == io.EOF || v.(error).Error() == "remote error: handshake failure" {
+ if v == io.EOF || v.Error() == "remote error: handshake failure" {
*err = driver.ErrBadConn
} else {
*err = v
}
default:
- cn.setBad()
+ cn.err.set(driver.ErrBadConn)
panic(fmt.Sprintf("unknown error: %#v", e))
}
// Any time we return ErrBadConn, we need to remember it since *Tx doesn't
// mark the connection bad in database/sql.
if *err == driver.ErrBadConn {
- cn.setBad()
+ cn.err.set(driver.ErrBadConn)
}
}
diff --git a/vendor/github.com/lib/pq/notice.go b/vendor/github.com/lib/pq/notice.go
index 01dd8c723ddb772bb04bfff58c7f59293a482c21..70ad122a7d6b80a372646e98996525bb4686e482 100644
--- a/vendor/github.com/lib/pq/notice.go
+++ b/vendor/github.com/lib/pq/notice.go
@@ -1,3 +1,4 @@
+//go:build go1.10
// +build go1.10
package pq
diff --git a/vendor/github.com/lib/pq/ssl.go b/vendor/github.com/lib/pq/ssl.go
index e5eb928954deb7ca16fd0013c44ffc91f6321d72..36b61ba45be25745b4233395ca92988b44266cd5 100644
--- a/vendor/github.com/lib/pq/ssl.go
+++ b/vendor/github.com/lib/pq/ssl.go
@@ -8,6 +8,7 @@ import (
"os"
"os/user"
"path/filepath"
+ "strings"
)
// ssl generates a function to upgrade a net.Conn based on the "sslmode" and
@@ -50,6 +51,16 @@ func ssl(o values) (func(net.Conn) (net.Conn, error), error) {
return nil, fmterrorf(`unsupported sslmode %q; only "require" (default), "verify-full", "verify-ca", and "disable" supported`, mode)
}
+ // Set Server Name Indication (SNI), if enabled by connection parameters.
+ // By default SNI is on, any value which is not starting with "1" disables
+ // SNI -- that is the same check vanilla libpq uses.
+ if sslsni := o["sslsni"]; sslsni == "" || strings.HasPrefix(sslsni, "1") {
+ // RFC 6066 asks to not set SNI if the host is a literal IP address (IPv4
+ // or IPv6). This check is coded already crypto.tls.hostnameInSNI, so
+ // just always set ServerName here and let crypto/tls do the filtering.
+ tlsConf.ServerName = o["host"]
+ }
+
err := sslClientCertificates(&tlsConf, o)
if err != nil {
return nil, err
diff --git a/vendor/github.com/lib/pq/ssl_permissions.go b/vendor/github.com/lib/pq/ssl_permissions.go
index 3b7c3a2a3190f0256a5ac3497f99c146e00c6d54..d587f102edb22a0ab287edcb7f79b25c319e3d4a 100644
--- a/vendor/github.com/lib/pq/ssl_permissions.go
+++ b/vendor/github.com/lib/pq/ssl_permissions.go
@@ -1,8 +1,30 @@
+//go:build !windows
// +build !windows
package pq
-import "os"
+import (
+ "errors"
+ "os"
+ "syscall"
+)
+
+const (
+ rootUserID = uint32(0)
+
+ // The maximum permissions that a private key file owned by a regular user
+ // is allowed to have. This translates to u=rw.
+ maxUserOwnedKeyPermissions os.FileMode = 0600
+
+ // The maximum permissions that a private key file owned by root is allowed
+ // to have. This translates to u=rw,g=r.
+ maxRootOwnedKeyPermissions os.FileMode = 0640
+)
+
+var (
+ errSSLKeyHasUnacceptableUserPermissions = errors.New("permissions for files not owned by root should be u=rw (0600) or less")
+ errSSLKeyHasUnacceptableRootPermissions = errors.New("permissions for root owned files should be u=rw,g=r (0640) or less")
+)
// sslKeyPermissions checks the permissions on user-supplied ssl key files.
// The key file should have very little access.
@@ -13,8 +35,59 @@ func sslKeyPermissions(sslkey string) error {
if err != nil {
return err
}
- if info.Mode().Perm()&0077 != 0 {
- return ErrSSLKeyHasWorldPermissions
+
+ err = hasCorrectPermissions(info)
+
+ // return ErrSSLKeyHasWorldPermissions for backwards compatability with
+ // existing code.
+ if err == errSSLKeyHasUnacceptableUserPermissions || err == errSSLKeyHasUnacceptableRootPermissions {
+ err = ErrSSLKeyHasWorldPermissions
}
- return nil
+ return err
+}
+
+// hasCorrectPermissions checks the file info (and the unix-specific stat_t
+// output) to verify that the permissions on the file are correct.
+//
+// If the file is owned by the same user the process is running as,
+// the file should only have 0600 (u=rw). If the file is owned by root,
+// and the group matches the group that the process is running in, the
+// permissions cannot be more than 0640 (u=rw,g=r). The file should
+// never have world permissions.
+//
+// Returns an error when the permission check fails.
+func hasCorrectPermissions(info os.FileInfo) error {
+ // if file's permission matches 0600, allow access.
+ userPermissionMask := (os.FileMode(0777) ^ maxUserOwnedKeyPermissions)
+
+ // regardless of if we're running as root or not, 0600 is acceptable,
+ // so we return if we match the regular user permission mask.
+ if info.Mode().Perm()&userPermissionMask == 0 {
+ return nil
+ }
+
+ // We need to pull the Unix file information to get the file's owner.
+ // If we can't access it, there's some sort of operating system level error
+ // and we should fail rather than attempting to use faulty information.
+ sysInfo := info.Sys()
+ if sysInfo == nil {
+ return ErrSSLKeyUnknownOwnership
+ }
+
+ unixStat, ok := sysInfo.(*syscall.Stat_t)
+ if !ok {
+ return ErrSSLKeyUnknownOwnership
+ }
+
+ // if the file is owned by root, we allow 0640 (u=rw,g=r) to match what
+ // Postgres does.
+ if unixStat.Uid == rootUserID {
+ rootPermissionMask := (os.FileMode(0777) ^ maxRootOwnedKeyPermissions)
+ if info.Mode().Perm()&rootPermissionMask != 0 {
+ return errSSLKeyHasUnacceptableRootPermissions
+ }
+ return nil
+ }
+
+ return errSSLKeyHasUnacceptableUserPermissions
}
diff --git a/vendor/github.com/lib/pq/ssl_windows.go b/vendor/github.com/lib/pq/ssl_windows.go
index 5d2c763cebc1c76484cbc5adb709248e1e9ce081..73663c8f157c1315e16b4de90e2e2e55a4d2b2e7 100644
--- a/vendor/github.com/lib/pq/ssl_windows.go
+++ b/vendor/github.com/lib/pq/ssl_windows.go
@@ -1,3 +1,4 @@
+//go:build windows
// +build windows
package pq
diff --git a/vendor/github.com/lib/pq/user_other.go b/vendor/github.com/lib/pq/user_other.go
new file mode 100644
index 0000000000000000000000000000000000000000..3dae8f5572b3f05ce1d6e2172f4fc14ab4d27b54
--- /dev/null
+++ b/vendor/github.com/lib/pq/user_other.go
@@ -0,0 +1,10 @@
+// Package pq is a pure Go Postgres driver for the database/sql package.
+
+//go:build js || android || hurd || zos
+// +build js android hurd zos
+
+package pq
+
+func userCurrent() (string, error) {
+ return "", ErrCouldNotDetectUsername
+}
diff --git a/vendor/github.com/lib/pq/user_posix.go b/vendor/github.com/lib/pq/user_posix.go
index a51019205824e65f8c0a0776d74d475948be7586..5f2d439bc4268318cbb4d91486f5f1d9afb69852 100644
--- a/vendor/github.com/lib/pq/user_posix.go
+++ b/vendor/github.com/lib/pq/user_posix.go
@@ -1,6 +1,7 @@
// Package pq is a pure Go Postgres driver for the database/sql package.
-// +build aix darwin dragonfly freebsd linux nacl netbsd openbsd plan9 solaris rumprun
+//go:build aix || darwin || dragonfly || freebsd || (linux && !android) || nacl || netbsd || openbsd || plan9 || solaris || rumprun || illumos
+// +build aix darwin dragonfly freebsd linux,!android nacl netbsd openbsd plan9 solaris rumprun illumos
package pq
diff --git a/vendor/modules.txt b/vendor/modules.txt
index 3c8efb02014c3c237156befe9a893a51ee572985..2e16c52c6749db9154841eb1f42c6187449ffb9d 100644
--- a/vendor/modules.txt
+++ b/vendor/modules.txt
@@ -189,7 +189,7 @@ github.com/jhump/protoreflect/internal/codec
github.com/jonboulle/clockwork
# github.com/json-iterator/go v1.1.12
github.com/json-iterator/go
-# github.com/lib/pq v1.10.1
+# github.com/lib/pq v1.10.7
## explicit
github.com/lib/pq
github.com/lib/pq/oid