use errors functions in mongo package.

Author: qingyang-hu

mongo/change_stream.go

@@ -339,8 +339,8 @@ AggregateExecuteLoop:
 			break AggregateExecuteLoop
 		}
 
-		switch tt := err.(type) {
-		case driver.Error:
+		var tt driver.Error
+		if errors.As(err, &tt) {
 			// If error is not retryable, do not retry.
 			if !tt.RetryableRead() {
 				break AggregateExecuteLoop
@@ -370,7 +370,7 @@ AggregateExecuteLoop:
 
 			// Reset deployment.
 			cs.aggregate.Deployment(cs.createOperationDeployment(server, conn))
-		default:
+		} else {
 			// Do not retry if error is not a driver error.
 			break AggregateExecuteLoop
 		}

mongo/collection.go

@@ -1045,7 +1045,8 @@ func aggregate(a aggregateParams, opts ...options.Lister[options.AggregateOption
 
 	err = op.Execute(a.ctx)
 	if err != nil {
-		if wce, ok := err.(driver.WriteCommandError); ok && wce.WriteConcernError != nil {
+		var wce driver.WriteCommandError
+		if errors.As(err, &wce) && wce.WriteConcernError != nil {
 			return nil, *convertDriverWriteConcernError(wce.WriteConcernError)
 		}
 		return nil, replaceErrors(err)
@@ -2041,8 +2042,8 @@ func (coll *Collection) drop(ctx context.Context) error {
 	err = op.Execute(ctx)
 
 	// ignore namespace not found errors
-	driverErr, ok := err.(driver.Error)
-	if !ok || (ok && !driverErr.NamespaceNotFound()) {
+	var driverErr driver.Error
+	if !errors.As(err, &driverErr) || !driverErr.NamespaceNotFound() {
 		return replaceErrors(err)
 	}
 	return nil

mongo/database.go

@@ -343,8 +343,8 @@ func (db *Database) Drop(ctx context.Context) error {
 
 	err = op.Execute(ctx)
 
-	driverErr, ok := err.(driver.Error)
-	if err != nil && (!ok || !driverErr.NamespaceNotFound()) {
+	var driverErr driver.Error
+	if err != nil && (!errors.As(err, &driverErr) || !driverErr.NamespaceNotFound()) {
 		return replaceErrors(err)
 	}
 	return nil

mongo/errors.go

@@ -57,14 +57,14 @@ func replaceErrors(err error) error {
 	// ignored. For non-DDL write commands (insert, update, etc), acknowledgement
 	// should be be propagated at the result-level: e.g.,
 	// SingleResult.Acknowledged.
-	if err == driver.ErrUnacknowledgedWrite {
+	if errors.Is(err, driver.ErrUnacknowledgedWrite) {
 		return nil
 	}
 
 	if errors.Is(err, topology.ErrTopologyClosed) {
 		return ErrClientDisconnected
 	}
-	if de, ok := err.(driver.Error); ok {
+	if de := new(driver.Error); errors.As(err, de) {
 		return CommandError{
 			Code:    de.Code,
 			Message: de.Message,
@@ -74,7 +74,7 @@ func replaceErrors(err error) error {
 			Raw:     bson.Raw(de.Raw),
 		}
 	}
-	if qe, ok := err.(driver.QueryFailureError); ok {
+	if qe := new(driver.QueryFailureError); errors.As(err, qe) {
 		// qe.Message is "command failure"
 		ce := CommandError{
 			Name:    qe.Message,
@@ -93,15 +93,15 @@ func replaceErrors(err error) error {
 
 		return ce
 	}
-	if me, ok := err.(mongocrypt.Error); ok {
+	if me := new(mongocrypt.Error); errors.As(err, me) {
 		return MongocryptError{Code: me.Code, Message: me.Message}
 	}
 
 	if errors.Is(err, codecutil.ErrNilValue) {
 		return ErrNilValue
 	}
 
-	if marshalErr, ok := err.(codecutil.MarshalError); ok {
+	if marshalErr := new(codecutil.MarshalError); errors.As(err, marshalErr) {
 		return MarshalError{
 			Value: marshalErr.Value,
 			Err:   marshalErr.Err,
@@ -721,12 +721,12 @@ func processWriteError(err error) (returnResult, error) {
 	// ignored. For non-DDL write commands (insert, update, etc), acknowledgement
 	// should be be propagated at the result-level: e.g.,
 	// SingleResult.Acknowledged.
-	if err == driver.ErrUnacknowledgedWrite {
+	if errors.Is(err, driver.ErrUnacknowledgedWrite) {
 		return rrAllUnacknowledged, nil
 	}
 
-	wce, ok := err.(driver.WriteCommandError)
-	if !ok {
+	var wce driver.WriteCommandError
+	if !errors.As(err, &wce) {
 		return rrNone, replaceErrors(err)
 	}
 

mongo/index_view.go

@@ -52,7 +52,8 @@ type IndexModel struct {
 }
 
 func isNamespaceNotFoundError(err error) bool {
-	if de, ok := err.(driver.Error); ok {
+	var de driver.Error
+	if errors.As(err, &de) {
 		return de.Code == 26
 	}
 	return false

mongo/search_index_view.go

@@ -8,6 +8,7 @@ package mongo
 
 import (
 	"context"
+	"errors"
 	"fmt"
 	"strconv"
 
@@ -229,7 +230,8 @@ func (siv SearchIndexView) DropOne(
 		Timeout(siv.coll.client.timeout).Authenticator(siv.coll.client.authenticator)
 
 	err = op.Execute(ctx)
-	if de, ok := err.(driver.Error); ok && de.NamespaceNotFound() {
+	var de driver.Error
+	if errors.As(err, &de) && de.NamespaceNotFound() {
 		return nil
 	}
 	return err

mongo/session.go

@@ -193,7 +193,8 @@ func (s *Session) WithTransaction(
 			default:
 			}
 
-			if cerr, ok := err.(CommandError); ok {
+			var cerr CommandError
+			if errors.As(err, &cerr) {
 				if cerr.HasErrorLabel(driver.UnknownTransactionCommitResult) && !cerr.IsMaxTimeMSExpiredError() {
 					continue
 				}

mongo/with_transactions_test.go

@@ -55,7 +55,8 @@ func TestConvenientTransactions(t *testing.T) {
 			{"killAllSessions", bson.A{}},
 		}).Err()
 		if err != nil {
-			if ce, ok := err.(CommandError); !ok || ce.Code != errorInterrupted {
+			var ce CommandError
+			if !errors.As(err, &ce) || ce.Code != errorInterrupted {
 				t.Fatalf("killAllSessions error: %v", err)
 			}
 		}
@@ -115,8 +116,8 @@ func TestConvenientTransactions(t *testing.T) {
 				return nil, CommandError{Name: "test Error", Labels: []string{driver.TransientTransactionError}}
 			})
 			assert.NotNil(t, err, "expected WithTransaction error, got nil")
-			cmdErr, ok := err.(CommandError)
-			assert.True(t, ok, "expected error type %T, got %T", CommandError{}, err)
+			var cmdErr CommandError
+			assert.True(t, errors.As(err, &cmdErr), "expected error type %T, got %T", cmdErr, err)
 			assert.True(t, cmdErr.HasErrorLabel(driver.TransientTransactionError),
 				"expected error with label %v, got %v", driver.TransientTransactionError, cmdErr)
 		})
@@ -148,8 +149,8 @@ func TestConvenientTransactions(t *testing.T) {
 				return nil, err
 			})
 			assert.NotNil(t, err, "expected WithTransaction error, got nil")
-			cmdErr, ok := err.(CommandError)
-			assert.True(t, ok, "expected error type %T, got %T", CommandError{}, err)
+			var cmdErr CommandError
+			assert.True(t, errors.As(err, &cmdErr), "expected error type %T, got %T", cmdErr, err)
 			assert.True(t, cmdErr.HasErrorLabel(driver.UnknownTransactionCommitResult),
 				"expected error with label %v, got %v", driver.UnknownTransactionCommitResult, cmdErr)
 		})
@@ -181,8 +182,8 @@ func TestConvenientTransactions(t *testing.T) {
 				return nil, err
 			})
 			assert.NotNil(t, err, "expected WithTransaction error, got nil")
-			cmdErr, ok := err.(CommandError)
-			assert.True(t, ok, "expected error type %T, got %T", CommandError{}, err)
+			var cmdErr CommandError
+			assert.True(t, errors.As(err, &cmdErr), "expected error type %T, got %T", cmdErr, err)
 			assert.True(t, cmdErr.HasErrorLabel(driver.TransientTransactionError),
 				"expected error with label %v, got %v", driver.TransientTransactionError, cmdErr)
 		})
@@ -392,7 +393,8 @@ func TestConvenientTransactions(t *testing.T) {
 				{"killAllSessions", bson.A{}},
 			}).Err()
 			if err != nil {
-				if ce, ok := err.(CommandError); !ok || ce.Code != errorInterrupted {
+				var ce CommandError
+				if !errors.As(err, &ce) || ce.Code != errorInterrupted {
 					t.Fatalf("killAllSessions error: %v", err)
 				}
 			}