Make pgconn.ConnectError and pgconn.ParseConfigError public

jackc · jackc · commit 5d26bbefd81a · 2024-01-12T17:52:25.000-06:00
fixes #1773
diff --git a/pgconn/config.go b/pgconn/config.go
@@ -237,12 +237,12 @@ func ParseConfigWithOptions(connString string, options ParseConfigOptions) (*Con
 		if strings.HasPrefix(connString, "postgres://") || strings.HasPrefix(connString, "postgresql://") {
 			connStringSettings, err = parseURLSettings(connString)
 			if err != nil {
-				return nil, &parseConfigError{connString: connString, msg: "failed to parse as URL", err: err}
+				return nil, &ParseConfigError{ConnString: connString, msg: "failed to parse as URL", err: err}
 			}
 		} else {
 			connStringSettings, err = parseDSNSettings(connString)
 			if err != nil {
-				return nil, &parseConfigError{connString: connString, msg: "failed to parse as DSN", err: err}
+				return nil, &ParseConfigError{ConnString: connString, msg: "failed to parse as DSN", err: err}
 			}
 		}
 	}
@@ -251,7 +251,7 @@ func ParseConfigWithOptions(connString string, options ParseConfigOptions) (*Con
 	if service, present := settings["service"]; present {
 		serviceSettings, err := parseServiceSettings(settings["servicefile"], service)
 		if err != nil {
-			return nil, &parseConfigError{connString: connString, msg: "failed to read service", err: err}
+			return nil, &ParseConfigError{ConnString: connString, msg: "failed to read service", err: err}
 		}
 
 		settings = mergeSettings(defaultSettings, envSettings, serviceSettings, connStringSettings)
@@ -278,7 +278,7 @@ func ParseConfigWithOptions(connString string, options ParseConfigOptions) (*Con
 	if connectTimeoutSetting, present := settings["connect_timeout"]; present {
 		connectTimeout, err := parseConnectTimeoutSetting(connectTimeoutSetting)
 		if err != nil {
-			return nil, &parseConfigError{connString: connString, msg: "invalid connect_timeout", err: err}
+			return nil, &ParseConfigError{ConnString: connString, msg: "invalid connect_timeout", err: err}
 		}
 		config.ConnectTimeout = connectTimeout
 		config.DialFunc = makeConnectTimeoutDialFunc(connectTimeout)
@@ -340,7 +340,7 @@ func ParseConfigWithOptions(connString string, options ParseConfigOptions) (*Con
 
 		port, err := parsePort(portStr)
 		if err != nil {
-			return nil, &parseConfigError{connString: connString, msg: "invalid port", err: err}
+			return nil, &ParseConfigError{ConnString: connString, msg: "invalid port", err: err}
 		}
 
 		var tlsConfigs []*tls.Config
@@ -352,7 +352,7 @@ func ParseConfigWithOptions(connString string, options ParseConfigOptions) (*Con
 			var err error
 			tlsConfigs, err = configTLS(settings, host, options)
 			if err != nil {
-				return nil, &parseConfigError{connString: connString, msg: "failed to configure TLS", err: err}
+				return nil, &ParseConfigError{ConnString: connString, msg: "failed to configure TLS", err: err}
 			}
 		}
 
@@ -396,7 +396,7 @@ func ParseConfigWithOptions(connString string, options ParseConfigOptions) (*Con
 	case "any":
 		// do nothing
 	default:
-		return nil, &parseConfigError{connString: connString, msg: fmt.Sprintf("unknown target_session_attrs value: %v", tsa)}
+		return nil, &ParseConfigError{ConnString: connString, msg: fmt.Sprintf("unknown target_session_attrs value: %v", tsa)}
 	}
 
 	return config, nil
diff --git a/pgconn/errors.go b/pgconn/errors.go
@@ -57,22 +57,23 @@ func (pe *PgError) SQLState() string {
 	return pe.Code
 }
 
-type connectError struct {
-	config *Config
+// ConnectError is the error returned when a connection attempt fails.
+type ConnectError struct {
+	Config *Config // The configuration that was used in the connection attempt.
 	msg    string
 	err    error
 }
 
-func (e *connectError) Error() string {
+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)
+	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 {
+func (e *ConnectError) Unwrap() error {
 	return e.err
 }
 
@@ -88,21 +89,22 @@ func (e *connLockError) Error() string {
 	return e.status
 }
 
-type parseConfigError struct {
-	connString string
+// 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.
 	msg        string
 	err        error
 }
 
-func (e *parseConfigError) Error() string {
-	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
 }
 
diff --git a/pgconn/export_test.go b/pgconn/export_test.go
@@ -3,8 +3,8 @@
 package pgconn
 
 func NewParseConfigError(conn, msg string, err error) error {
-	return &parseConfigError{
-		connString: conn,
+	return &ParseConfigError{
+		ConnString: conn,
 		msg:        msg,
 		err:        err,
 	}
diff --git a/pgconn/pgconn.go b/pgconn/pgconn.go
@@ -152,11 +152,11 @@ func ConnectConfig(octx context.Context, config *Config) (pgConn *PgConn, err er
 	ctx := octx
 	fallbackConfigs, err = expandWithIPs(ctx, config.LookupFunc, fallbackConfigs)
 	if err != nil {
-		return nil, &connectError{config: config, msg: "hostname resolving error", err: err}
+		return nil, &ConnectError{Config: config, msg: "hostname resolving error", err: err}
 	}
 
 	if len(fallbackConfigs) == 0 {
-		return nil, &connectError{config: config, msg: "hostname resolving error", err: errors.New("ip addr wasn't found")}
+		return nil, &ConnectError{Config: config, msg: "hostname resolving error", err: errors.New("ip addr wasn't found")}
 	}
 
 	foundBestServer := false
@@ -178,7 +178,7 @@ func ConnectConfig(octx context.Context, config *Config) (pgConn *PgConn, err er
 			foundBestServer = true
 			break
 		} else if pgerr, ok := err.(*PgError); ok {
-			err = &connectError{config: config, msg: "server error", err: pgerr}
+			err = &ConnectError{Config: config, msg: "server error", err: pgerr}
 			const ERRCODE_INVALID_PASSWORD = "28P01"                    // wrong password
 			const ERRCODE_INVALID_AUTHORIZATION_SPECIFICATION = "28000" // wrong password or bad pg_hba.conf settings
 			const ERRCODE_INVALID_CATALOG_NAME = "3D000"                // db does not exist
@@ -189,7 +189,7 @@ func ConnectConfig(octx context.Context, config *Config) (pgConn *PgConn, err er
 				pgerr.Code == ERRCODE_INSUFFICIENT_PRIVILEGE {
 				break
 			}
-		} else if cerr, ok := err.(*connectError); ok {
+		} else if cerr, ok := err.(*ConnectError); ok {
 			if _, ok := cerr.err.(*NotPreferredError); ok {
 				fallbackConfig = fc
 			}
@@ -199,7 +199,7 @@ func ConnectConfig(octx context.Context, config *Config) (pgConn *PgConn, err er
 	if !foundBestServer && fallbackConfig != nil {
 		pgConn, err = connect(ctx, config, fallbackConfig, true)
 		if pgerr, ok := err.(*PgError); ok {
-			err = &connectError{config: config, msg: "server error", err: pgerr}
+			err = &ConnectError{Config: config, msg: "server error", err: pgerr}
 		}
 	}
 
@@ -211,7 +211,7 @@ func ConnectConfig(octx context.Context, config *Config) (pgConn *PgConn, err er
 		err := config.AfterConnect(ctx, pgConn)
 		if err != nil {
 			pgConn.conn.Close()
-			return nil, &connectError{config: config, msg: "AfterConnect error", err: err}
+			return nil, &ConnectError{Config: config, msg: "AfterConnect error", err: err}
 		}
 	}
 
@@ -283,7 +283,7 @@ func connect(ctx context.Context, config *Config, fallbackConfig *FallbackConfig
 	network, address := NetworkAddress(fallbackConfig.Host, fallbackConfig.Port)
 	netConn, err := config.DialFunc(ctx, network, address)
 	if err != nil {
-		return nil, &connectError{config: config, msg: "dial error", err: normalizeTimeoutError(ctx, err)}
+		return nil, &ConnectError{Config: config, msg: "dial error", err: normalizeTimeoutError(ctx, err)}
 	}
 
 	pgConn.conn = netConn
@@ -295,7 +295,7 @@ func connect(ctx context.Context, config *Config, fallbackConfig *FallbackConfig
 		pgConn.contextWatcher.Unwatch() // Always unwatch `netConn` after TLS.
 		if err != nil {
 			netConn.Close()
-			return nil, &connectError{config: config, msg: "tls error", err: normalizeTimeoutError(ctx, err)}
+			return nil, &ConnectError{Config: config, msg: "tls error", err: normalizeTimeoutError(ctx, err)}
 		}
 
 		pgConn.conn = nbTLSConn
@@ -336,7 +336,7 @@ func connect(ctx context.Context, config *Config, fallbackConfig *FallbackConfig
 	pgConn.frontend.Send(&startupMsg)
 	if err := pgConn.flushWithPotentialWriteReadDeadlock(); err != nil {
 		pgConn.conn.Close()
-		return nil, &connectError{config: config, msg: "failed to write startup message", err: normalizeTimeoutError(ctx, err)}
+		return nil, &ConnectError{Config: config, msg: "failed to write startup message", err: normalizeTimeoutError(ctx, err)}
 	}
 
 	for {
@@ -346,7 +346,7 @@ func connect(ctx context.Context, config *Config, fallbackConfig *FallbackConfig
 			if err, ok := err.(*PgError); ok {
 				return nil, err
 			}
-			return nil, &connectError{config: config, msg: "failed to receive message", err: normalizeTimeoutError(ctx, err)}
+			return nil, &ConnectError{Config: config, msg: "failed to receive message", err: normalizeTimeoutError(ctx, err)}
 		}
 
 		switch msg := msg.(type) {
@@ -359,26 +359,26 @@ func connect(ctx context.Context, config *Config, fallbackConfig *FallbackConfig
 			err = pgConn.txPasswordMessage(pgConn.config.Password)
 			if err != nil {
 				pgConn.conn.Close()
-				return nil, &connectError{config: config, msg: "failed to write password message", err: err}
+				return nil, &ConnectError{Config: config, msg: "failed to write password message", err: err}
 			}
 		case *pgproto3.AuthenticationMD5Password:
 			digestedPassword := "md5" + hexMD5(hexMD5(pgConn.config.Password+pgConn.config.User)+string(msg.Salt[:]))
 			err = pgConn.txPasswordMessage(digestedPassword)
 			if err != nil {
 				pgConn.conn.Close()
-				return nil, &connectError{config: config, msg: "failed to write password message", err: err}
+				return nil, &ConnectError{Config: config, msg: "failed to write password message", err: err}
 			}
 		case *pgproto3.AuthenticationSASL:
 			err = pgConn.scramAuth(msg.AuthMechanisms)
 			if err != nil {
 				pgConn.conn.Close()
-				return nil, &connectError{config: config, msg: "failed SASL auth", err: err}
+				return nil, &ConnectError{Config: config, msg: "failed SASL auth", err: err}
 			}
 		case *pgproto3.AuthenticationGSS:
 			err = pgConn.gssAuth()
 			if err != nil {
 				pgConn.conn.Close()
-				return nil, &connectError{config: config, msg: "failed GSS auth", err: err}
+				return nil, &ConnectError{Config: config, msg: "failed GSS auth", err: err}
 			}
 		case *pgproto3.ReadyForQuery:
 			pgConn.status = connStatusIdle
@@ -396,7 +396,7 @@ func connect(ctx context.Context, config *Config, fallbackConfig *FallbackConfig
 						return pgConn, nil
 					}
 					pgConn.conn.Close()
-					return nil, &connectError{config: config, msg: "ValidateConnect failed", err: err}
+					return nil, &ConnectError{Config: config, msg: "ValidateConnect failed", err: err}
 				}
 			}
 			return pgConn, nil
@@ -407,7 +407,7 @@ func connect(ctx context.Context, config *Config, fallbackConfig *FallbackConfig
 			return nil, ErrorResponseToPgError(msg)
 		default:
 			pgConn.conn.Close()
-			return nil, &connectError{config: config, msg: "received unexpected message", err: err}
+			return nil, &ConnectError{Config: config, msg: "received unexpected message", err: err}
 		}
 	}
 }

Original file line number	Diff line number	Diff line change
`@@ -237,12 +237,12 @@ func ParseConfigWithOptions(connString string, options ParseConfigOptions) (*Con`
`237`	`237`	`if strings.HasPrefix(connString, "postgres://") \|\| strings.HasPrefix(connString, "postgresql://") {`
`238`	`238`	`connStringSettings, err = parseURLSettings(connString)`
`239`	`239`	`if err != nil {`
`240`		`- return nil, &parseConfigError{connString: connString, msg: "failed to parse as URL", err: err}`
	`240`	`+ return nil, &ParseConfigError{ConnString: connString, msg: "failed to parse as URL", err: err}`
`241`	`241`	`}`
`242`	`242`	`} else {`
`243`	`243`	`connStringSettings, err = parseDSNSettings(connString)`
`244`	`244`	`if err != nil {`
`245`		`- return nil, &parseConfigError{connString: connString, msg: "failed to parse as DSN", err: err}`
	`245`	`+ return nil, &ParseConfigError{ConnString: connString, msg: "failed to parse as DSN", err: err}`
`246`	`246`	`}`
`247`	`247`	`}`
`248`	`248`	`}`
`@@ -251,7 +251,7 @@ func ParseConfigWithOptions(connString string, options ParseConfigOptions) (*Con`
`251`	`251`	`if service, present := settings["service"]; present {`
`252`	`252`	`serviceSettings, err := parseServiceSettings(settings["servicefile"], service)`
`253`	`253`	`if err != nil {`
`254`		`- return nil, &parseConfigError{connString: connString, msg: "failed to read service", err: err}`
	`254`	`+ return nil, &ParseConfigError{ConnString: connString, msg: "failed to read service", err: err}`
`255`	`255`	`}`
`256`	`256`
`257`	`257`	`settings = mergeSettings(defaultSettings, envSettings, serviceSettings, connStringSettings)`
`@@ -278,7 +278,7 @@ func ParseConfigWithOptions(connString string, options ParseConfigOptions) (*Con`
`278`	`278`	`if connectTimeoutSetting, present := settings["connect_timeout"]; present {`
`279`	`279`	`connectTimeout, err := parseConnectTimeoutSetting(connectTimeoutSetting)`
`280`	`280`	`if err != nil {`
`281`		`- return nil, &parseConfigError{connString: connString, msg: "invalid connect_timeout", err: err}`
	`281`	`+ return nil, &ParseConfigError{ConnString: connString, msg: "invalid connect_timeout", err: err}`
`282`	`282`	`}`
`283`	`283`	`config.ConnectTimeout = connectTimeout`
`284`	`284`	`config.DialFunc = makeConnectTimeoutDialFunc(connectTimeout)`
`@@ -340,7 +340,7 @@ func ParseConfigWithOptions(connString string, options ParseConfigOptions) (*Con`
`340`	`340`
`341`	`341`	`port, err := parsePort(portStr)`
`342`	`342`	`if err != nil {`
`343`		`- return nil, &parseConfigError{connString: connString, msg: "invalid port", err: err}`
	`343`	`+ return nil, &ParseConfigError{ConnString: connString, msg: "invalid port", err: err}`
`344`	`344`	`}`
`345`	`345`
`346`	`346`	`var tlsConfigs []*tls.Config`
`@@ -352,7 +352,7 @@ func ParseConfigWithOptions(connString string, options ParseConfigOptions) (*Con`
`352`	`352`	`var err error`
`353`	`353`	`tlsConfigs, err = configTLS(settings, host, options)`
`354`	`354`	`if err != nil {`
`355`		`- return nil, &parseConfigError{connString: connString, msg: "failed to configure TLS", err: err}`
	`355`	`+ return nil, &ParseConfigError{ConnString: connString, msg: "failed to configure TLS", err: err}`
`356`	`356`	`}`
`357`	`357`	`}`
`358`	`358`
`@@ -396,7 +396,7 @@ func ParseConfigWithOptions(connString string, options ParseConfigOptions) (*Con`
`396`	`396`	`case "any":`
`397`	`397`	`// do nothing`
`398`	`398`	`default:`
`399`		`- return nil, &parseConfigError{connString: connString, msg: fmt.Sprintf("unknown target_session_attrs value: %v", tsa)}`
	`399`	`+ return nil, &ParseConfigError{ConnString: connString, msg: fmt.Sprintf("unknown target_session_attrs value: %v", tsa)}`
`400`	`400`	`}`
`401`	`401`
`402`	`402`	`return config, nil`
Original file line number	Diff line number	Diff line change
`@@ -57,22 +57,23 @@ func (pe *PgError) SQLState() string {`
`57`	`57`	`return pe.Code`
`58`	`58`	`}`
`59`	`59`
`60`		`-type connectError struct {`
`61`		`- config *Config`
	`60`	`+// ConnectError is the error returned when a connection attempt fails.`
	`61`	`+type ConnectError struct {`
	`62`	`+ Config *Config // The configuration that was used in the connection attempt.`
`62`	`63`	`msg string`
`63`	`64`	`err error`
`64`	`65`	`}`
`65`	`66`
`66`		`-func (e *connectError) Error() string {`
	`67`	`+func (e *ConnectError) Error() string {`
`67`	`68`	`sb := &strings.Builder{}`
`68`		- 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)
	`69`	+ 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)
`69`	`70`	`if e.err != nil {`
`70`	`71`	`fmt.Fprintf(sb, " (%s)", e.err.Error())`
`71`	`72`	`}`
`72`	`73`	`return sb.String()`
`73`	`74`	`}`
`74`	`75`
`75`		`-func (e *connectError) Unwrap() error {`
	`76`	`+func (e *ConnectError) Unwrap() error {`
`76`	`77`	`return e.err`
`77`	`78`	`}`
`78`	`79`
`@@ -88,21 +89,22 @@ func (e *connLockError) Error() string {`
`88`	`89`	`return e.status`
`89`	`90`	`}`
`90`	`91`
`91`		`-type parseConfigError struct {`
`92`		`- connString string`
	`92`	`+// ParseConfigError is the error returned when a connection string cannot be parsed.`
	`93`	`+type ParseConfigError struct {`
	`94`	`+ ConnString string // The connection string that could not be parsed.`
`93`	`95`	`msg string`
`94`	`96`	`err error`
`95`	`97`	`}`
`96`	`98`
`97`		`-func (e *parseConfigError) Error() string {`
`98`		`- connString := redactPW(e.connString)`
	`99`	`+func (e *ParseConfigError) Error() string {`
	`100`	`+ connString := redactPW(e.ConnString)`
`99`	`101`	`if e.err == nil {`
`100`	`102`	return fmt.Sprintf("cannot parse `%s`: %s", connString, e.msg)
`101`	`103`	`}`
`102`	`104`	return fmt.Sprintf("cannot parse `%s`: %s (%s)", connString, e.msg, e.err.Error())
`103`	`105`	`}`
`104`	`106`
`105`		`-func (e *parseConfigError) Unwrap() error {`
	`107`	`+func (e *ParseConfigError) Unwrap() error {`
`106`	`108`	`return e.err`
`107`	`109`	`}`
`108`	`110`
Original file line number	Diff line number	Diff line change
`@@ -152,11 +152,11 @@ func ConnectConfig(octx context.Context, config Config) (pgConn PgConn, err er`
`152`	`152`	`ctx := octx`
`153`	`153`	`fallbackConfigs, err = expandWithIPs(ctx, config.LookupFunc, fallbackConfigs)`
`154`	`154`	`if err != nil {`
`155`		`- return nil, &connectError{config: config, msg: "hostname resolving error", err: err}`
	`155`	`+ return nil, &ConnectError{Config: config, msg: "hostname resolving error", err: err}`
`156`	`156`	`}`
`157`	`157`
`158`	`158`	`if len(fallbackConfigs) == 0 {`
`159`		`- return nil, &connectError{config: config, msg: "hostname resolving error", err: errors.New("ip addr wasn't found")}`
	`159`	`+ return nil, &ConnectError{Config: config, msg: "hostname resolving error", err: errors.New("ip addr wasn't found")}`
`160`	`160`	`}`
`161`	`161`
`162`	`162`	`foundBestServer := false`
`@@ -178,7 +178,7 @@ func ConnectConfig(octx context.Context, config Config) (pgConn PgConn, err er`
`178`	`178`	`foundBestServer = true`
`179`	`179`	`break`
`180`	`180`	`} else if pgerr, ok := err.(*PgError); ok {`
`181`		`- err = &connectError{config: config, msg: "server error", err: pgerr}`
	`181`	`+ err = &ConnectError{Config: config, msg: "server error", err: pgerr}`
`182`	`182`	`const ERRCODE_INVALID_PASSWORD = "28P01" // wrong password`
`183`	`183`	`const ERRCODE_INVALID_AUTHORIZATION_SPECIFICATION = "28000" // wrong password or bad pg_hba.conf settings`
`184`	`184`	`const ERRCODE_INVALID_CATALOG_NAME = "3D000" // db does not exist`
`@@ -189,7 +189,7 @@ func ConnectConfig(octx context.Context, config Config) (pgConn PgConn, err er`
`189`	`189`	`pgerr.Code == ERRCODE_INSUFFICIENT_PRIVILEGE {`
`190`	`190`	`break`
`191`	`191`	`}`
`192`		`- } else if cerr, ok := err.(*connectError); ok {`
	`192`	`+ } else if cerr, ok := err.(*ConnectError); ok {`
`193`	`193`	`if _, ok := cerr.err.(*NotPreferredError); ok {`
`194`	`194`	`fallbackConfig = fc`
`195`	`195`	`}`
`@@ -199,7 +199,7 @@ func ConnectConfig(octx context.Context, config Config) (pgConn PgConn, err er`
`199`	`199`	`if !foundBestServer && fallbackConfig != nil {`
`200`	`200`	`pgConn, err = connect(ctx, config, fallbackConfig, true)`
`201`	`201`	`if pgerr, ok := err.(*PgError); ok {`
`202`		`- err = &connectError{config: config, msg: "server error", err: pgerr}`
	`202`	`+ err = &ConnectError{Config: config, msg: "server error", err: pgerr}`
`203`	`203`	`}`
`204`	`204`	`}`
`205`	`205`
`@@ -211,7 +211,7 @@ func ConnectConfig(octx context.Context, config Config) (pgConn PgConn, err er`
`211`	`211`	`err := config.AfterConnect(ctx, pgConn)`
`212`	`212`	`if err != nil {`
`213`	`213`	`pgConn.conn.Close()`
`214`		`- return nil, &connectError{config: config, msg: "AfterConnect error", err: err}`
	`214`	`+ return nil, &ConnectError{Config: config, msg: "AfterConnect error", err: err}`
`215`	`215`	`}`
`216`	`216`	`}`
`217`	`217`
`@@ -283,7 +283,7 @@ func connect(ctx context.Context, config Config, fallbackConfig FallbackConfig`
`283`	`283`	`network, address := NetworkAddress(fallbackConfig.Host, fallbackConfig.Port)`
`284`	`284`	`netConn, err := config.DialFunc(ctx, network, address)`
`285`	`285`	`if err != nil {`
`286`		`- return nil, &connectError{config: config, msg: "dial error", err: normalizeTimeoutError(ctx, err)}`
	`286`	`+ return nil, &ConnectError{Config: config, msg: "dial error", err: normalizeTimeoutError(ctx, err)}`
`287`	`287`	`}`
`288`	`288`
`289`	`289`	`pgConn.conn = netConn`
`@@ -295,7 +295,7 @@ func connect(ctx context.Context, config Config, fallbackConfig FallbackConfig`
`295`	`295`	pgConn.contextWatcher.Unwatch() // Always unwatch `netConn` after TLS.
`296`	`296`	`if err != nil {`
`297`	`297`	`netConn.Close()`
`298`		`- return nil, &connectError{config: config, msg: "tls error", err: normalizeTimeoutError(ctx, err)}`
	`298`	`+ return nil, &ConnectError{Config: config, msg: "tls error", err: normalizeTimeoutError(ctx, err)}`
`299`	`299`	`}`
`300`	`300`
`301`	`301`	`pgConn.conn = nbTLSConn`
`@@ -336,7 +336,7 @@ func connect(ctx context.Context, config Config, fallbackConfig FallbackConfig`
`336`	`336`	`pgConn.frontend.Send(&startupMsg)`
`337`	`337`	`if err := pgConn.flushWithPotentialWriteReadDeadlock(); err != nil {`
`338`	`338`	`pgConn.conn.Close()`
`339`		`- return nil, &connectError{config: config, msg: "failed to write startup message", err: normalizeTimeoutError(ctx, err)}`
	`339`	`+ return nil, &ConnectError{Config: config, msg: "failed to write startup message", err: normalizeTimeoutError(ctx, err)}`
`340`	`340`	`}`
`341`	`341`
`342`	`342`	`for {`
`@@ -346,7 +346,7 @@ func connect(ctx context.Context, config Config, fallbackConfig FallbackConfig`
`346`	`346`	`if err, ok := err.(*PgError); ok {`
`347`	`347`	`return nil, err`
`348`	`348`	`}`
`349`		`- return nil, &connectError{config: config, msg: "failed to receive message", err: normalizeTimeoutError(ctx, err)}`
	`349`	`+ return nil, &ConnectError{Config: config, msg: "failed to receive message", err: normalizeTimeoutError(ctx, err)}`
`350`	`350`	`}`
`351`	`351`
`352`	`352`	`switch msg := msg.(type) {`
`@@ -359,26 +359,26 @@ func connect(ctx context.Context, config Config, fallbackConfig FallbackConfig`
`359`	`359`	`err = pgConn.txPasswordMessage(pgConn.config.Password)`
`360`	`360`	`if err != nil {`
`361`	`361`	`pgConn.conn.Close()`
`362`		`- return nil, &connectError{config: config, msg: "failed to write password message", err: err}`
	`362`	`+ return nil, &ConnectError{Config: config, msg: "failed to write password message", err: err}`
`363`	`363`	`}`
`364`	`364`	`case *pgproto3.AuthenticationMD5Password:`
`365`	`365`	`digestedPassword := "md5" + hexMD5(hexMD5(pgConn.config.Password+pgConn.config.User)+string(msg.Salt[:]))`
`366`	`366`	`err = pgConn.txPasswordMessage(digestedPassword)`
`367`	`367`	`if err != nil {`
`368`	`368`	`pgConn.conn.Close()`
`369`		`- return nil, &connectError{config: config, msg: "failed to write password message", err: err}`
	`369`	`+ return nil, &ConnectError{Config: config, msg: "failed to write password message", err: err}`
`370`	`370`	`}`
`371`	`371`	`case *pgproto3.AuthenticationSASL:`
`372`	`372`	`err = pgConn.scramAuth(msg.AuthMechanisms)`
`373`	`373`	`if err != nil {`
`374`	`374`	`pgConn.conn.Close()`
`375`		`- return nil, &connectError{config: config, msg: "failed SASL auth", err: err}`
	`375`	`+ return nil, &ConnectError{Config: config, msg: "failed SASL auth", err: err}`
`376`	`376`	`}`
`377`	`377`	`case *pgproto3.AuthenticationGSS:`
`378`	`378`	`err = pgConn.gssAuth()`
`379`	`379`	`if err != nil {`
`380`	`380`	`pgConn.conn.Close()`
`381`		`- return nil, &connectError{config: config, msg: "failed GSS auth", err: err}`
	`381`	`+ return nil, &ConnectError{Config: config, msg: "failed GSS auth", err: err}`
`382`	`382`	`}`
`383`	`383`	`case *pgproto3.ReadyForQuery:`
`384`	`384`	`pgConn.status = connStatusIdle`
`@@ -396,7 +396,7 @@ func connect(ctx context.Context, config Config, fallbackConfig FallbackConfig`
`396`	`396`	`return pgConn, nil`
`397`	`397`	`}`
`398`	`398`	`pgConn.conn.Close()`
`399`		`- return nil, &connectError{config: config, msg: "ValidateConnect failed", err: err}`
	`399`	`+ return nil, &ConnectError{Config: config, msg: "ValidateConnect failed", err: err}`
`400`	`400`	`}`
`401`	`401`	`}`
`402`	`402`	`return pgConn, nil`
`@@ -407,7 +407,7 @@ func connect(ctx context.Context, config Config, fallbackConfig FallbackConfig`
`407`	`407`	`return nil, ErrorResponseToPgError(msg)`
`408`	`408`	`default:`
`409`	`409`	`pgConn.conn.Close()`
`410`		`- return nil, &connectError{config: config, msg: "received unexpected message", err: err}`
	`410`	`+ return nil, &ConnectError{Config: config, msg: "received unexpected message", err: err}`
`411`	`411`	`}`
`412`	`412`	`}`
`413`	`413`	`}`