added len method

test/benchmarks_test.go

@@ -87,7 +87,7 @@ func BenchmarkV1BulkInsert100KDocs(b *testing.B) {
 }
 
 func bulkRead(b *testing.B, docSize int) {
-	db, col := setup(b)
+	_, col := setup(b)
 
 	// -----------------------------
 	// Prepare and insert documents
@@ -110,31 +110,24 @@ func bulkRead(b *testing.B, docSize int) {
 	require.NoError(b, err)
 
 	// -----------------------------------------
-	// Sub-benchmark 1: Read entire collection
+	// Sub-benchmark 1: Read entire collection using ReadDocuments
 	// -----------------------------------------
 	b.Run("ReadAllDocsOnce", func(b *testing.B) {
-		query := fmt.Sprintf("FOR d IN %s RETURN d", col.Name())
+		// Prepare keys for reading
+		keys := make([]string, docSize)
+		for j := 0; j < docSize; j++ {
+			keys[j] = fmt.Sprintf("doc_%d", j)
+		}
 
 		b.ResetTimer()
 		for i := 0; i < b.N; i++ {
-			cursor, err := db.Query(ctx, query, nil)
+			readDocs := make([]TestDoc, docSize)
+			_, _, err := col.ReadDocuments(ctx, keys, readDocs)
 			require.NoError(b, err)
 
-			count := 0
-			for {
-				var doc TestDoc
-				_, err := cursor.ReadDocument(ctx, &doc)
-				if driver.IsNoMoreDocuments(err) {
-					break
-				}
-				require.NoError(b, err)
-				count++
-			}
-			// require.Equal(b, docSize, count, "expected to read all documents")
-			_ = cursor.Close()
 			// sanity check
-			if count != docSize {
-				b.Fatalf("expected to read %d docs, got %d", docSize, count)
+			if len(readDocs) != docSize {
+				b.Fatalf("expected to read %d docs, got %d", docSize, len(readDocs))
 			}
 		}
 	})

v2/CHANGELOG.md

@@ -7,6 +7,7 @@
 - Disabled V8 related testcases in V1 and V2
 - Added new ConsolidationPolicy attributes to support updated configuration options for ArangoSearch Views properties and Inverted Indexes
 - Add Vector index feature
+- Add len() for Read methods
 
 ## [2.1.6](https://github.com/arangodb/go-driver/tree/v2.1.6) (2025-11-06)
 - Add missing endpoints from replication

v2/arangodb/collection_documents_create.go

@@ -71,7 +71,9 @@ type CollectionDocumentCreate interface {
 }
 
 type CollectionDocumentCreateResponseReader interface {
+	shared.ReadAllReadable[CollectionDocumentCreateResponse]
 	Read() (CollectionDocumentCreateResponse, error)
+	Len() int
 }
 
 type CollectionDocumentCreateResponse struct {

v2/arangodb/collection_documents_create_impl.go

@@ -24,6 +24,8 @@ import (
 	"context"
 	"io"
 	"net/http"
+	"reflect"
+	"sync"
 
 	"github.com/pkg/errors"
 
@@ -49,6 +51,13 @@ func (c collectionDocumentCreate) CreateDocumentsWithOptions(ctx context.Context
 		return nil, errors.Errorf("Input documents should be list")
 	}
 
+	// Get document count from input (same as v1 approach)
+	documentsVal := reflect.ValueOf(documents)
+	if documentsVal.Kind() == reflect.Ptr {
+		documentsVal = documentsVal.Elem()
+	}
+	documentCount := documentsVal.Len()
+
 	url := c.collection.url("document")
 
 	req, err := c.collection.connection().NewRequest(http.MethodPost, url)
@@ -73,7 +82,7 @@ func (c collectionDocumentCreate) CreateDocumentsWithOptions(ctx context.Context
 	case http.StatusCreated:
 		fallthrough
 	case http.StatusAccepted:
-		return newCollectionDocumentCreateResponseReader(&arr, opts), nil
+		return newCollectionDocumentCreateResponseReader(&arr, opts, documentCount), nil
 	default:
 		return nil, shared.NewResponseStruct().AsArangoErrorWithCode(code)
 	}
@@ -125,44 +134,64 @@ func (c collectionDocumentCreate) CreateDocument(ctx context.Context, document i
 	return c.CreateDocumentWithOptions(ctx, document, nil)
 }
 
-func newCollectionDocumentCreateResponseReader(array *connection.Array, options *CollectionDocumentCreateOptions) *collectionDocumentCreateResponseReader {
-	c := &collectionDocumentCreateResponseReader{array: array, options: options}
+func newCollectionDocumentCreateResponseReader(array *connection.Array, options *CollectionDocumentCreateOptions, documentCount int) *collectionDocumentCreateResponseReader {
+	c := &collectionDocumentCreateResponseReader{
+		array:         array,
+		options:       options,
+		documentCount: documentCount,
+	}
 
 	if c.options != nil {
 		c.response.Old = newUnmarshalInto(c.options.OldObject)
 		c.response.New = newUnmarshalInto(c.options.NewObject)
 	}
 
+	c.ReadAllReader = shared.ReadAllReader[CollectionDocumentCreateResponse, *collectionDocumentCreateResponseReader]{Reader: c}
 	return c
 }
 
 var _ CollectionDocumentCreateResponseReader = &collectionDocumentCreateResponseReader{}
 
 type collectionDocumentCreateResponseReader struct {
-	array    *connection.Array
-	options  *CollectionDocumentCreateOptions
-	response struct {
+	array         *connection.Array
+	options       *CollectionDocumentCreateOptions
+	documentCount int // Store input document count for Len() without caching
+	response      struct {
 		*DocumentMeta
 		*shared.ResponseStruct `json:",inline"`
 		Old                    *UnmarshalInto `json:"old,omitempty"`
 		New                    *UnmarshalInto `json:"new,omitempty"`
 	}
+	shared.ReadAllReader[CollectionDocumentCreateResponse, *collectionDocumentCreateResponseReader]
+	mu sync.Mutex
 }
 
 func (c *collectionDocumentCreateResponseReader) Read() (CollectionDocumentCreateResponse, error) {
+	c.mu.Lock()
+	defer c.mu.Unlock()
+
 	if !c.array.More() {
 		return CollectionDocumentCreateResponse{}, shared.NoMoreDocumentsError{}
 	}
 
 	var meta CollectionDocumentCreateResponse
 
+	// Create new instances for each document to avoid pointer reuse
 	if c.options != nil {
-		meta.Old = c.options.OldObject
-		meta.New = c.options.NewObject
+		if c.options.OldObject != nil {
+			oldObjectType := reflect.TypeOf(c.options.OldObject).Elem()
+			meta.Old = reflect.New(oldObjectType).Interface()
+		}
+		if c.options.NewObject != nil {
+			newObjectType := reflect.TypeOf(c.options.NewObject).Elem()
+			meta.New = reflect.New(newObjectType).Interface()
+		}
 	}
 
 	c.response.DocumentMeta = &meta.DocumentMeta
 	c.response.ResponseStruct = &meta.ResponseStruct
+	c.response.Old = newUnmarshalInto(meta.Old)
+	c.response.New = newUnmarshalInto(meta.New)
 
 	if err := c.array.Unmarshal(&c.response); err != nil {
 		if err == io.EOF {
@@ -175,5 +204,26 @@ func (c *collectionDocumentCreateResponseReader) Read() (CollectionDocumentCreat
 		return meta, meta.AsArangoError()
 	}
 
+	// Copy data from the new instances back to the original option objects for backward compatibility
+	if c.options != nil {
+		if c.options.OldObject != nil && meta.Old != nil {
+			oldValue := reflect.ValueOf(meta.Old).Elem()
+			originalValue := reflect.ValueOf(c.options.OldObject).Elem()
+			originalValue.Set(oldValue)
+		}
+		if c.options.NewObject != nil && meta.New != nil {
+			newValue := reflect.ValueOf(meta.New).Elem()
+			originalValue := reflect.ValueOf(c.options.NewObject).Elem()
+			originalValue.Set(newValue)
+		}
+	}
+
 	return meta, nil
 }
+
+// Len returns the number of items in the response.
+// Returns the input document count immediately without reading/caching (same as v1 behavior).
+// After calling Len(), you can still use Read() to iterate through items.
+func (c *collectionDocumentCreateResponseReader) Len() int {
+	return c.documentCount
+}

v2/arangodb/collection_documents_delete.go

@@ -63,7 +63,9 @@ type CollectionDocumentDeleteResponse struct {
 }
 
 type CollectionDocumentDeleteResponseReader interface {
+	shared.ReadAllIntoReadable[CollectionDocumentDeleteResponse]
 	Read(i interface{}) (CollectionDocumentDeleteResponse, error)
+	Len() int
 }
 
 type CollectionDocumentDeleteOptions struct {
@@ -82,6 +84,7 @@ type CollectionDocumentDeleteOptions struct {
 	WithWaitForSync *bool
 
 	// Return additionally the complete previous revision of the changed document
+	// Should be a pointer to an object
 	OldObject interface{}
 
 	// If set to true, an empty object is returned as response if the document operation succeeds.

v2/arangodb/collection_documents_delete_impl.go

@@ -24,6 +24,8 @@ import (
 	"context"
 	"io"
 	"net/http"
+	"reflect"
+	"sync"
 
 	"github.com/pkg/errors"
 
@@ -42,6 +44,7 @@ var _ CollectionDocumentDelete = &collectionDocumentDelete{}
 
 type collectionDocumentDelete struct {
 	collection *collection
+	shared.ReadAllIntoReader[CollectionDocumentDeleteResponse, *collectionDocumentDeleteResponseReader]
 }
 
 func (c collectionDocumentDelete) DeleteDocument(ctx context.Context, key string) (CollectionDocumentDeleteResponse, error) {
@@ -78,6 +81,13 @@ func (c collectionDocumentDelete) DeleteDocumentsWithOptions(ctx context.Context
 		return nil, errors.Errorf("Input documents should be list")
 	}
 
+	// Get document count from input (same as v1 approach)
+	documentsVal := reflect.ValueOf(documents)
+	if documentsVal.Kind() == reflect.Ptr {
+		documentsVal = documentsVal.Elem()
+	}
+	documentCount := documentsVal.Len()
+
 	url := c.collection.url("document")
 
 	req, err := c.collection.connection().NewRequest(http.MethodDelete, url)
@@ -97,23 +107,34 @@ func (c collectionDocumentDelete) DeleteDocumentsWithOptions(ctx context.Context
 	if err != nil {
 		return nil, err
 	}
-	return newCollectionDocumentDeleteResponseReader(&arr, opts), nil
+	return newCollectionDocumentDeleteResponseReader(&arr, opts, documentCount), nil
 }
 
-func newCollectionDocumentDeleteResponseReader(array *connection.Array, options *CollectionDocumentDeleteOptions) *collectionDocumentDeleteResponseReader {
-	c := &collectionDocumentDeleteResponseReader{array: array, options: options}
+func newCollectionDocumentDeleteResponseReader(array *connection.Array, options *CollectionDocumentDeleteOptions, documentCount int) *collectionDocumentDeleteResponseReader {
+	c := &collectionDocumentDeleteResponseReader{
+		array:         array,
+		options:       options,
+		documentCount: documentCount,
+	}
 
+	c.ReadAllIntoReader = shared.ReadAllIntoReader[CollectionDocumentDeleteResponse, *collectionDocumentDeleteResponseReader]{Reader: c}
 	return c
 }
 
 var _ CollectionDocumentDeleteResponseReader = &collectionDocumentDeleteResponseReader{}
 
 type collectionDocumentDeleteResponseReader struct {
-	array   *connection.Array
-	options *CollectionDocumentDeleteOptions
+	array         *connection.Array
+	options       *CollectionDocumentDeleteOptions
+	documentCount int // Store input document count for Len() without caching
+	shared.ReadAllIntoReader[CollectionDocumentDeleteResponse, *collectionDocumentDeleteResponseReader]
+	mu sync.Mutex
 }
 
 func (c *collectionDocumentDeleteResponseReader) Read(i interface{}) (CollectionDocumentDeleteResponse, error) {
+	c.mu.Lock()
+	defer c.mu.Unlock()
+
 	if !c.array.More() {
 		return CollectionDocumentDeleteResponse{}, shared.NoMoreDocumentsError{}
 	}
@@ -146,11 +167,27 @@ func (c *collectionDocumentDeleteResponseReader) Read(i interface{}) (Collection
 	}
 
 	if c.options != nil && c.options.OldObject != nil {
-		meta.Old = c.options.OldObject
+		// Create a new instance for each document to avoid pointer reuse
+		oldObjectType := reflect.TypeOf(c.options.OldObject).Elem()
+		meta.Old = reflect.New(oldObjectType).Interface()
+
+		// Extract old data into the new instance
 		if err := response.Object.Object.Extract("old").Inject(meta.Old); err != nil {
 			return CollectionDocumentDeleteResponse{}, err
 		}
+
+		// Copy data from the new instance to the original OldObject for backward compatibility
+		oldValue := reflect.ValueOf(meta.Old).Elem()
+		originalValue := reflect.ValueOf(c.options.OldObject).Elem()
+		originalValue.Set(oldValue)
 	}
 
 	return meta, nil
 }
+
+// Len returns the number of items in the response.
+// Returns the input document count immediately without reading/caching (same as v1 behavior).
+// After calling Len(), you can still use Read() to iterate through items.
+func (c *collectionDocumentDeleteResponseReader) Len() int {
+	return c.documentCount
+}

v2/arangodb/collection_documents_read.go

@@ -59,6 +59,8 @@ type CollectionDocumentRead interface {
 
 type CollectionDocumentReadResponseReader interface {
 	Read(i interface{}) (CollectionDocumentReadResponse, error)
+	shared.ReadAllIntoReadable[CollectionDocumentReadResponse]
+	Len() int
 }
 
 type CollectionDocumentReadResponse struct {