Upsert doesn't work well with query where value is []byte format

[ngtuna]

What version of MongoDB are you using (mongod --version)?

v4.0.8

What version of Go are you using (go version)?

1.11.8

What operating system and processor architecture are you using (go env)?

Ubuntu 18.04.1 amd64

What did you do?

Upsert doens't work well with query where value is []byte.

Example:
If I do an upsert with query := bson.M{"hash": hash} (hash [32]byte) in case of overwriting existing record. It says:

Error: E11000 duplicate key error collection: xxx.yyy index: hash_1 dup key: { : \"0xc023e09ff5f2d764fd08bfb92907d2d60cbc76d5acb8c808a26c9ed91278b489\" }"

Only work if I change hash to its string format like this: query := bson.M{"hash": hash.Hex()} - Hex() convert [32]byte to string.

Can you reproduce the issue on the latest development branch?

Haven't tried yet.

[ljluestc]

package main

import (
	"context"
	"crypto/sha256"
	"errors"
	"fmt"
	"time"

	"go.mongodb.org/mongo-driver/bson"
	"go.mongodb.org/mongo-driver/bson/primitive"
	"go.mongodb.org/mongo-driver/mongo"
	"go.mongodb.org/mongo-driver/mongo/options"
)

// Document represents the structure of a document in the collection
type Document struct {
	ID   primitive.ObjectId `json:"_id" bson:"_id"`
	Hash [32]byte           `json:"hash" bson:"hash"` // Stored as binary
	// Hash string             `json:"hash" bson:"hash"` // Alternative: store as string
	Value string `json:"value" bson:"value"`
}

// DatabaseConfig holds MongoDB configuration
type DatabaseConfig struct {
	URI                    string
	Database               string
	ConnectTimeout         time.Duration
	ServerSelectionTimeout time.Duration
	SocketTimeout          time.Duration
}

// Database holds the MongoDB client and configuration
type Database struct {
	Client *mongo.Client
	Config *DatabaseConfig
}

// ErrUnavailable is returned when the database connection is not available
var ErrUnavailable = errors.New("database connection unavailable")

// Connect initializes the MongoDB connection
func (d *Database) Connect() error {
	ctx, cancel := context.WithTimeout(context.Background(), d.Config.ConnectTimeout)
	defer cancel()

	clientOptions := options.Client().
		ApplyURI(d.Config.URI).
		SetConnectTimeout(d.Config.ConnectTimeout).
		SetServerSelectionTimeout(d.Config.ServerSelectionTimeout).
		SetSocketTimeout(d.Config.SocketTimeout)

	client, err := mongo.Connect(ctx, clientOptions)
	if err != nil {
		return err
	}
	d.Client = client
	return nil
}

// CheckConnection verifies if the database connection is active
func (d *Database) CheckConnection() bool {
	if d.Client == nil {
		return false
	}
	ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)
	defer cancel()
	return d.Client.Ping(ctx, nil) == nil
}

// Close terminates the MongoDB connection
func (d *Database) Close() error {
	if d.Client == nil {
		return nil
	}
	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
	defer cancel()
	return d.Client.Disconnect(ctx)
}

// SetupCollection creates the collection with a unique index on the hash field
func (d *Database) SetupCollection() error {
	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
	defer cancel()

	collection := d.Client.Database(d.Config.Database).Collection("documents")
	indexModel := mongo.IndexModel{
		Keys:    bson.D{{"hash", 1}},
		Options: options.Index().SetUnique(true),
	}
	_, err := collection.Indexes().CreateOne(ctx, indexModel)
	return err
}

// UpsertDocumentWithBinary attempts to upsert a document with a [32]byte hash (demonstrates the issue)
func (d *Database) UpsertDocumentWithBinary(hash [32]byte, value string) error {
	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
	defer cancel()

	collection := d.Client.Database(d.Config.Database).Collection("documents")
	query := bson.M{"hash": hash} // Using [32]byte directly
	update := bson.M{
		"$set": bson.M{
			"hash":  hash,
			"value": value,
		},
	}
	opts := options.Update().SetUpsert(true)

	_, err := collection.UpdateOne(ctx, query, update, opts)
	return err
}

// UpsertDocumentWithString upserts a document using the string representation of the hash (workaround)
func (d *Database) UpsertDocumentWithString(hash [32]byte, value string) error {
	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
	defer cancel()

	collection := d.Client.Database(d.Config.Database).Collection("documents")
	hashStr := fmt.Sprintf("%x", hash) // Convert [32]byte to hex string
	query := bson.M{"hash": hashStr}
	update := bson.M{
		"$set": bson.M{
			"hash":  hashStr,
			"value": value,
		},
	}
	opts := options.Update().SetUpsert(true)

	_, err := collection.UpdateOne(ctx, query, update, opts)
	return err
}

// standardizeError normalizes errors for consistent handling
func standardizeError(err error) error {
	if err == mongo.ErrNoDocuments {
		return errors.New("no document found")
	}
	if mongo.IsDuplicateKeyError(err) {
		return errors.New("duplicate key error")
	}
	return err
}

func main() {
	// Initialize database
	database := &Database{
		Config: &DatabaseConfig{
			URI:                    "mongodb://localhost:27017",
			Database:               "testdb",
			ConnectTimeout:         10 * time.Second,
			ServerSelectionTimeout: 5 * time.Second,
			SocketTimeout:          30 * time.Second,
		},
	}

	// Connect to MongoDB
	if err := database.Connect(); err != nil {
		fmt.Printf("Failed to connect: %v\n", err)
		return
	}
	defer database.Close()

	// Check connection
	if !database.CheckConnection() {
		fmt.Println("Database connection unavailable")
		return
	}

	// Setup collection with unique index
	if err := database.SetupCollection(); err != nil {
		fmt.Printf("Failed to setup collection: %v\n", err)
		return
	}

	// Generate a sample hash
	hash := sha256.Sum256([]byte("test"))

	// Attempt upsert with [32]byte (this will fail with E11000)
	err := database.UpsertDocumentWithBinary(hash, "value1")
	if err != nil {
		fmt.Printf("Upsert with binary failed: %v\n", standardizeError(err))
	}

	// Attempt upsert with string (this should succeed)
	err = database.UpsertDocumentWithString(hash, "value1")
	if err != nil {
		fmt.Printf("Upsert with string failed: %v\n", err)
	} else {
		fmt.Println("Upsert with string succeeded")
	}

	// Attempt upsert again with the same hash to test overwriting
	err = database.UpsertDocumentWithString(hash, "value2")
	if err != nil {
		fmt.Printf("Upsert with string (update) failed: %v\n", err)
	} else {
		fmt.Println("Upsert with string (update) succeeded")
	}
}