Pg to bun (#148)

* start moving to bun

* changing more stuff

* more

* and yet more

* tests passing

* seems stable now

* more big changes

* small fix

* little fixes

22 files changed, 0 insertions, 2665 deletions

diff --git a/vendor/github.com/go-pg/pg/v10/types/append.go b/vendor/github.com/go-pg/pg/v10/types/append.go
deleted file mode 100644
index 05be2a0fa..000000000
--- a/vendor/github.com/go-pg/pg/v10/types/append.go
+++ /dev/null
@@ -1,201 +0,0 @@
-package types
-
-import (
-	"math"
-	"reflect"
-	"strconv"
-	"time"
-	"unicode/utf8"
-
-	"github.com/tmthrgd/go-hex"
-)
-
-func Append(b []byte, v interface{}, flags int) []byte {
-	switch v := v.(type) {
-	case nil:
-		return AppendNull(b, flags)
-	case bool:
-		return appendBool(b, v)
-	case int32:
-		return strconv.AppendInt(b, int64(v), 10)
-	case int64:
-		return strconv.AppendInt(b, v, 10)
-	case int:
-		return strconv.AppendInt(b, int64(v), 10)
-	case float32:
-		return appendFloat(b, float64(v), flags, 32)
-	case float64:
-		return appendFloat(b, v, flags, 64)
-	case string:
-		return AppendString(b, v, flags)
-	case time.Time:
-		return AppendTime(b, v, flags)
-	case []byte:
-		return AppendBytes(b, v, flags)
-	case ValueAppender:
-		return appendAppender(b, v, flags)
-	default:
-		return appendValue(b, reflect.ValueOf(v), flags)
-	}
-}
-
-func AppendError(b []byte, err error) []byte {
-	b = append(b, "?!("...)
-	b = append(b, err.Error()...)
-	b = append(b, ')')
-	return b
-}
-
-func AppendNull(b []byte, flags int) []byte {
-	if hasFlag(flags, quoteFlag) {
-		return append(b, "NULL"...)
-	}
-	return nil
-}
-
-func appendBool(dst []byte, v bool) []byte {
-	if v {
-		return append(dst, "TRUE"...)
-	}
-	return append(dst, "FALSE"...)
-}
-
-func appendFloat(dst []byte, v float64, flags int, bitSize int) []byte {
-	if hasFlag(flags, arrayFlag) {
-		return appendFloat2(dst, v, flags)
-	}
-
-	switch {
-	case math.IsNaN(v):
-		if hasFlag(flags, quoteFlag) {
-			return append(dst, "'NaN'"...)
-		}
-		return append(dst, "NaN"...)
-	case math.IsInf(v, 1):
-		if hasFlag(flags, quoteFlag) {
-			return append(dst, "'Infinity'"...)
-		}
-		return append(dst, "Infinity"...)
-	case math.IsInf(v, -1):
-		if hasFlag(flags, quoteFlag) {
-			return append(dst, "'-Infinity'"...)
-		}
-		return append(dst, "-Infinity"...)
-	default:
-		return strconv.AppendFloat(dst, v, 'f', -1, bitSize)
-	}
-}
-
-func appendFloat2(dst []byte, v float64, _ int) []byte {
-	switch {
-	case math.IsNaN(v):
-		return append(dst, "NaN"...)
-	case math.IsInf(v, 1):
-		return append(dst, "Infinity"...)
-	case math.IsInf(v, -1):
-		return append(dst, "-Infinity"...)
-	default:
-		return strconv.AppendFloat(dst, v, 'f', -1, 64)
-	}
-}
-
-func AppendString(b []byte, s string, flags int) []byte {
-	if hasFlag(flags, arrayFlag) {
-		return appendString2(b, s, flags)
-	}
-
-	if hasFlag(flags, quoteFlag) {
-		b = append(b, '\'')
-		for _, c := range s {
-			if c == '\000' {
-				continue
-			}
-
-			if c == '\'' {
-				b = append(b, '\'', '\'')
-			} else {
-				b = appendRune(b, c)
-			}
-		}
-		b = append(b, '\'')
-		return b
-	}
-
-	for _, c := range s {
-		if c != '\000' {
-			b = appendRune(b, c)
-		}
-	}
-	return b
-}
-
-func appendString2(b []byte, s string, flags int) []byte {
-	b = append(b, '"')
-	for _, c := range s {
-		if c == '\000' {
-			continue
-		}
-
-		switch c {
-		case '\'':
-			if hasFlag(flags, quoteFlag) {
-				b = append(b, '\'')
-			}
-			b = append(b, '\'')
-		case '"':
-			b = append(b, '\\', '"')
-		case '\\':
-			b = append(b, '\\', '\\')
-		default:
-			b = appendRune(b, c)
-		}
-	}
-	b = append(b, '"')
-	return b
-}
-
-func appendRune(b []byte, r rune) []byte {
-	if r < utf8.RuneSelf {
-		return append(b, byte(r))
-	}
-	l := len(b)
-	if cap(b)-l < utf8.UTFMax {
-		b = append(b, make([]byte, utf8.UTFMax)...)
-	}
-	n := utf8.EncodeRune(b[l:l+utf8.UTFMax], r)
-	return b[:l+n]
-}
-
-func AppendBytes(b []byte, bytes []byte, flags int) []byte {
-	if bytes == nil {
-		return AppendNull(b, flags)
-	}
-
-	if hasFlag(flags, arrayFlag) {
-		b = append(b, `"\`...)
-	} else if hasFlag(flags, quoteFlag) {
-		b = append(b, '\'')
-	}
-
-	b = append(b, `\x`...)
-
-	s := len(b)
-	b = append(b, make([]byte, hex.EncodedLen(len(bytes)))...)
-	hex.Encode(b[s:], bytes)
-
-	if hasFlag(flags, arrayFlag) {
-		b = append(b, '"')
-	} else if hasFlag(flags, quoteFlag) {
-		b = append(b, '\'')
-	}
-
-	return b
-}
-
-func appendAppender(b []byte, v ValueAppender, flags int) []byte {
-	bb, err := v.AppendValue(b, flags)
-	if err != nil {
-		return AppendError(b, err)
-	}
-	return bb
-}
diff --git a/vendor/github.com/go-pg/pg/v10/types/append_ident.go b/vendor/github.com/go-pg/pg/v10/types/append_ident.go
deleted file mode 100644
index 60b9d6784..000000000
--- a/vendor/github.com/go-pg/pg/v10/types/append_ident.go
+++ /dev/null
@@ -1,46 +0,0 @@
-package types
-
-import "github.com/go-pg/pg/v10/internal"
-
-func AppendIdent(b []byte, field string, flags int) []byte {
-	return appendIdent(b, internal.StringToBytes(field), flags)
-}
-
-func AppendIdentBytes(b []byte, field []byte, flags int) []byte {
-	return appendIdent(b, field, flags)
-}
-
-func appendIdent(b, src []byte, flags int) []byte {
-	var quoted bool
-loop:
-	for _, c := range src {
-		switch c {
-		case '*':
-			if !quoted {
-				b = append(b, '*')
-				continue loop
-			}
-		case '.':
-			if quoted && hasFlag(flags, quoteFlag) {
-				b = append(b, '"')
-				quoted = false
-			}
-			b = append(b, '.')
-			continue loop
-		}
-
-		if !quoted && hasFlag(flags, quoteFlag) {
-			b = append(b, '"')
-			quoted = true
-		}
-		if c == '"' {
-			b = append(b, '"', '"')
-		} else {
-			b = append(b, c)
-		}
-	}
-	if quoted && hasFlag(flags, quoteFlag) {
-		b = append(b, '"')
-	}
-	return b
-}
diff --git a/vendor/github.com/go-pg/pg/v10/types/append_jsonb.go b/vendor/github.com/go-pg/pg/v10/types/append_jsonb.go
deleted file mode 100644
index ffe221825..000000000
--- a/vendor/github.com/go-pg/pg/v10/types/append_jsonb.go
+++ /dev/null
@@ -1,49 +0,0 @@
-package types
-
-import "github.com/go-pg/pg/v10/internal/parser"
-
-func AppendJSONB(b, jsonb []byte, flags int) []byte {
-	if hasFlag(flags, arrayFlag) {
-		b = append(b, '"')
-	} else if hasFlag(flags, quoteFlag) {
-		b = append(b, '\'')
-	}
-
-	p := parser.New(jsonb)
-	for p.Valid() {
-		c := p.Read()
-		switch c {
-		case '"':
-			if hasFlag(flags, arrayFlag) {
-				b = append(b, '\\')
-			}
-			b = append(b, '"')
-		case '\'':
-			if hasFlag(flags, quoteFlag) {
-				b = append(b, '\'')
-			}
-			b = append(b, '\'')
-		case '\000':
-			continue
-		case '\\':
-			if p.SkipBytes([]byte("u0000")) {
-				b = append(b, "\\\\u0000"...)
-			} else {
-				b = append(b, '\\')
-				if p.Valid() {
-					b = append(b, p.Read())
-				}
-			}
-		default:
-			b = append(b, c)
-		}
-	}
-
-	if hasFlag(flags, arrayFlag) {
-		b = append(b, '"')
-	} else if hasFlag(flags, quoteFlag) {
-		b = append(b, '\'')
-	}
-
-	return b
-}
diff --git a/vendor/github.com/go-pg/pg/v10/types/append_value.go b/vendor/github.com/go-pg/pg/v10/types/append_value.go
deleted file mode 100644
index f12fc564f..000000000
--- a/vendor/github.com/go-pg/pg/v10/types/append_value.go
+++ /dev/null
@@ -1,248 +0,0 @@
-package types
-
-import (
-	"database/sql/driver"
-	"fmt"
-	"net"
-	"reflect"
-	"strconv"
-	"sync"
-	"time"
-
-	"github.com/vmihailenco/bufpool"
-
-	"github.com/go-pg/pg/v10/internal"
-	"github.com/go-pg/pg/v10/pgjson"
-)
-
-var (
-	driverValuerType = reflect.TypeOf((*driver.Valuer)(nil)).Elem()
-	appenderType     = reflect.TypeOf((*ValueAppender)(nil)).Elem()
-)
-
-type AppenderFunc func([]byte, reflect.Value, int) []byte
-
-var appenders []AppenderFunc
-
-//nolint
-func init() {
-	appenders = []AppenderFunc{
-		reflect.Bool:          appendBoolValue,
-		reflect.Int:           appendIntValue,
-		reflect.Int8:          appendIntValue,
-		reflect.Int16:         appendIntValue,
-		reflect.Int32:         appendIntValue,
-		reflect.Int64:         appendIntValue,
-		reflect.Uint:          appendUintValue,
-		reflect.Uint8:         appendUintValue,
-		reflect.Uint16:        appendUintValue,
-		reflect.Uint32:        appendUintValue,
-		reflect.Uint64:        appendUintValue,
-		reflect.Uintptr:       nil,
-		reflect.Float32:       appendFloat32Value,
-		reflect.Float64:       appendFloat64Value,
-		reflect.Complex64:     nil,
-		reflect.Complex128:    nil,
-		reflect.Array:         appendJSONValue,
-		reflect.Chan:          nil,
-		reflect.Func:          nil,
-		reflect.Interface:     appendIfaceValue,
-		reflect.Map:           appendJSONValue,
-		reflect.Ptr:           nil,
-		reflect.Slice:         appendJSONValue,
-		reflect.String:        appendStringValue,
-		reflect.Struct:        appendStructValue,
-		reflect.UnsafePointer: nil,
-	}
-}
-
-var appendersMap sync.Map
-
-// RegisterAppender registers an appender func for the value type.
-// Expecting to be used only during initialization, it panics
-// if there is already a registered appender for the given type.
-func RegisterAppender(value interface{}, fn AppenderFunc) {
-	registerAppender(reflect.TypeOf(value), fn)
-}
-
-func registerAppender(typ reflect.Type, fn AppenderFunc) {
-	_, loaded := appendersMap.LoadOrStore(typ, fn)
-	if loaded {
-		err := fmt.Errorf("pg: appender for the type=%s is already registered",
-			typ.String())
-		panic(err)
-	}
-}
-
-func Appender(typ reflect.Type) AppenderFunc {
-	if v, ok := appendersMap.Load(typ); ok {
-		return v.(AppenderFunc)
-	}
-	fn := appender(typ, false)
-	_, _ = appendersMap.LoadOrStore(typ, fn)
-	return fn
-}
-
-func appender(typ reflect.Type, pgArray bool) AppenderFunc {
-	switch typ {
-	case timeType:
-		return appendTimeValue
-	case ipType:
-		return appendIPValue
-	case ipNetType:
-		return appendIPNetValue
-	case jsonRawMessageType:
-		return appendJSONRawMessageValue
-	}
-
-	if typ.Implements(appenderType) {
-		return appendAppenderValue
-	}
-	if typ.Implements(driverValuerType) {
-		return appendDriverValuerValue
-	}
-
-	kind := typ.Kind()
-	switch kind {
-	case reflect.Ptr:
-		return ptrAppenderFunc(typ)
-	case reflect.Slice:
-		if typ.Elem().Kind() == reflect.Uint8 {
-			return appendBytesValue
-		}
-		if pgArray {
-			return ArrayAppender(typ)
-		}
-	case reflect.Array:
-		if typ.Elem().Kind() == reflect.Uint8 {
-			return appendArrayBytesValue
-		}
-	}
-	return appenders[kind]
-}
-
-func ptrAppenderFunc(typ reflect.Type) AppenderFunc {
-	appender := Appender(typ.Elem())
-	return func(b []byte, v reflect.Value, flags int) []byte {
-		if v.IsNil() {
-			return AppendNull(b, flags)
-		}
-		return appender(b, v.Elem(), flags)
-	}
-}
-
-func appendValue(b []byte, v reflect.Value, flags int) []byte {
-	if v.Kind() == reflect.Ptr && v.IsNil() {
-		return AppendNull(b, flags)
-	}
-	appender := Appender(v.Type())
-	return appender(b, v, flags)
-}
-
-func appendIfaceValue(b []byte, v reflect.Value, flags int) []byte {
-	return Append(b, v.Interface(), flags)
-}
-
-func appendBoolValue(b []byte, v reflect.Value, _ int) []byte {
-	return appendBool(b, v.Bool())
-}
-
-func appendIntValue(b []byte, v reflect.Value, _ int) []byte {
-	return strconv.AppendInt(b, v.Int(), 10)
-}
-
-func appendUintValue(b []byte, v reflect.Value, _ int) []byte {
-	return strconv.AppendUint(b, v.Uint(), 10)
-}
-
-func appendFloat32Value(b []byte, v reflect.Value, flags int) []byte {
-	return appendFloat(b, v.Float(), flags, 32)
-}
-
-func appendFloat64Value(b []byte, v reflect.Value, flags int) []byte {
-	return appendFloat(b, v.Float(), flags, 64)
-}
-
-func appendBytesValue(b []byte, v reflect.Value, flags int) []byte {
-	return AppendBytes(b, v.Bytes(), flags)
-}
-
-func appendArrayBytesValue(b []byte, v reflect.Value, flags int) []byte {
-	if v.CanAddr() {
-		return AppendBytes(b, v.Slice(0, v.Len()).Bytes(), flags)
-	}
-
-	buf := bufpool.Get(v.Len())
-
-	tmp := buf.Bytes()
-	reflect.Copy(reflect.ValueOf(tmp), v)
-	b = AppendBytes(b, tmp, flags)
-
-	bufpool.Put(buf)
-
-	return b
-}
-
-func appendStringValue(b []byte, v reflect.Value, flags int) []byte {
-	return AppendString(b, v.String(), flags)
-}
-
-func appendStructValue(b []byte, v reflect.Value, flags int) []byte {
-	if v.Type() == timeType {
-		return appendTimeValue(b, v, flags)
-	}
-	return appendJSONValue(b, v, flags)
-}
-
-var jsonPool bufpool.Pool
-
-func appendJSONValue(b []byte, v reflect.Value, flags int) []byte {
-	buf := jsonPool.Get()
-	defer jsonPool.Put(buf)
-
-	if err := pgjson.NewEncoder(buf).Encode(v.Interface()); err != nil {
-		return AppendError(b, err)
-	}
-
-	bb := buf.Bytes()
-	if len(bb) > 0 && bb[len(bb)-1] == '\n' {
-		bb = bb[:len(bb)-1]
-	}
-
-	return AppendJSONB(b, bb, flags)
-}
-
-func appendTimeValue(b []byte, v reflect.Value, flags int) []byte {
-	tm := v.Interface().(time.Time)
-	return AppendTime(b, tm, flags)
-}
-
-func appendIPValue(b []byte, v reflect.Value, flags int) []byte {
-	ip := v.Interface().(net.IP)
-	return AppendString(b, ip.String(), flags)
-}
-
-func appendIPNetValue(b []byte, v reflect.Value, flags int) []byte {
-	ipnet := v.Interface().(net.IPNet)
-	return AppendString(b, ipnet.String(), flags)
-}
-
-func appendJSONRawMessageValue(b []byte, v reflect.Value, flags int) []byte {
-	return AppendString(b, internal.BytesToString(v.Bytes()), flags)
-}
-
-func appendAppenderValue(b []byte, v reflect.Value, flags int) []byte {
-	return appendAppender(b, v.Interface().(ValueAppender), flags)
-}
-
-func appendDriverValuerValue(b []byte, v reflect.Value, flags int) []byte {
-	return appendDriverValuer(b, v.Interface().(driver.Valuer), flags)
-}
-
-func appendDriverValuer(b []byte, v driver.Valuer, flags int) []byte {
-	value, err := v.Value()
-	if err != nil {
-		return AppendError(b, err)
-	}
-	return Append(b, value, flags)
-}
diff --git a/vendor/github.com/go-pg/pg/v10/types/array.go b/vendor/github.com/go-pg/pg/v10/types/array.go
deleted file mode 100644
index fb70c1f50..000000000
--- a/vendor/github.com/go-pg/pg/v10/types/array.go
+++ /dev/null
@@ -1,58 +0,0 @@
-package types
-
-import (
-	"fmt"
-	"reflect"
-)
-
-type Array struct {
-	v reflect.Value
-
-	append AppenderFunc
-	scan   ScannerFunc
-}
-
-var (
-	_ ValueAppender = (*Array)(nil)
-	_ ValueScanner  = (*Array)(nil)
-)
-
-func NewArray(vi interface{}) *Array {
-	v := reflect.ValueOf(vi)
-	if !v.IsValid() {
-		panic(fmt.Errorf("pg: Array(nil)"))
-	}
-
-	return &Array{
-		v: v,
-
-		append: ArrayAppender(v.Type()),
-		scan:   ArrayScanner(v.Type()),
-	}
-}
-
-func (a *Array) AppendValue(b []byte, flags int) ([]byte, error) {
-	if a.append == nil {
-		panic(fmt.Errorf("pg: Array(unsupported %s)", a.v.Type()))
-	}
-	return a.append(b, a.v, flags), nil
-}
-
-func (a *Array) ScanValue(rd Reader, n int) error {
-	if a.scan == nil {
-		return fmt.Errorf("pg: Array(unsupported %s)", a.v.Type())
-	}
-
-	if a.v.Kind() != reflect.Ptr {
-		return fmt.Errorf("pg: Array(non-pointer %s)", a.v.Type())
-	}
-
-	return a.scan(a.v.Elem(), rd, n)
-}
-
-func (a *Array) Value() interface{} {
-	if a.v.IsValid() {
-		return a.v.Interface()
-	}
-	return nil
-}
diff --git a/vendor/github.com/go-pg/pg/v10/types/array_append.go b/vendor/github.com/go-pg/pg/v10/types/array_append.go
deleted file mode 100644
index a4132eb61..000000000
--- a/vendor/github.com/go-pg/pg/v10/types/array_append.go
+++ /dev/null
@@ -1,236 +0,0 @@
-package types
-
-import (
-	"reflect"
-	"strconv"
-	"sync"
-)
-
-var (
-	stringType      = reflect.TypeOf((*string)(nil)).Elem()
-	sliceStringType = reflect.TypeOf([]string(nil))
-
-	intType      = reflect.TypeOf((*int)(nil)).Elem()
-	sliceIntType = reflect.TypeOf([]int(nil))
-
-	int64Type      = reflect.TypeOf((*int64)(nil)).Elem()
-	sliceInt64Type = reflect.TypeOf([]int64(nil))
-
-	float64Type      = reflect.TypeOf((*float64)(nil)).Elem()
-	sliceFloat64Type = reflect.TypeOf([]float64(nil))
-)
-
-var arrayAppendersMap sync.Map
-
-func ArrayAppender(typ reflect.Type) AppenderFunc {
-	if v, ok := arrayAppendersMap.Load(typ); ok {
-		return v.(AppenderFunc)
-	}
-	fn := arrayAppender(typ)
-	arrayAppendersMap.Store(typ, fn)
-	return fn
-}
-
-func arrayAppender(typ reflect.Type) AppenderFunc {
-	kind := typ.Kind()
-	if kind == reflect.Ptr {
-		typ = typ.Elem()
-		kind = typ.Kind()
-	}
-
-	switch kind {
-	case reflect.Slice, reflect.Array:
-		// ok:
-	default:
-		return nil
-	}
-
-	elemType := typ.Elem()
-
-	if kind == reflect.Slice {
-		switch elemType {
-		case stringType:
-			return appendSliceStringValue
-		case intType:
-			return appendSliceIntValue
-		case int64Type:
-			return appendSliceInt64Value
-		case float64Type:
-			return appendSliceFloat64Value
-		}
-	}
-
-	appendElem := appender(elemType, true)
-	return func(b []byte, v reflect.Value, flags int) []byte {
-		flags |= arrayFlag
-
-		kind := v.Kind()
-		switch kind {
-		case reflect.Ptr, reflect.Slice:
-			if v.IsNil() {
-				return AppendNull(b, flags)
-			}
-		}
-
-		if kind == reflect.Ptr {
-			v = v.Elem()
-		}
-
-		quote := shouldQuoteArray(flags)
-		if quote {
-			b = append(b, '\'')
-		}
-
-		flags |= subArrayFlag
-
-		b = append(b, '{')
-		for i := 0; i < v.Len(); i++ {
-			elem := v.Index(i)
-			b = appendElem(b, elem, flags)
-			b = append(b, ',')
-		}
-		if v.Len() > 0 {
-			b[len(b)-1] = '}' // Replace trailing comma.
-		} else {
-			b = append(b, '}')
-		}
-
-		if quote {
-			b = append(b, '\'')
-		}
-
-		return b
-	}
-}
-
-func appendSliceStringValue(b []byte, v reflect.Value, flags int) []byte {
-	ss := v.Convert(sliceStringType).Interface().([]string)
-	return appendSliceString(b, ss, flags)
-}
-
-func appendSliceString(b []byte, ss []string, flags int) []byte {
-	if ss == nil {
-		return AppendNull(b, flags)
-	}
-
-	quote := shouldQuoteArray(flags)
-	if quote {
-		b = append(b, '\'')
-	}
-
-	b = append(b, '{')
-	for _, s := range ss {
-		b = appendString2(b, s, flags)
-		b = append(b, ',')
-	}
-	if len(ss) > 0 {
-		b[len(b)-1] = '}' // Replace trailing comma.
-	} else {
-		b = append(b, '}')
-	}
-
-	if quote {
-		b = append(b, '\'')
-	}
-
-	return b
-}
-
-func appendSliceIntValue(b []byte, v reflect.Value, flags int) []byte {
-	ints := v.Convert(sliceIntType).Interface().([]int)
-	return appendSliceInt(b, ints, flags)
-}
-
-func appendSliceInt(b []byte, ints []int, flags int) []byte {
-	if ints == nil {
-		return AppendNull(b, flags)
-	}
-
-	quote := shouldQuoteArray(flags)
-	if quote {
-		b = append(b, '\'')
-	}
-
-	b = append(b, '{')
-	for _, n := range ints {
-		b = strconv.AppendInt(b, int64(n), 10)
-		b = append(b, ',')
-	}
-	if len(ints) > 0 {
-		b[len(b)-1] = '}' // Replace trailing comma.
-	} else {
-		b = append(b, '}')
-	}
-
-	if quote {
-		b = append(b, '\'')
-	}
-
-	return b
-}
-
-func appendSliceInt64Value(b []byte, v reflect.Value, flags int) []byte {
-	ints := v.Convert(sliceInt64Type).Interface().([]int64)
-	return appendSliceInt64(b, ints, flags)
-}
-
-func appendSliceInt64(b []byte, ints []int64, flags int) []byte {
-	if ints == nil {
-		return AppendNull(b, flags)
-	}
-
-	quote := shouldQuoteArray(flags)
-	if quote {
-		b = append(b, '\'')
-	}
-
-	b = append(b, '{')
-	for _, n := range ints {
-		b = strconv.AppendInt(b, n, 10)
-		b = append(b, ',')
-	}
-	if len(ints) > 0 {
-		b[len(b)-1] = '}' // Replace trailing comma.
-	} else {
-		b = append(b, '}')
-	}
-
-	if quote {
-		b = append(b, '\'')
-	}
-
-	return b
-}
-
-func appendSliceFloat64Value(b []byte, v reflect.Value, flags int) []byte {
-	floats := v.Convert(sliceFloat64Type).Interface().([]float64)
-	return appendSliceFloat64(b, floats, flags)
-}
-
-func appendSliceFloat64(b []byte, floats []float64, flags int) []byte {
-	if floats == nil {
-		return AppendNull(b, flags)
-	}
-
-	quote := shouldQuoteArray(flags)
-	if quote {
-		b = append(b, '\'')
-	}
-
-	b = append(b, '{')
-	for _, n := range floats {
-		b = appendFloat2(b, n, flags)
-		b = append(b, ',')
-	}
-	if len(floats) > 0 {
-		b[len(b)-1] = '}' // Replace trailing comma.
-	} else {
-		b = append(b, '}')
-	}
-
-	if quote {
-		b = append(b, '\'')
-	}
-
-	return b
-}
diff --git a/vendor/github.com/go-pg/pg/v10/types/array_parser.go b/vendor/github.com/go-pg/pg/v10/types/array_parser.go
deleted file mode 100644
index 0870a6568..000000000
--- a/vendor/github.com/go-pg/pg/v10/types/array_parser.go
+++ /dev/null
@@ -1,170 +0,0 @@
-package types
-
-import (
-	"bufio"
-	"bytes"
-	"errors"
-	"fmt"
-	"io"
-
-	"github.com/go-pg/pg/v10/internal/parser"
-)
-
-var errEndOfArray = errors.New("pg: end of array")
-
-type arrayParser struct {
-	p parser.StreamingParser
-
-	stickyErr error
-	buf       []byte
-}
-
-func newArrayParserErr(err error) *arrayParser {
-	return &arrayParser{
-		stickyErr: err,
-		buf:       make([]byte, 32),
-	}
-}
-
-func newArrayParser(rd Reader) *arrayParser {
-	p := parser.NewStreamingParser(rd)
-	err := p.SkipByte('{')
-	if err != nil {
-		return newArrayParserErr(err)
-	}
-	return &arrayParser{
-		p: p,
-	}
-}
-
-func (p *arrayParser) NextElem() ([]byte, error) {
-	if p.stickyErr != nil {
-		return nil, p.stickyErr
-	}
-
-	c, err := p.p.ReadByte()
-	if err != nil {
-		if err == io.EOF {
-			return nil, errEndOfArray
-		}
-		return nil, err
-	}
-
-	switch c {
-	case '"':
-		b, err := p.p.ReadSubstring(p.buf[:0])
-		if err != nil {
-			return nil, err
-		}
-		p.buf = b
-
-		err = p.readCommaBrace()
-		if err != nil {
-			return nil, err
-		}
-
-		return b, nil
-	case '{':
-		b, err := p.readSubArray(p.buf[:0])
-		if err != nil {
-			return nil, err
-		}
-		p.buf = b
-
-		err = p.readCommaBrace()
-		if err != nil {
-			return nil, err
-		}
-
-		return b, nil
-	case '}':
-		return nil, errEndOfArray
-	default:
-		err = p.p.UnreadByte()
-		if err != nil {
-			return nil, err
-		}
-
-		b, err := p.readSimple(p.buf[:0])
-		if err != nil {
-			return nil, err
-		}
-		p.buf = b
-
-		if bytes.Equal(b, []byte("NULL")) {
-			return nil, nil
-		}
-		return b, nil
-	}
-}
-
-func (p *arrayParser) readSimple(b []byte) ([]byte, error) {
-	for {
-		tmp, err := p.p.ReadSlice(',')
-		if err == nil {
-			b = append(b, tmp...)
-			b = b[:len(b)-1]
-			break
-		}
-		b = append(b, tmp...)
-		if err == bufio.ErrBufferFull {
-			continue
-		}
-		if err == io.EOF {
-			if b[len(b)-1] == '}' {
-				b = b[:len(b)-1]
-				break
-			}
-		}
-		return nil, err
-	}
-	return b, nil
-}
-
-func (p *arrayParser) readSubArray(b []byte) ([]byte, error) {
-	b = append(b, '{')
-	for {
-		c, err := p.p.ReadByte()
-		if err != nil {
-			return nil, err
-		}
-
-		if c == '}' {
-			b = append(b, '}')
-			return b, nil
-		}
-
-		if c == '"' {
-			b = append(b, '"')
-			for {
-				tmp, err := p.p.ReadSlice('"')
-				b = append(b, tmp...)
-				if err != nil {
-					if err == bufio.ErrBufferFull {
-						continue
-					}
-					return nil, err
-				}
-				if len(b) > 1 && b[len(b)-2] != '\\' {
-					break
-				}
-			}
-			continue
-		}
-
-		b = append(b, c)
-	}
-}
-
-func (p *arrayParser) readCommaBrace() error {
-	c, err := p.p.ReadByte()
-	if err != nil {
-		return err
-	}
-	switch c {
-	case ',', '}':
-		return nil
-	default:
-		return fmt.Errorf("pg: got %q, wanted ',' or '}'", c)
-	}
-}
diff --git a/vendor/github.com/go-pg/pg/v10/types/array_scan.go b/vendor/github.com/go-pg/pg/v10/types/array_scan.go
deleted file mode 100644
index dbccafc06..000000000
--- a/vendor/github.com/go-pg/pg/v10/types/array_scan.go
+++ /dev/null
@@ -1,334 +0,0 @@
-package types
-
-import (
-	"fmt"
-	"reflect"
-
-	"github.com/go-pg/pg/v10/internal"
-	"github.com/go-pg/pg/v10/internal/pool"
-)
-
-var arrayValueScannerType = reflect.TypeOf((*ArrayValueScanner)(nil)).Elem()
-
-type ArrayValueScanner interface {
-	BeforeScanArrayValue(rd Reader, n int) error
-	ScanArrayValue(rd Reader, n int) error
-	AfterScanArrayValue() error
-}
-
-func ArrayScanner(typ reflect.Type) ScannerFunc {
-	if typ.Implements(arrayValueScannerType) {
-		return scanArrayValueScannerValue
-	}
-
-	kind := typ.Kind()
-	if kind == reflect.Ptr {
-		typ = typ.Elem()
-		kind = typ.Kind()
-	}
-
-	switch kind {
-	case reflect.Slice, reflect.Array:
-		// ok:
-	default:
-		return nil
-	}
-
-	elemType := typ.Elem()
-
-	if kind == reflect.Slice {
-		switch elemType {
-		case stringType:
-			return scanStringArrayValue
-		case intType:
-			return scanIntArrayValue
-		case int64Type:
-			return scanInt64ArrayValue
-		case float64Type:
-			return scanFloat64ArrayValue
-		}
-	}
-
-	scanElem := scanner(elemType, true)
-	return func(v reflect.Value, rd Reader, n int) error {
-		v = reflect.Indirect(v)
-		if !v.CanSet() {
-			return fmt.Errorf("pg: Scan(non-settable %s)", v.Type())
-		}
-
-		kind := v.Kind()
-
-		if n == -1 {
-			if kind != reflect.Slice || !v.IsNil() {
-				v.Set(reflect.Zero(v.Type()))
-			}
-			return nil
-		}
-
-		if kind == reflect.Slice {
-			if v.IsNil() {
-				v.Set(reflect.MakeSlice(v.Type(), 0, 0))
-			} else if v.Len() > 0 {
-				v.Set(v.Slice(0, 0))
-			}
-		}
-
-		p := newArrayParser(rd)
-		nextValue := internal.MakeSliceNextElemFunc(v)
-		var elemRd *pool.BytesReader
-
-		for {
-			elem, err := p.NextElem()
-			if err != nil {
-				if err == errEndOfArray {
-					break
-				}
-				return err
-			}
-
-			if elemRd == nil {
-				elemRd = pool.NewBytesReader(elem)
-			} else {
-				elemRd.Reset(elem)
-			}
-
-			var elemN int
-			if elem == nil {
-				elemN = -1
-			} else {
-				elemN = len(elem)
-			}
-
-			elemValue := nextValue()
-			err = scanElem(elemValue, elemRd, elemN)
-			if err != nil {
-				return err
-			}
-		}
-
-		return nil
-	}
-}
-
-func scanStringArrayValue(v reflect.Value, rd Reader, n int) error {
-	v = reflect.Indirect(v)
-	if !v.CanSet() {
-		return fmt.Errorf("pg: Scan(non-settable %s)", v.Type())
-	}
-
-	strings, err := scanStringArray(rd, n)
-	if err != nil {
-		return err
-	}
-
-	v.Set(reflect.ValueOf(strings))
-	return nil
-}
-
-func scanStringArray(rd Reader, n int) ([]string, error) {
-	if n == -1 {
-		return nil, nil
-	}
-
-	p := newArrayParser(rd)
-	slice := make([]string, 0)
-	for {
-		elem, err := p.NextElem()
-		if err != nil {
-			if err == errEndOfArray {
-				break
-			}
-			return nil, err
-		}
-
-		slice = append(slice, string(elem))
-	}
-
-	return slice, nil
-}
-
-func scanIntArrayValue(v reflect.Value, rd Reader, n int) error {
-	v = reflect.Indirect(v)
-	if !v.CanSet() {
-		return fmt.Errorf("pg: Scan(non-settable %s)", v.Type())
-	}
-
-	slice, err := decodeSliceInt(rd, n)
-	if err != nil {
-		return err
-	}
-
-	v.Set(reflect.ValueOf(slice))
-	return nil
-}
-
-func decodeSliceInt(rd Reader, n int) ([]int, error) {
-	if n == -1 {
-		return nil, nil
-	}
-
-	p := newArrayParser(rd)
-	slice := make([]int, 0)
-	for {
-		elem, err := p.NextElem()
-		if err != nil {
-			if err == errEndOfArray {
-				break
-			}
-			return nil, err
-		}
-
-		if elem == nil {
-			slice = append(slice, 0)
-			continue
-		}
-
-		n, err := internal.Atoi(elem)
-		if err != nil {
-			return nil, err
-		}
-
-		slice = append(slice, n)
-	}
-
-	return slice, nil
-}
-
-func scanInt64ArrayValue(v reflect.Value, rd Reader, n int) error {
-	v = reflect.Indirect(v)
-	if !v.CanSet() {
-		return fmt.Errorf("pg: Scan(non-settable %s)", v.Type())
-	}
-
-	slice, err := scanInt64Array(rd, n)
-	if err != nil {
-		return err
-	}
-
-	v.Set(reflect.ValueOf(slice))
-	return nil
-}
-
-func scanInt64Array(rd Reader, n int) ([]int64, error) {
-	if n == -1 {
-		return nil, nil
-	}
-
-	p := newArrayParser(rd)
-	slice := make([]int64, 0)
-	for {
-		elem, err := p.NextElem()
-		if err != nil {
-			if err == errEndOfArray {
-				break
-			}
-			return nil, err
-		}
-
-		if elem == nil {
-			slice = append(slice, 0)
-			continue
-		}
-
-		n, err := internal.ParseInt(elem, 10, 64)
-		if err != nil {
-			return nil, err
-		}
-
-		slice = append(slice, n)
-	}
-
-	return slice, nil
-}
-
-func scanFloat64ArrayValue(v reflect.Value, rd Reader, n int) error {
-	v = reflect.Indirect(v)
-	if !v.CanSet() {
-		return fmt.Errorf("pg: Scan(non-settable %s)", v.Type())
-	}
-
-	slice, err := scanFloat64Array(rd, n)
-	if err != nil {
-		return err
-	}
-
-	v.Set(reflect.ValueOf(slice))
-	return nil
-}
-
-func scanFloat64Array(rd Reader, n int) ([]float64, error) {
-	if n == -1 {
-		return nil, nil
-	}
-
-	p := newArrayParser(rd)
-	slice := make([]float64, 0)
-	for {
-		elem, err := p.NextElem()
-		if err != nil {
-			if err == errEndOfArray {
-				break
-			}
-			return nil, err
-		}
-
-		if elem == nil {
-			slice = append(slice, 0)
-			continue
-		}
-
-		n, err := internal.ParseFloat(elem, 64)
-		if err != nil {
-			return nil, err
-		}
-
-		slice = append(slice, n)
-	}
-
-	return slice, nil
-}
-
-func scanArrayValueScannerValue(v reflect.Value, rd Reader, n int) error {
-	if n == -1 {
-		return nil
-	}
-
-	scanner := v.Addr().Interface().(ArrayValueScanner)
-
-	err := scanner.BeforeScanArrayValue(rd, n)
-	if err != nil {
-		return err
-	}
-
-	p := newArrayParser(rd)
-	var elemRd *pool.BytesReader
-	for {
-		elem, err := p.NextElem()
-		if err != nil {
-			if err == errEndOfArray {
-				break
-			}
-			return err
-		}
-
-		if elemRd == nil {
-			elemRd = pool.NewBytesReader(elem)
-		} else {
-			elemRd.Reset(elem)
-		}
-
-		var elemN int
-		if elem == nil {
-			elemN = -1
-		} else {
-			elemN = len(elem)
-		}
-
-		err = scanner.ScanArrayValue(elemRd, elemN)
-		if err != nil {
-			return err
-		}
-	}
-
-	return scanner.AfterScanArrayValue()
-}
diff --git a/vendor/github.com/go-pg/pg/v10/types/column.go b/vendor/github.com/go-pg/pg/v10/types/column.go
deleted file mode 100644
index e3470f3eb..000000000
--- a/vendor/github.com/go-pg/pg/v10/types/column.go
+++ /dev/null
@@ -1,113 +0,0 @@
-package types
-
-import (
-	"encoding/json"
-
-	"github.com/go-pg/pg/v10/internal/pool"
-	"github.com/go-pg/pg/v10/pgjson"
-)
-
-const (
-	pgBool = 16
-
-	pgInt2 = 21
-	pgInt4 = 23
-	pgInt8 = 20
-
-	pgFloat4 = 700
-	pgFloat8 = 701
-
-	pgText    = 25
-	pgVarchar = 1043
-	pgBytea   = 17
-	pgJSON    = 114
-	pgJSONB   = 3802
-
-	pgTimestamp   = 1114
-	pgTimestamptz = 1184
-
-	// pgInt2Array = 1005
-	pgInt32Array  = 1007
-	pgInt8Array   = 1016
-	pgFloat8Array = 1022
-	pgStringArray = 1009
-
-	pgUUID = 2950
-)
-
-type ColumnInfo = pool.ColumnInfo
-
-type RawValue struct {
-	Type  int32
-	Value string
-}
-
-func (v RawValue) AppendValue(b []byte, flags int) ([]byte, error) {
-	return AppendString(b, v.Value, flags), nil
-}
-
-func (v RawValue) MarshalJSON() ([]byte, error) {
-	return pgjson.Marshal(v.Value)
-}
-
-func ReadColumnValue(col ColumnInfo, rd Reader, n int) (interface{}, error) {
-	switch col.DataType {
-	case pgBool:
-		return ScanBool(rd, n)
-
-	case pgInt2:
-		n, err := scanInt64(rd, n, 16)
-		if err != nil {
-			return nil, err
-		}
-		return int16(n), nil
-	case pgInt4:
-		n, err := scanInt64(rd, n, 32)
-		if err != nil {
-			return nil, err
-		}
-		return int32(n), nil
-	case pgInt8:
-		return ScanInt64(rd, n)
-
-	case pgFloat4:
-		return ScanFloat32(rd, n)
-	case pgFloat8:
-		return ScanFloat64(rd, n)
-
-	case pgBytea:
-		return ScanBytes(rd, n)
-	case pgText, pgVarchar, pgUUID:
-		return ScanString(rd, n)
-	case pgJSON, pgJSONB:
-		s, err := ScanString(rd, n)
-		if err != nil {
-			return nil, err
-		}
-		return json.RawMessage(s), nil
-
-	case pgTimestamp:
-		return ScanTime(rd, n)
-	case pgTimestamptz:
-		return ScanTime(rd, n)
-
-	case pgInt32Array:
-		return scanInt64Array(rd, n)
-	case pgInt8Array:
-		return scanInt64Array(rd, n)
-	case pgFloat8Array:
-		return scanFloat64Array(rd, n)
-	case pgStringArray:
-		return scanStringArray(rd, n)
-
-	default:
-		s, err := ScanString(rd, n)
-		if err != nil {
-			return nil, err
-		}
-		return RawValue{
-			Type:  col.DataType,
-			Value: s,
-		}, nil
-	}
-}
diff --git a/vendor/github.com/go-pg/pg/v10/types/doc.go b/vendor/github.com/go-pg/pg/v10/types/doc.go
deleted file mode 100644
index 890ef3c08..000000000
--- a/vendor/github.com/go-pg/pg/v10/types/doc.go
+++ /dev/null
@@ -1,4 +0,0 @@
-/*
-The API in this package is not stable and may change without any notice.
-*/
-package types
diff --git a/vendor/github.com/go-pg/pg/v10/types/flags.go b/vendor/github.com/go-pg/pg/v10/types/flags.go
deleted file mode 100644
index 10e415f14..000000000
--- a/vendor/github.com/go-pg/pg/v10/types/flags.go
+++ /dev/null
@@ -1,25 +0,0 @@
-package types
-
-import "reflect"
-
-const (
-	quoteFlag = 1 << iota
-	arrayFlag
-	subArrayFlag
-)
-
-func hasFlag(flags, flag int) bool {
-	return flags&flag == flag
-}
-
-func shouldQuoteArray(flags int) bool {
-	return hasFlag(flags, quoteFlag) && !hasFlag(flags, subArrayFlag)
-}
-
-func nilable(v reflect.Value) bool {
-	switch v.Kind() {
-	case reflect.Chan, reflect.Func, reflect.Interface, reflect.Map, reflect.Ptr, reflect.Slice:
-		return true
-	}
-	return false
-}
diff --git a/vendor/github.com/go-pg/pg/v10/types/hex.go b/vendor/github.com/go-pg/pg/v10/types/hex.go
deleted file mode 100644
index 8ae6469b9..000000000
--- a/vendor/github.com/go-pg/pg/v10/types/hex.go
+++ /dev/null
@@ -1,81 +0,0 @@
-package types
-
-import (
-	"bytes"
-	"encoding/hex"
-	"fmt"
-	"io"
-
-	fasthex "github.com/tmthrgd/go-hex"
-)
-
-type HexEncoder struct {
-	b       []byte
-	flags   int
-	written bool
-}
-
-func NewHexEncoder(b []byte, flags int) *HexEncoder {
-	return &HexEncoder{
-		b:     b,
-		flags: flags,
-	}
-}
-
-func (enc *HexEncoder) Bytes() []byte {
-	return enc.b
-}
-
-func (enc *HexEncoder) Write(b []byte) (int, error) {
-	if !enc.written {
-		if hasFlag(enc.flags, arrayFlag) {
-			enc.b = append(enc.b, `"\`...)
-		} else if hasFlag(enc.flags, quoteFlag) {
-			enc.b = append(enc.b, '\'')
-		}
-		enc.b = append(enc.b, `\x`...)
-		enc.written = true
-	}
-
-	i := len(enc.b)
-	enc.b = append(enc.b, make([]byte, fasthex.EncodedLen(len(b)))...)
-	fasthex.Encode(enc.b[i:], b)
-
-	return len(b), nil
-}
-
-func (enc *HexEncoder) Close() error {
-	if enc.written {
-		if hasFlag(enc.flags, arrayFlag) {
-			enc.b = append(enc.b, '"')
-		} else if hasFlag(enc.flags, quoteFlag) {
-			enc.b = append(enc.b, '\'')
-		}
-	} else {
-		enc.b = AppendNull(enc.b, enc.flags)
-	}
-	return nil
-}
-
-//------------------------------------------------------------------------------
-
-func NewHexDecoder(rd Reader, n int) (io.Reader, error) {
-	if n <= 0 {
-		var rd bytes.Reader
-		return &rd, nil
-	}
-
-	if c, err := rd.ReadByte(); err != nil {
-		return nil, err
-	} else if c != '\\' {
-		return nil, fmt.Errorf("got %q, wanted %q", c, '\\')
-	}
-
-	if c, err := rd.ReadByte(); err != nil {
-		return nil, err
-	} else if c != 'x' {
-		return nil, fmt.Errorf("got %q, wanted %q", c, 'x')
-	}
-
-	return hex.NewDecoder(rd), nil
-}
diff --git a/vendor/github.com/go-pg/pg/v10/types/hstore.go b/vendor/github.com/go-pg/pg/v10/types/hstore.go
deleted file mode 100644
index 58c214ac6..000000000
--- a/vendor/github.com/go-pg/pg/v10/types/hstore.go
+++ /dev/null
@@ -1,59 +0,0 @@
-package types
-
-import (
-	"fmt"
-	"reflect"
-)
-
-type Hstore struct {
-	v reflect.Value
-
-	append AppenderFunc
-	scan   ScannerFunc
-}
-
-var (
-	_ ValueAppender = (*Hstore)(nil)
-	_ ValueScanner  = (*Hstore)(nil)
-)
-
-func NewHstore(vi interface{}) *Hstore {
-	v := reflect.ValueOf(vi)
-	if !v.IsValid() {
-		panic(fmt.Errorf("pg.Hstore(nil)"))
-	}
-
-	typ := v.Type()
-	if typ.Kind() == reflect.Ptr {
-		typ = typ.Elem()
-	}
-	if typ.Kind() != reflect.Map {
-		panic(fmt.Errorf("pg.Hstore(unsupported %s)", typ))
-	}
-
-	return &Hstore{
-		v: v,
-
-		append: HstoreAppender(typ),
-		scan:   HstoreScanner(typ),
-	}
-}
-
-func (h *Hstore) Value() interface{} {
-	if h.v.IsValid() {
-		return h.v.Interface()
-	}
-	return nil
-}
-
-func (h *Hstore) AppendValue(b []byte, flags int) ([]byte, error) {
-	return h.append(b, h.v, flags), nil
-}
-
-func (h *Hstore) ScanValue(rd Reader, n int) error {
-	if h.v.Kind() != reflect.Ptr {
-		return fmt.Errorf("pg: Hstore(non-pointer %s)", h.v.Type())
-	}
-
-	return h.scan(h.v.Elem(), rd, n)
-}
diff --git a/vendor/github.com/go-pg/pg/v10/types/hstore_append.go b/vendor/github.com/go-pg/pg/v10/types/hstore_append.go
deleted file mode 100644
index e27292afa..000000000
--- a/vendor/github.com/go-pg/pg/v10/types/hstore_append.go
+++ /dev/null
@@ -1,50 +0,0 @@
-package types
-
-import (
-	"fmt"
-	"reflect"
-)
-
-var mapStringStringType = reflect.TypeOf(map[string]string(nil))
-
-func HstoreAppender(typ reflect.Type) AppenderFunc {
-	if typ.Key() == stringType && typ.Elem() == stringType {
-		return appendMapStringStringValue
-	}
-
-	return func(b []byte, v reflect.Value, flags int) []byte {
-		err := fmt.Errorf("pg.Hstore(unsupported %s)", v.Type())
-		return AppendError(b, err)
-	}
-}
-
-func appendMapStringString(b []byte, m map[string]string, flags int) []byte {
-	if m == nil {
-		return AppendNull(b, flags)
-	}
-
-	if hasFlag(flags, quoteFlag) {
-		b = append(b, '\'')
-	}
-
-	for key, value := range m {
-		b = appendString2(b, key, flags)
-		b = append(b, '=', '>')
-		b = appendString2(b, value, flags)
-		b = append(b, ',')
-	}
-	if len(m) > 0 {
-		b = b[:len(b)-1] // Strip trailing comma.
-	}
-
-	if hasFlag(flags, quoteFlag) {
-		b = append(b, '\'')
-	}
-
-	return b
-}
-
-func appendMapStringStringValue(b []byte, v reflect.Value, flags int) []byte {
-	m := v.Convert(mapStringStringType).Interface().(map[string]string)
-	return appendMapStringString(b, m, flags)
-}
diff --git a/vendor/github.com/go-pg/pg/v10/types/hstore_parser.go b/vendor/github.com/go-pg/pg/v10/types/hstore_parser.go
deleted file mode 100644
index 79cd41eda..000000000
--- a/vendor/github.com/go-pg/pg/v10/types/hstore_parser.go
+++ /dev/null
@@ -1,65 +0,0 @@
-package types
-
-import (
-	"errors"
-	"io"
-
-	"github.com/go-pg/pg/v10/internal/parser"
-)
-
-var errEndOfHstore = errors.New("pg: end of hstore")
-
-type hstoreParser struct {
-	p parser.StreamingParser
-}
-
-func newHstoreParser(rd Reader) *hstoreParser {
-	return &hstoreParser{
-		p: parser.NewStreamingParser(rd),
-	}
-}
-
-func (p *hstoreParser) NextKey() ([]byte, error) {
-	err := p.p.SkipByte('"')
-	if err != nil {
-		if err == io.EOF {
-			return nil, errEndOfHstore
-		}
-		return nil, err
-	}
-
-	key, err := p.p.ReadSubstring(nil)
-	if err != nil {
-		return nil, err
-	}
-
-	err = p.p.SkipByte('=')
-	if err != nil {
-		return nil, err
-	}
-	err = p.p.SkipByte('>')
-	if err != nil {
-		return nil, err
-	}
-
-	return key, nil
-}
-
-func (p *hstoreParser) NextValue() ([]byte, error) {
-	err := p.p.SkipByte('"')
-	if err != nil {
-		return nil, err
-	}
-
-	value, err := p.p.ReadSubstring(nil)
-	if err != nil {
-		return nil, err
-	}
-
-	err = p.p.SkipByte(',')
-	if err == nil {
-		_ = p.p.SkipByte(' ')
-	}
-
-	return value, nil
-}
diff --git a/vendor/github.com/go-pg/pg/v10/types/hstore_scan.go b/vendor/github.com/go-pg/pg/v10/types/hstore_scan.go
deleted file mode 100644
index 2061c6163..000000000
--- a/vendor/github.com/go-pg/pg/v10/types/hstore_scan.go
+++ /dev/null
@@ -1,51 +0,0 @@
-package types
-
-import (
-	"fmt"
-	"reflect"
-)
-
-func HstoreScanner(typ reflect.Type) ScannerFunc {
-	if typ.Key() == stringType && typ.Elem() == stringType {
-		return scanMapStringStringValue
-	}
-	return func(v reflect.Value, rd Reader, n int) error {
-		return fmt.Errorf("pg.Hstore(unsupported %s)", v.Type())
-	}
-}
-
-func scanMapStringStringValue(v reflect.Value, rd Reader, n int) error {
-	m, err := scanMapStringString(rd, n)
-	if err != nil {
-		return err
-	}
-
-	v.Set(reflect.ValueOf(m))
-	return nil
-}
-
-func scanMapStringString(rd Reader, n int) (map[string]string, error) {
-	if n == -1 {
-		return nil, nil
-	}
-
-	p := newHstoreParser(rd)
-	m := make(map[string]string)
-	for {
-		key, err := p.NextKey()
-		if err != nil {
-			if err == errEndOfHstore {
-				break
-			}
-			return nil, err
-		}
-
-		value, err := p.NextValue()
-		if err != nil {
-			return nil, err
-		}
-
-		m[string(key)] = string(value)
-	}
-	return m, nil
-}
diff --git a/vendor/github.com/go-pg/pg/v10/types/in_op.go b/vendor/github.com/go-pg/pg/v10/types/in_op.go
deleted file mode 100644
index 472b986d8..000000000
--- a/vendor/github.com/go-pg/pg/v10/types/in_op.go
+++ /dev/null
@@ -1,62 +0,0 @@
-package types
-
-import (
-	"fmt"
-	"reflect"
-)
-
-type inOp struct {
-	slice     reflect.Value
-	stickyErr error
-}
-
-var _ ValueAppender = (*inOp)(nil)
-
-func InMulti(values ...interface{}) ValueAppender {
-	return &inOp{
-		slice: reflect.ValueOf(values),
-	}
-}
-
-func In(slice interface{}) ValueAppender {
-	v := reflect.ValueOf(slice)
-	if v.Kind() != reflect.Slice {
-		return &inOp{
-			stickyErr: fmt.Errorf("pg: In(non-slice %T)", slice),
-		}
-	}
-
-	return &inOp{
-		slice: v,
-	}
-}
-
-func (in *inOp) AppendValue(b []byte, flags int) ([]byte, error) {
-	if in.stickyErr != nil {
-		return nil, in.stickyErr
-	}
-	return appendIn(b, in.slice, flags), nil
-}
-
-func appendIn(b []byte, slice reflect.Value, flags int) []byte {
-	sliceLen := slice.Len()
-	for i := 0; i < sliceLen; i++ {
-		if i > 0 {
-			b = append(b, ',')
-		}
-
-		elem := slice.Index(i)
-		if elem.Kind() == reflect.Interface {
-			elem = elem.Elem()
-		}
-
-		if elem.Kind() == reflect.Slice {
-			b = append(b, '(')
-			b = appendIn(b, elem, flags)
-			b = append(b, ')')
-		} else {
-			b = appendValue(b, elem, flags)
-		}
-	}
-	return b
-}
diff --git a/vendor/github.com/go-pg/pg/v10/types/null_time.go b/vendor/github.com/go-pg/pg/v10/types/null_time.go
deleted file mode 100644
index 3c3f1f79a..000000000
--- a/vendor/github.com/go-pg/pg/v10/types/null_time.go
+++ /dev/null
@@ -1,58 +0,0 @@
-package types
-
-import (
-	"bytes"
-	"database/sql"
-	"encoding/json"
-	"time"
-)
-
-var jsonNull = []byte("null")
-
-// NullTime is a time.Time wrapper that marshals zero time as JSON null and
-// PostgreSQL NULL.
-type NullTime struct {
-	time.Time
-}
-
-var (
-	_ json.Marshaler   = (*NullTime)(nil)
-	_ json.Unmarshaler = (*NullTime)(nil)
-	_ sql.Scanner      = (*NullTime)(nil)
-	_ ValueAppender    = (*NullTime)(nil)
-)
-
-func (tm NullTime) MarshalJSON() ([]byte, error) {
-	if tm.IsZero() {
-		return jsonNull, nil
-	}
-	return tm.Time.MarshalJSON()
-}
-
-func (tm *NullTime) UnmarshalJSON(b []byte) error {
-	if bytes.Equal(b, jsonNull) {
-		tm.Time = time.Time{}
-		return nil
-	}
-	return tm.Time.UnmarshalJSON(b)
-}
-
-func (tm NullTime) AppendValue(b []byte, flags int) ([]byte, error) {
-	if tm.IsZero() {
-		return AppendNull(b, flags), nil
-	}
-	return AppendTime(b, tm.Time, flags), nil
-}
-
-func (tm *NullTime) Scan(b interface{}) error {
-	if b == nil {
-		tm.Time = time.Time{}
-		return nil
-	}
-	newtm, err := ParseTime(b.([]byte))
-	if err != nil {
-		return err
-	}
-	tm.Time = newtm
-	return nil
-}
diff --git a/vendor/github.com/go-pg/pg/v10/types/scan.go b/vendor/github.com/go-pg/pg/v10/types/scan.go
deleted file mode 100644
index 2e9c0cc85..000000000
--- a/vendor/github.com/go-pg/pg/v10/types/scan.go
+++ /dev/null
@@ -1,244 +0,0 @@
-package types
-
-import (
-	"errors"
-	"fmt"
-	"reflect"
-	"time"
-
-	"github.com/tmthrgd/go-hex"
-
-	"github.com/go-pg/pg/v10/internal"
-)
-
-func Scan(v interface{}, rd Reader, n int) error {
-	var err error
-	switch v := v.(type) {
-	case *string:
-		*v, err = ScanString(rd, n)
-		return err
-	case *[]byte:
-		*v, err = ScanBytes(rd, n)
-		return err
-	case *int:
-		*v, err = ScanInt(rd, n)
-		return err
-	case *int64:
-		*v, err = ScanInt64(rd, n)
-		return err
-	case *float32:
-		*v, err = ScanFloat32(rd, n)
-		return err
-	case *float64:
-		*v, err = ScanFloat64(rd, n)
-		return err
-	case *time.Time:
-		*v, err = ScanTime(rd, n)
-		return err
-	}
-
-	vv := reflect.ValueOf(v)
-	if !vv.IsValid() {
-		return errors.New("pg: Scan(nil)")
-	}
-
-	if vv.Kind() != reflect.Ptr {
-		return fmt.Errorf("pg: Scan(non-pointer %T)", v)
-	}
-	if vv.IsNil() {
-		return fmt.Errorf("pg: Scan(non-settable %T)", v)
-	}
-
-	vv = vv.Elem()
-	if vv.Kind() == reflect.Interface {
-		if vv.IsNil() {
-			return errors.New("pg: Scan(nil)")
-		}
-
-		vv = vv.Elem()
-		if vv.Kind() != reflect.Ptr {
-			return fmt.Errorf("pg: Decode(non-pointer %s)", vv.Type().String())
-		}
-	}
-
-	return ScanValue(vv, rd, n)
-}
-
-func ScanString(rd Reader, n int) (string, error) {
-	if n <= 0 {
-		return "", nil
-	}
-
-	b, err := rd.ReadFull()
-	if err != nil {
-		return "", err
-	}
-
-	return internal.BytesToString(b), nil
-}
-
-func ScanBytes(rd Reader, n int) ([]byte, error) {
-	if n == -1 {
-		return nil, nil
-	}
-	if n == 0 {
-		return []byte{}, nil
-	}
-
-	b := make([]byte, hex.DecodedLen(n-2))
-	if err := ReadBytes(rd, b); err != nil {
-		return nil, err
-	}
-	return b, nil
-}
-
-func ReadBytes(rd Reader, b []byte) error {
-	tmp, err := rd.ReadFullTemp()
-	if err != nil {
-		return err
-	}
-
-	if len(tmp) < 2 {
-		return fmt.Errorf("pg: can't parse bytea: %q", tmp)
-	}
-
-	if tmp[0] != '\\' || tmp[1] != 'x' {
-		return fmt.Errorf("pg: can't parse bytea: %q", tmp)
-	}
-	tmp = tmp[2:] // Trim off "\\x".
-
-	if len(b) != hex.DecodedLen(len(tmp)) {
-		return fmt.Errorf("pg: too small buf to decode hex")
-	}
-
-	if _, err := hex.Decode(b, tmp); err != nil {
-		return err
-	}
-
-	return nil
-}
-
-func ScanInt(rd Reader, n int) (int, error) {
-	if n <= 0 {
-		return 0, nil
-	}
-
-	tmp, err := rd.ReadFullTemp()
-	if err != nil {
-		return 0, err
-	}
-
-	num, err := internal.Atoi(tmp)
-	if err != nil {
-		return 0, err
-	}
-
-	return num, nil
-}
-
-func ScanInt64(rd Reader, n int) (int64, error) {
-	return scanInt64(rd, n, 64)
-}
-
-func scanInt64(rd Reader, n int, bitSize int) (int64, error) {
-	if n <= 0 {
-		return 0, nil
-	}
-
-	tmp, err := rd.ReadFullTemp()
-	if err != nil {
-		return 0, err
-	}
-
-	num, err := internal.ParseInt(tmp, 10, bitSize)
-	if err != nil {
-		return 0, err
-	}
-
-	return num, nil
-}
-
-func ScanUint64(rd Reader, n int) (uint64, error) {
-	if n <= 0 {
-		return 0, nil
-	}
-
-	tmp, err := rd.ReadFullTemp()
-	if err != nil {
-		return 0, err
-	}
-
-	// PostgreSQL does not natively support uint64 - only int64.
-	// Be nice and accept negative int64.
-	if len(tmp) > 0 && tmp[0] == '-' {
-		num, err := internal.ParseInt(tmp, 10, 64)
-		if err != nil {
-			return 0, err
-		}
-		return uint64(num), nil
-	}
-
-	num, err := internal.ParseUint(tmp, 10, 64)
-	if err != nil {
-		return 0, err
-	}
-
-	return num, nil
-}
-
-func ScanFloat32(rd Reader, n int) (float32, error) {
-	if n <= 0 {
-		return 0, nil
-	}
-
-	tmp, err := rd.ReadFullTemp()
-	if err != nil {
-		return 0, err
-	}
-
-	num, err := internal.ParseFloat(tmp, 32)
-	if err != nil {
-		return 0, err
-	}
-
-	return float32(num), nil
-}
-
-func ScanFloat64(rd Reader, n int) (float64, error) {
-	if n <= 0 {
-		return 0, nil
-	}
-
-	tmp, err := rd.ReadFullTemp()
-	if err != nil {
-		return 0, err
-	}
-
-	num, err := internal.ParseFloat(tmp, 64)
-	if err != nil {
-		return 0, err
-	}
-
-	return num, nil
-}
-
-func ScanTime(rd Reader, n int) (time.Time, error) {
-	if n <= 0 {
-		return time.Time{}, nil
-	}
-
-	tmp, err := rd.ReadFullTemp()
-	if err != nil {
-		return time.Time{}, err
-	}
-
-	return ParseTime(tmp)
-}
-
-func ScanBool(rd Reader, n int) (bool, error) {
-	tmp, err := rd.ReadFullTemp()
-	if err != nil {
-		return false, err
-	}
-	return len(tmp) == 1 && (tmp[0] == 't' || tmp[0] == '1'), nil
-}
diff --git a/vendor/github.com/go-pg/pg/v10/types/scan_value.go b/vendor/github.com/go-pg/pg/v10/types/scan_value.go
deleted file mode 100644
index 9f5a7bb6e..000000000
--- a/vendor/github.com/go-pg/pg/v10/types/scan_value.go
+++ /dev/null
@@ -1,418 +0,0 @@
-package types
-
-import (
-	"database/sql"
-	"encoding/json"
-	"errors"
-	"fmt"
-	"net"
-	"reflect"
-	"sync"
-	"time"
-
-	"github.com/go-pg/pg/v10/internal"
-	"github.com/go-pg/pg/v10/pgjson"
-)
-
-var (
-	valueScannerType   = reflect.TypeOf((*ValueScanner)(nil)).Elem()
-	sqlScannerType     = reflect.TypeOf((*sql.Scanner)(nil)).Elem()
-	timeType           = reflect.TypeOf((*time.Time)(nil)).Elem()
-	ipType             = reflect.TypeOf((*net.IP)(nil)).Elem()
-	ipNetType          = reflect.TypeOf((*net.IPNet)(nil)).Elem()
-	jsonRawMessageType = reflect.TypeOf((*json.RawMessage)(nil)).Elem()
-)
-
-type ScannerFunc func(reflect.Value, Reader, int) error
-
-var valueScanners []ScannerFunc
-
-//nolint
-func init() {
-	valueScanners = []ScannerFunc{
-		reflect.Bool:          scanBoolValue,
-		reflect.Int:           scanInt64Value,
-		reflect.Int8:          scanInt64Value,
-		reflect.Int16:         scanInt64Value,
-		reflect.Int32:         scanInt64Value,
-		reflect.Int64:         scanInt64Value,
-		reflect.Uint:          scanUint64Value,
-		reflect.Uint8:         scanUint64Value,
-		reflect.Uint16:        scanUint64Value,
-		reflect.Uint32:        scanUint64Value,
-		reflect.Uint64:        scanUint64Value,
-		reflect.Uintptr:       nil,
-		reflect.Float32:       scanFloat32Value,
-		reflect.Float64:       scanFloat64Value,
-		reflect.Complex64:     nil,
-		reflect.Complex128:    nil,
-		reflect.Array:         scanJSONValue,
-		reflect.Chan:          nil,
-		reflect.Func:          nil,
-		reflect.Interface:     scanIfaceValue,
-		reflect.Map:           scanJSONValue,
-		reflect.Ptr:           nil,
-		reflect.Slice:         scanJSONValue,
-		reflect.String:        scanStringValue,
-		reflect.Struct:        scanJSONValue,
-		reflect.UnsafePointer: nil,
-	}
-}
-
-var scannersMap sync.Map
-
-// RegisterScanner registers an scanner func for the type.
-// Expecting to be used only during initialization, it panics
-// if there is already a registered scanner for the given type.
-func RegisterScanner(value interface{}, fn ScannerFunc) {
-	registerScanner(reflect.TypeOf(value), fn)
-}
-
-func registerScanner(typ reflect.Type, fn ScannerFunc) {
-	_, loaded := scannersMap.LoadOrStore(typ, fn)
-	if loaded {
-		err := fmt.Errorf("pg: scanner for the type=%s is already registered",
-			typ.String())
-		panic(err)
-	}
-}
-
-func Scanner(typ reflect.Type) ScannerFunc {
-	if v, ok := scannersMap.Load(typ); ok {
-		return v.(ScannerFunc)
-	}
-	fn := scanner(typ, false)
-	_, _ = scannersMap.LoadOrStore(typ, fn)
-	return fn
-}
-
-func scanner(typ reflect.Type, pgArray bool) ScannerFunc {
-	switch typ {
-	case timeType:
-		return scanTimeValue
-	case ipType:
-		return scanIPValue
-	case ipNetType:
-		return scanIPNetValue
-	case jsonRawMessageType:
-		return scanJSONRawMessageValue
-	}
-
-	if typ.Implements(valueScannerType) {
-		return scanValueScannerValue
-	}
-	if reflect.PtrTo(typ).Implements(valueScannerType) {
-		return scanValueScannerAddrValue
-	}
-
-	if typ.Implements(sqlScannerType) {
-		return scanSQLScannerValue
-	}
-	if reflect.PtrTo(typ).Implements(sqlScannerType) {
-		return scanSQLScannerAddrValue
-	}
-
-	kind := typ.Kind()
-	switch kind {
-	case reflect.Ptr:
-		return ptrScannerFunc(typ)
-	case reflect.Slice:
-		if typ.Elem().Kind() == reflect.Uint8 {
-			return scanBytesValue
-		}
-		if pgArray {
-			return ArrayScanner(typ)
-		}
-	case reflect.Array:
-		if typ.Elem().Kind() == reflect.Uint8 {
-			return scanArrayBytesValue
-		}
-	}
-	return valueScanners[kind]
-}
-
-func ptrScannerFunc(typ reflect.Type) ScannerFunc {
-	scanner := Scanner(typ.Elem())
-	return func(v reflect.Value, rd Reader, n int) error {
-		if scanner == nil {
-			return fmt.Errorf("pg: Scan(unsupported %s)", v.Type())
-		}
-
-		if n == -1 {
-			if v.IsNil() {
-				return nil
-			}
-			if !v.CanSet() {
-				return fmt.Errorf("pg: Scan(non-settable %s)", v.Type())
-			}
-			v.Set(reflect.Zero(v.Type()))
-			return nil
-		}
-
-		if v.IsNil() {
-			if !v.CanSet() {
-				return fmt.Errorf("pg: Scan(non-settable %s)", v.Type())
-			}
-			v.Set(reflect.New(v.Type().Elem()))
-		}
-
-		return scanner(v.Elem(), rd, n)
-	}
-}
-
-func scanIfaceValue(v reflect.Value, rd Reader, n int) error {
-	if v.IsNil() {
-		return scanJSONValue(v, rd, n)
-	}
-	return ScanValue(v.Elem(), rd, n)
-}
-
-func ScanValue(v reflect.Value, rd Reader, n int) error {
-	if !v.IsValid() {
-		return errors.New("pg: Scan(nil)")
-	}
-
-	scanner := Scanner(v.Type())
-	if scanner != nil {
-		return scanner(v, rd, n)
-	}
-
-	if v.Kind() == reflect.Interface {
-		return errors.New("pg: Scan(nil)")
-	}
-	return fmt.Errorf("pg: Scan(unsupported %s)", v.Type())
-}
-
-func scanBoolValue(v reflect.Value, rd Reader, n int) error {
-	if n == -1 {
-		v.SetBool(false)
-		return nil
-	}
-
-	flag, err := ScanBool(rd, n)
-	if err != nil {
-		return err
-	}
-
-	v.SetBool(flag)
-	return nil
-}
-
-func scanInt64Value(v reflect.Value, rd Reader, n int) error {
-	num, err := ScanInt64(rd, n)
-	if err != nil {
-		return err
-	}
-
-	v.SetInt(num)
-	return nil
-}
-
-func scanUint64Value(v reflect.Value, rd Reader, n int) error {
-	num, err := ScanUint64(rd, n)
-	if err != nil {
-		return err
-	}
-
-	v.SetUint(num)
-	return nil
-}
-
-func scanFloat32Value(v reflect.Value, rd Reader, n int) error {
-	num, err := ScanFloat32(rd, n)
-	if err != nil {
-		return err
-	}
-
-	v.SetFloat(float64(num))
-	return nil
-}
-
-func scanFloat64Value(v reflect.Value, rd Reader, n int) error {
-	num, err := ScanFloat64(rd, n)
-	if err != nil {
-		return err
-	}
-
-	v.SetFloat(num)
-	return nil
-}
-
-func scanStringValue(v reflect.Value, rd Reader, n int) error {
-	s, err := ScanString(rd, n)
-	if err != nil {
-		return err
-	}
-
-	v.SetString(s)
-	return nil
-}
-
-func scanJSONValue(v reflect.Value, rd Reader, n int) error {
-	// Zero value so it works with SelectOrInsert.
-	// TODO: better handle slices
-	v.Set(reflect.New(v.Type()).Elem())
-
-	if n == -1 {
-		return nil
-	}
-
-	dec := pgjson.NewDecoder(rd)
-	return dec.Decode(v.Addr().Interface())
-}
-
-func scanTimeValue(v reflect.Value, rd Reader, n int) error {
-	tm, err := ScanTime(rd, n)
-	if err != nil {
-		return err
-	}
-
-	ptr := v.Addr().Interface().(*time.Time)
-	*ptr = tm
-
-	return nil
-}
-
-func scanIPValue(v reflect.Value, rd Reader, n int) error {
-	if n == -1 {
-		return nil
-	}
-
-	tmp, err := rd.ReadFullTemp()
-	if err != nil {
-		return err
-	}
-
-	ip := net.ParseIP(internal.BytesToString(tmp))
-	if ip == nil {
-		return fmt.Errorf("pg: invalid ip=%q", tmp)
-	}
-
-	ptr := v.Addr().Interface().(*net.IP)
-	*ptr = ip
-
-	return nil
-}
-
-var zeroIPNetValue = reflect.ValueOf(net.IPNet{})
-
-func scanIPNetValue(v reflect.Value, rd Reader, n int) error {
-	if n == -1 {
-		v.Set(zeroIPNetValue)
-		return nil
-	}
-
-	tmp, err := rd.ReadFullTemp()
-	if err != nil {
-		return err
-	}
-
-	_, ipnet, err := net.ParseCIDR(internal.BytesToString(tmp))
-	if err != nil {
-		return err
-	}
-
-	ptr := v.Addr().Interface().(*net.IPNet)
-	*ptr = *ipnet
-
-	return nil
-}
-
-func scanJSONRawMessageValue(v reflect.Value, rd Reader, n int) error {
-	if n == -1 {
-		v.SetBytes(nil)
-		return nil
-	}
-
-	b, err := rd.ReadFull()
-	if err != nil {
-		return err
-	}
-
-	v.SetBytes(b)
-	return nil
-}
-
-func scanBytesValue(v reflect.Value, rd Reader, n int) error {
-	if n == -1 {
-		v.SetBytes(nil)
-		return nil
-	}
-
-	b, err := ScanBytes(rd, n)
-	if err != nil {
-		return err
-	}
-
-	v.SetBytes(b)
-	return nil
-}
-
-func scanArrayBytesValue(v reflect.Value, rd Reader, n int) error {
-	b := v.Slice(0, v.Len()).Bytes()
-
-	if n == -1 {
-		for i := range b {
-			b[i] = 0
-		}
-		return nil
-	}
-
-	return ReadBytes(rd, b)
-}
-
-func scanValueScannerValue(v reflect.Value, rd Reader, n int) error {
-	if n == -1 {
-		if v.IsNil() {
-			return nil
-		}
-		return v.Interface().(ValueScanner).ScanValue(rd, n)
-	}
-
-	if v.IsNil() {
-		v.Set(reflect.New(v.Type().Elem()))
-	}
-
-	return v.Interface().(ValueScanner).ScanValue(rd, n)
-}
-
-func scanValueScannerAddrValue(v reflect.Value, rd Reader, n int) error {
-	if !v.CanAddr() {
-		return fmt.Errorf("pg: Scan(non-settable %s)", v.Type())
-	}
-	return v.Addr().Interface().(ValueScanner).ScanValue(rd, n)
-}
-
-func scanSQLScannerValue(v reflect.Value, rd Reader, n int) error {
-	if n == -1 {
-		if nilable(v) && v.IsNil() {
-			return nil
-		}
-		return scanSQLScanner(v.Interface().(sql.Scanner), rd, n)
-	}
-
-	if nilable(v) && v.IsNil() {
-		v.Set(reflect.New(v.Type().Elem()))
-	}
-
-	return scanSQLScanner(v.Interface().(sql.Scanner), rd, n)
-}
-
-func scanSQLScannerAddrValue(v reflect.Value, rd Reader, n int) error {
-	if !v.CanAddr() {
-		return fmt.Errorf("pg: Scan(non-settable %s)", v.Type())
-	}
-	return scanSQLScanner(v.Addr().Interface().(sql.Scanner), rd, n)
-}
-
-func scanSQLScanner(scanner sql.Scanner, rd Reader, n int) error {
-	if n == -1 {
-		return scanner.Scan(nil)
-	}
-
-	tmp, err := rd.ReadFullTemp()
-	if err != nil {
-		return err
-	}
-	return scanner.Scan(tmp)
-}
diff --git a/vendor/github.com/go-pg/pg/v10/types/time.go b/vendor/github.com/go-pg/pg/v10/types/time.go
deleted file mode 100644
index e68a7a19a..000000000
--- a/vendor/github.com/go-pg/pg/v10/types/time.go
+++ /dev/null
@@ -1,56 +0,0 @@
-package types
-
-import (
-	"time"
-
-	"github.com/go-pg/pg/v10/internal"
-)
-
-const (
-	dateFormat         = "2006-01-02"
-	timeFormat         = "15:04:05.999999999"
-	timestampFormat    = "2006-01-02 15:04:05.999999999"
-	timestamptzFormat  = "2006-01-02 15:04:05.999999999-07:00:00"
-	timestamptzFormat2 = "2006-01-02 15:04:05.999999999-07:00"
-	timestamptzFormat3 = "2006-01-02 15:04:05.999999999-07"
-)
-
-func ParseTime(b []byte) (time.Time, error) {
-	s := internal.BytesToString(b)
-	return ParseTimeString(s)
-}
-
-func ParseTimeString(s string) (time.Time, error) {
-	switch l := len(s); {
-	case l <= len(timeFormat):
-		if s[2] == ':' {
-			return time.ParseInLocation(timeFormat, s, time.UTC)
-		}
-		return time.ParseInLocation(dateFormat, s, time.UTC)
-	default:
-		if s[10] == 'T' {
-			return time.Parse(time.RFC3339Nano, s)
-		}
-		if c := s[l-9]; c == '+' || c == '-' {
-			return time.Parse(timestamptzFormat, s)
-		}
-		if c := s[l-6]; c == '+' || c == '-' {
-			return time.Parse(timestamptzFormat2, s)
-		}
-		if c := s[l-3]; c == '+' || c == '-' {
-			return time.Parse(timestamptzFormat3, s)
-		}
-		return time.ParseInLocation(timestampFormat, s, time.UTC)
-	}
-}
-
-func AppendTime(b []byte, tm time.Time, flags int) []byte {
-	if flags == 1 {
-		b = append(b, '\'')
-	}
-	b = tm.UTC().AppendFormat(b, timestamptzFormat)
-	if flags == 1 {
-		b = append(b, '\'')
-	}
-	return b
-}
diff --git a/vendor/github.com/go-pg/pg/v10/types/types.go b/vendor/github.com/go-pg/pg/v10/types/types.go
deleted file mode 100644
index 718ac2933..000000000
--- a/vendor/github.com/go-pg/pg/v10/types/types.go
+++ /dev/null
@@ -1,37 +0,0 @@
-package types
-
-import (
-	"github.com/go-pg/pg/v10/internal/pool"
-)
-
-type Reader = pool.Reader
-
-type ValueScanner interface {
-	ScanValue(rd Reader, n int) error
-}
-
-type ValueAppender interface {
-	AppendValue(b []byte, flags int) ([]byte, error)
-}
-
-//------------------------------------------------------------------------------
-
-// Safe represents a safe SQL query.
-type Safe string
-
-var _ ValueAppender = (*Safe)(nil)
-
-func (q Safe) AppendValue(b []byte, flags int) ([]byte, error) {
-	return append(b, q...), nil
-}
-
-//------------------------------------------------------------------------------
-
-// Ident represents a SQL identifier, e.g. table or column name.
-type Ident string
-
-var _ ValueAppender = (*Ident)(nil)
-
-func (f Ident) AppendValue(b []byte, flags int) ([]byte, error) {
-	return AppendIdent(b, string(f), flags), nil
-}