增加websocket支持

vendor/github.com/jackc/pgx/v5/pgconn/errors.go

@@ -12,14 +12,13 @@ import (
 
 // SafeToRetry checks if the err is guaranteed to have occurred before sending any data to the server.
 func SafeToRetry(err error) bool {
-	var retryableErr interface{ SafeToRetry() bool }
-	if errors.As(err, &retryableErr) {
-		return retryableErr.SafeToRetry()
+	if e, ok := err.(interface{ SafeToRetry() bool }); ok {
+		return e.SafeToRetry()
 	}
 	return false
 }
 
-// Timeout checks if err was caused by a timeout. To be specific, it is true if err was caused within pgconn by a
+// Timeout checks if err was was caused by a timeout. To be specific, it is true if err was caused within pgconn by a
 // context.DeadlineExceeded or an implementer of net.Error where Timeout() is true.
 func Timeout(err error) bool {
 	var timeoutErr *errTimeout
@@ -30,24 +29,23 @@ func Timeout(err error) bool {
 // http://www.postgresql.org/docs/11/static/protocol-error-fields.html for
 // detailed field description.
 type PgError struct {
-	Severity            string
-	SeverityUnlocalized string
-	Code                string
-	Message             string
-	Detail              string
-	Hint                string
-	Position            int32
-	InternalPosition    int32
-	InternalQuery       string
-	Where               string
-	SchemaName          string
-	TableName           string
-	ColumnName          string
-	DataTypeName        string
-	ConstraintName      string
-	File                string
-	Line                int32
-	Routine             string
+	Severity         string
+	Code             string
+	Message          string
+	Detail           string
+	Hint             string
+	Position         int32
+	InternalPosition int32
+	InternalQuery    string
+	Where            string
+	SchemaName       string
+	TableName        string
+	ColumnName       string
+	DataTypeName     string
+	ConstraintName   string
+	File             string
+	Line             int32
+	Routine          string
 }
 
 func (pe *PgError) Error() string {
@@ -59,37 +57,22 @@ func (pe *PgError) SQLState() string {
 	return pe.Code
 }
 
-// ConnectError is the error returned when a connection attempt fails.
-type ConnectError struct {
-	Config *Config // The configuration that was used in the connection attempt.
+type connectError struct {
+	config *Config
+	msg    string
 	err    error
 }
 
-func (e *ConnectError) Error() string {
-	prefix := fmt.Sprintf("failed to connect to `user=%s database=%s`:", e.Config.User, e.Config.Database)
-	details := e.err.Error()
-	if strings.Contains(details, "\n") {
-		return prefix + "\n\t" + strings.ReplaceAll(details, "\n", "\n\t")
-	} else {
-		return prefix + " " + details
+func (e *connectError) Error() string {
+	sb := &strings.Builder{}
+	fmt.Fprintf(sb, "failed to connect to `host=%s user=%s database=%s`: %s", e.config.Host, e.config.User, e.config.Database, e.msg)
+	if e.err != nil {
+		fmt.Fprintf(sb, " (%s)", e.err.Error())
 	}
+	return sb.String()
 }
 
-func (e *ConnectError) Unwrap() error {
-	return e.err
-}
-
-type perDialConnectError struct {
-	address          string
-	originalHostname string
-	err              error
-}
-
-func (e *perDialConnectError) Error() string {
-	return fmt.Sprintf("%s (%s): %s", e.address, e.originalHostname, e.err.Error())
-}
-
-func (e *perDialConnectError) Unwrap() error {
+func (e *connectError) Unwrap() error {
 	return e.err
 }
 
@@ -105,38 +88,33 @@ func (e *connLockError) Error() string {
 	return e.status
 }
 
-// ParseConfigError is the error returned when a connection string cannot be parsed.
-type ParseConfigError struct {
-	ConnString string // The connection string that could not be parsed.
+type parseConfigError struct {
+	connString string
 	msg        string
 	err        error
 }
 
-func (e *ParseConfigError) Error() string {
-	// Now that ParseConfigError is public and ConnString is available to the developer, perhaps it would be better only
-	// return a static string. That would ensure that the error message cannot leak a password. The ConnString field would
-	// allow access to the original string if desired and Unwrap would allow access to the underlying error.
-	connString := redactPW(e.ConnString)
+func (e *parseConfigError) Error() string {
+	connString := redactPW(e.connString)
 	if e.err == nil {
 		return fmt.Sprintf("cannot parse `%s`: %s", connString, e.msg)
 	}
 	return fmt.Sprintf("cannot parse `%s`: %s (%s)", connString, e.msg, e.err.Error())
 }
 
-func (e *ParseConfigError) Unwrap() error {
+func (e *parseConfigError) Unwrap() error {
 	return e.err
 }
 
 func normalizeTimeoutError(ctx context.Context, err error) error {
-	var netErr net.Error
-	if errors.As(err, &netErr) && netErr.Timeout() {
+	if err, ok := err.(net.Error); ok && err.Timeout() {
 		if ctx.Err() == context.Canceled {
 			// Since the timeout was caused by a context cancellation, the actual error is context.Canceled not the timeout error.
 			return context.Canceled
 		} else if ctx.Err() == context.DeadlineExceeded {
 			return &errTimeout{err: ctx.Err()}
 		} else {
-			return &errTimeout{err: netErr}
+			return &errTimeout{err: err}
 		}
 	}
 	return err
@@ -211,10 +189,10 @@ func redactPW(connString string) string {
 			return redactURL(u)
 		}
 	}
-	quotedKV := regexp.MustCompile(`password='[^']*'`)
-	connString = quotedKV.ReplaceAllLiteralString(connString, "password=xxxxx")
-	plainKV := regexp.MustCompile(`password=[^ ]*`)
-	connString = plainKV.ReplaceAllLiteralString(connString, "password=xxxxx")
+	quotedDSN := regexp.MustCompile(`password='[^']*'`)
+	connString = quotedDSN.ReplaceAllLiteralString(connString, "password=xxxxx")
+	plainDSN := regexp.MustCompile(`password=[^ ]*`)
+	connString = plainDSN.ReplaceAllLiteralString(connString, "password=xxxxx")
 	brokenURL := regexp.MustCompile(`:[^:@]+?@`)
 	connString = brokenURL.ReplaceAllLiteralString(connString, ":xxxxxx@")
 	return connString