Clean actions attribute of Bulk struct

[GonzMG]

I'm using (b *Bulk) Update(pairs ...interface{}) to modify a huge quantity of data in a collection. To avoid memory errors, I'm using batches to perform the bulk.Run().

The problem I've found is the bulk class does not clean the the array of actions actions []bulkAction. Should we add a method to clean this variable or in the Run() function set the array as empty?

Thanks in advance!

[ljluestc]

package main

import (
	"context"
	"fmt"
	"log"

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

// bulkAction represents an action in the bulk operation (simplified for example).
type bulkAction struct {
	Type  string // e.g., "update"
	Pairs interface{}
}

// Bulk represents a custom bulk operation class.
type Bulk struct {
	actions []bulkAction
	coll    *mongo.Collection
}

// NewBulk creates a new Bulk instance.
func NewBulk(coll *mongo.Collection) *Bulk {
	return &Bulk{
		actions: make([]bulkAction, 0),
		coll:    coll,
	}
}

// Update adds an update operation to the bulk actions.
func (b *Bulk) Update(pairs ...interface{}) {
	b.actions = append(b.actions, bulkAction{
		Type:  "update",
		Pairs: pairs,
	})
}

// Run executes the bulk operations (simplified for example).
func (b *Bulk) Run(ctx context.Context) error {
	// Simulate executing the bulk operations.
	// In a real implementation, this would call the MongoDB driver's BulkWrite.
	fmt.Printf("Executing %d actions\n", len(b.actions))
	// Here, you'd use b.coll.BulkWrite(ctx, models) with proper WriteModel conversion.
	return nil
}

// Clear resets the actions array to free memory.
func (b *Bulk) Clear() {
	b.actions = nil // Set to nil to allow GC to reclaim memory.
	// Alternatively: b.actions = make([]bulkAction, 0) to keep an empty slice.
}

func main() {
	// Connect to MongoDB.
	client, err := mongo.Connect(context.Background(), options.Client().ApplyURI("mongodb://localhost:27017"))
	if err != nil {
		log.Fatal(err)
	}
	defer client.Disconnect(context.Background())

	coll := client.Database("testdb").Collection("testcoll")

	// Create a new Bulk instance.
	bulk := NewBulk(coll)

	// Simulate a large number of updates in batches.
	totalUpdates := 100000
	batchSize := 1000

	for i := 0; i < totalUpdates; i += batchSize {
		// Add updates to the bulk operation.
		for j := 0; j < batchSize && i+j < totalUpdates; j++ {
			update := map[string]interface{}{
				"filter":  map[string]interface{}{"_id": i + j},
				"update":  map[string]interface{}{"$set": map[string]string{"status": "updated"}},
			}
			bulk.Update(update)
		}

		// Execute the batch.
		if err := bulk.Run(context.Background()); err != nil {
			log.Printf("Error executing bulk: %v", err)
		}

		// Clear the actions array to free memory.
		bulk.Clear()

		// Log progress.
		fmt.Printf("Processed %d/%d updates\n", i+batchSize, totalUpdates)
	}

	fmt.Println("All updates completed")
}