Add functions to check if an error is a given pgconn error

errors.go

@@ -79,6 +79,11 @@ func (e *connectError) Unwrap() error {
 	return e.err
 }
 
+func IsConnectError(err error) bool {
+	_, ok := err.(*connectError)
+	return ok
+}
+
 type connLockError struct {
 	status string
 }
@@ -91,6 +96,11 @@ func (e *connLockError) Error() string {
 	return e.status
 }
 
+func IsConnLockError(err error) bool {
+	_, ok := err.(*connLockError)
+	return ok
+}
+
 type parseConfigError struct {
 	connString string
 	msg        string
@@ -108,6 +118,11 @@ func (e *parseConfigError) Unwrap() error {
 	return e.err
 }
 
+func IsParseConfigError(err error) bool {
+	_, ok := err.(*parseConfigError)
+	return ok
+}
+
 type pgconnError struct {
 	msg         string
 	err         error
@@ -132,6 +147,11 @@ func (e *pgconnError) Unwrap() error {
 	return e.err
 }
 
+func IsPgConnError(err error) bool {
+	_, ok := err.(*pgconnError)
+	return ok
+}
+
 type contextAlreadyDoneError struct {
 	err error
 }
@@ -148,6 +168,11 @@ func (e *contextAlreadyDoneError) Unwrap() error {
 	return e.err
 }
 
+func IsContextAlreadyDoneError(err error) bool {
+	_, ok := err.(*contextAlreadyDoneError)
+	return ok
+}
+
 type writeError struct {
 	err         error
 	safeToRetry bool
@@ -164,3 +189,8 @@ func (e *writeError) SafeToRetry() bool {
 func (e *writeError) Unwrap() error {
 	return e.err
 }
+
+func IsWriteError(err error) bool {
+	_, ok := err.(*writeError)
+	return ok
+}

errors_test.go

@@ -0,0 +1,51 @@
+package pgconn
+
+import (
+    "errors"
+    "io"
+    "testing"
+
+    "github.com/stretchr/testify/assert"
+)
+
+func TestIsConnectError(t *testing.T) {
+    err := &connectError{msg: "-"}
+    assert.True(t, IsConnectError(err))
+
+    assert.False(t, IsConnectError(io.EOF))
+}
+
+func TestIsConnLockError(t *testing.T) {
+    err := &connLockError{status: "-"}
+    assert.True(t, IsConnLockError(err))
+
+    assert.False(t, IsConnLockError(io.EOF))
+}
+
+func TestIsParseConfigError(t *testing.T) {
+    err := &parseConfigError{msg: "-"}
+    assert.True(t, IsParseConfigError(err))
+
+    assert.False(t, IsParseConfigError(io.EOF))
+}
+
+func TestIsPgConnError(t *testing.T) {
+    err := &pgconnError{msg: "-"}
+    assert.True(t, IsPgConnError(err))
+
+    assert.False(t, IsPgConnError(io.EOF))
+}
+
+func TestIsContextAlreadyDoneError(t *testing.T) {
+    err := &contextAlreadyDoneError{err: errors.New("-")}
+    assert.True(t, IsContextAlreadyDoneError(err))
+
+    assert.False(t, IsContextAlreadyDoneError(io.EOF))
+}
+
+func TestIsWriteError(t *testing.T) {
+    err := &writeError{err: errors.New("-")}
+    assert.True(t, IsWriteError(err))
+
+    assert.False(t, IsWriteError(io.EOF))
+}