GODRIVER-3587 Use raw bytes in valueReader

bson/buffered_byte_src.go

@@ -0,0 +1,128 @@
+// Copyright (C) MongoDB, Inc. 2025-present.
+//
+// Licensed under the Apache License, Version 2.0 (the "License"); you may
+// not use this file except in compliance with the License. You may obtain
+// a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+package bson
+
+import (
+	"bytes"
+	"io"
+)
+
+// bufferedByteSrc implements the low-level byteSrc interface by reading
+// directly from an in-memory byte slice. It provides efficient, zero-copy
+// access for parsing BSON when the entire document is buffered in memory.
+type bufferedByteSrc struct {
+	buf    []byte // entire BSON document
+	offset int64  // Current read index into buf
+}
+
+var _ byteSrc = (*bufferedByteSrc)(nil)
+
+// Read reads up to len(p) bytes from the in-memory buffer, advancing the offset
+// by the number of bytes read.
+func (b *bufferedByteSrc) readExact(p []byte) (int, error) {
+	if b.offset >= int64(len(b.buf)) {
+		return 0, io.EOF
+	}
+	n := copy(p, b.buf[b.offset:])
+	b.offset += int64(n)
+	return n, nil
+}
+
+// ReadByte returns the single byte at buf[offset] and advances offset by 1.
+func (b *bufferedByteSrc) ReadByte() (byte, error) {
+	if b.offset >= int64(len(b.buf)) {
+		return 0, io.EOF
+	}
+	b.offset++
+	return b.buf[b.offset-1], nil
+}
+
+// peek returns buf[offset:offset+n] without advancing offset.
+func (b *bufferedByteSrc) peek(n int) ([]byte, error) {
+	// Ensure we don't read past the end of the buffer.
+	if int64(n)+b.offset > int64(len(b.buf)) {
+		return b.buf[b.offset:], io.EOF
+	}
+
+	// Return the next n bytes without advancing the offset
+	return b.buf[b.offset : b.offset+int64(n)], nil
+}
+
+// discard advances offset by n bytes, returning the number of bytes discarded.
+func (b *bufferedByteSrc) discard(n int) (int, error) {
+	// Ensure we don't read past the end of the buffer.
+	if int64(n)+b.offset > int64(len(b.buf)) {
+		// If we have exceeded the buffer length, discard only up to the end.
+		left := len(b.buf) - int(b.offset)
+		b.offset = int64(len(b.buf))
+
+		return left, io.EOF
+	}
+
+	// Advance the read position
+	b.offset += int64(n)
+	return n, nil
+}
+
+// readSlice scans buf[offset:] for the first occurrence of delim, returns
+// buf[offset:idx+1], and advances offset past it; errors if delim not found.
+func (b *bufferedByteSrc) readSlice(delim byte) ([]byte, error) {
+	// Ensure we don't read past the end of the buffer.
+	if b.offset >= int64(len(b.buf)) {
+		return nil, io.EOF
+	}
+
+	// Look for the delimiter in the remaining bytes
+	rem := b.buf[b.offset:]
+	idx := bytes.IndexByte(rem, delim)
+	if idx < 0 {
+		return nil, io.EOF
+	}
+
+	// Build the result slice up through the delimiter.
+	result := rem[:idx+1]
+
+	// Advance the offset past the delimiter.
+	b.offset += int64(idx + 1)
+
+	return result, nil
+}
+
+// pos returns the current read position in the buffer.
+func (b *bufferedByteSrc) pos() int64 {
+	return b.offset
+}
+
+// regexLength will return the total byte length of a BSON regex value.
+func (b *bufferedByteSrc) regexLength() (int32, error) {
+	rem := b.buf[b.offset:]
+
+	// Find end of the first C-string (pattern).
+	i := bytes.IndexByte(rem, 0x00)
+	if i < 0 {
+		return 0, io.EOF
+	}
+
+	// Find end of second C-string (options).
+	j := bytes.IndexByte(rem[i+1:], 0x00)
+	if j < 0 {
+		return 0, io.EOF
+	}
+
+	// Total length = first C-string length (pattern) + second C-string length
+	// (options) + 2 null terminators
+	return int32(i + j + 2), nil
+}
+
+func (*bufferedByteSrc) streamable() bool {
+	return false
+}
+
+func (b *bufferedByteSrc) reset() {
+	b.buf = nil
+	b.offset = 0
+}

bson/buffered_byte_src_test.go

@@ -0,0 +1,153 @@
+// Copyright (C) MongoDB, Inc. 2025-present.
+//
+// Licensed under the Apache License, Version 2.0 (the "License"); you may
+// not use this file except in compliance with the License. You may obtain
+// a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+package bson
+
+import (
+	"bytes"
+	"io"
+	"testing"
+
+	"go.mongodb.org/mongo-driver/v2/internal/assert"
+	"go.mongodb.org/mongo-driver/v2/internal/require"
+)
+
+func TestBufferedvalueReader_discard(t *testing.T) {
+	tests := []struct {
+		name       string
+		buf        []byte
+		n          int
+		want       int
+		wantOffset int64
+		wantErr    error
+	}{
+		{
+			name:       "nothing",
+			buf:        bytes.Repeat([]byte("a"), 1024),
+			n:          0,
+			want:       0,
+			wantOffset: 0,
+			wantErr:    nil,
+		},
+		{
+			name:       "amount less than buffer size",
+			buf:        bytes.Repeat([]byte("a"), 1024),
+			n:          100,
+			want:       100,
+			wantOffset: 100,
+			wantErr:    nil,
+		},
+		{
+			name:       "amount greater than buffer size",
+			buf:        bytes.Repeat([]byte("a"), 1024),
+			n:          10000,
+			want:       1024,
+			wantOffset: 1024,
+			wantErr:    io.EOF,
+		},
+		{
+			name:       "exact buffer size",
+			buf:        bytes.Repeat([]byte("a"), 1024),
+			n:          1024,
+			want:       1024,
+			wantOffset: 1024,
+			wantErr:    nil,
+		},
+		{
+			name:       "from empty buffer",
+			buf:        []byte{},
+			n:          10,
+			want:       0,
+			wantOffset: 0,
+			wantErr:    io.EOF,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			reader := &bufferedByteSrc{buf: tt.buf, offset: 0}
+			n, err := reader.discard(tt.n)
+			if tt.wantErr != nil {
+				assert.ErrorIs(t, err, tt.wantErr, "Expected error %v, got %v", tt.wantErr, err)
+			} else {
+				require.NoError(t, err, "Expected no error when discarding %d bytes", tt.n)
+			}
+
+			assert.Equal(t, tt.want, n, "Expected to discard %d bytes, got %d", tt.want, n)
+			assert.Equal(t, tt.wantOffset, reader.offset, "Expected offset to be %d, got %d", tt.wantOffset, reader.offset)
+		})
+	}
+}
+
+func TestBufferedvalueReader_peek(t *testing.T) {
+	tests := []struct {
+		name    string
+		buf     []byte
+		n       int
+		offset  int64
+		want    []byte
+		wantErr error
+	}{
+		{
+			name:    "nothing",
+			buf:     bytes.Repeat([]byte("a"), 1024),
+			n:       0,
+			want:    []byte{},
+			wantErr: nil,
+		},
+		{
+			name:    "amount less than buffer size",
+			buf:     bytes.Repeat([]byte("a"), 1024),
+			n:       100,
+			want:    bytes.Repeat([]byte("a"), 100),
+			wantErr: nil,
+		},
+		{
+			name:    "amount greater than buffer size",
+			buf:     bytes.Repeat([]byte("a"), 1024),
+			n:       10000,
+			want:    bytes.Repeat([]byte("a"), 1024),
+			wantErr: io.EOF,
+		},
+		{
+			name:    "exact buffer size",
+			buf:     bytes.Repeat([]byte("a"), 1024),
+			n:       1024,
+			want:    bytes.Repeat([]byte("a"), 1024),
+			wantErr: nil,
+		},
+		{
+			name:    "from empty buffer",
+			buf:     []byte{},
+			n:       10,
+			want:    []byte{},
+			wantErr: io.EOF,
+		},
+		{
+			name:    "peek with offset",
+			buf:     append(bytes.Repeat([]byte("a"), 100), bytes.Repeat([]byte("b"), 100)...),
+			offset:  100,
+			n:       100,
+			want:    bytes.Repeat([]byte("b"), 100),
+			wantErr: nil,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			reader := &bufferedByteSrc{buf: tt.buf, offset: tt.offset}
+			n, err := reader.peek(tt.n)
+			if tt.wantErr != nil {
+				assert.ErrorIs(t, err, tt.wantErr, "Expected error %v, got %v", tt.wantErr, err)
+			} else {
+				require.NoError(t, err, "Expected no error when peeking %d bytes", tt.n)
+			}
+
+			assert.Equal(t, tt.want, n, "Expected to peek %d bytes, got %d", len(tt.want), len(n))
+			assert.Equal(t, tt.offset, reader.offset, "Expected offset to be %d, got %d", tt.offset, reader.offset)
+		})
+	}
+}

bson/copier.go

@@ -7,7 +7,6 @@
 package bson
 
 import (
-	"bytes"
 	"errors"
 	"fmt"
 	"io"
@@ -180,8 +179,11 @@ func copyValueFromBytes(dst ValueWriter, t Type, src []byte) error {
 		return wvb.writeValueBytes(t, src)
 	}
 
-	vr := newDocumentReader(bytes.NewReader(src))
-	vr.pushElement(t)
+	vr := newBufferedDocumentReader(src)
+	vr.advanceFrame()
+
+	vr.stack[vr.frame].mode = mElement
+	vr.stack[vr.frame].vType = t
 
 	return copyValue(dst, vr)
 }

bson/copier_test.go

@@ -40,7 +40,7 @@ func TestCopier(t *testing.T) {
 			doc = bsoncore.AppendStringElement(doc, "Hello", "world")
 			doc, err := bsoncore.AppendDocumentEnd(doc, idx)
 			noerr(t, err)
-			src := newDocumentReader(bytes.NewReader(doc))
+			src := newBufferedDocumentReader(doc)
 			dst := newValueWriterFromSlice(make([]byte, 0))
 			want := doc
 			err = copyDocument(dst, src)
@@ -77,7 +77,7 @@ func TestCopier(t *testing.T) {
 			noerr(t, err)
 			doc, err = bsoncore.AppendDocumentEnd(doc, idx)
 			noerr(t, err)
-			src := newDocumentReader(bytes.NewReader(doc))
+			src := newBufferedDocumentReader(doc)
 
 			_, err = src.ReadDocument()
 			noerr(t, err)
@@ -450,7 +450,7 @@ func TestCopier(t *testing.T) {
 				idx,
 			)
 			noerr(t, err)
-			vr := newDocumentReader(bytes.NewReader(b))
+			vr := newBufferedDocumentReader(b)
 			_, err = vr.ReadDocument()
 			noerr(t, err)
 			_, _, err = vr.ReadElement()
@@ -489,7 +489,7 @@ func TestCopier(t *testing.T) {
 				idx,
 			)
 			noerr(t, err)
-			vr := newDocumentReader(bytes.NewReader(b))
+			vr := newBufferedDocumentReader(b)
 			_, err = vr.ReadDocument()
 			noerr(t, err)
 			_, _, err = vr.ReadElement()

bson/mgoregistry_test.go

@@ -485,7 +485,7 @@ func (t *prefixPtr) SetBSON(raw RawValue) error {
 	if err != nil {
 		return err
 	}
-	vr := newValueReader(raw.Type, bytes.NewReader(raw.Value))
+	vr := newBufferedValueReader(raw.Type, raw.Value)
 	err = decoder.DecodeValue(DecodeContext{Registry: NewMgoRegistry()}, vr, rval)
 	if err != nil {
 		return err
@@ -512,7 +512,7 @@ func (t *prefixVal) SetBSON(raw RawValue) error {
 	if err != nil {
 		return err
 	}
-	vr := newValueReader(raw.Type, bytes.NewReader(raw.Value))
+	vr := newBufferedValueReader(raw.Type, raw.Value)
 	err = decoder.DecodeValue(DecodeContext{Registry: NewMgoRegistry()}, vr, rval)
 	if err != nil {
 		return err
@@ -936,7 +936,7 @@ func (o *setterType) SetBSON(raw RawValue) error {
 	if raw.Type == 0x00 {
 		raw.Type = TypeEmbeddedDocument
 	}
-	vr := newValueReader(raw.Type, bytes.NewReader(raw.Value))
+	vr := newBufferedValueReader(raw.Type, raw.Value)
 	err = decoder.DecodeValue(DecodeContext{Registry: NewMgoRegistry()}, vr, rval)
 	if err != nil {
 		return err
@@ -1289,7 +1289,7 @@ func (s *getterSetterD) SetBSON(raw RawValue) error {
 	if raw.Type == 0x00 {
 		raw.Type = TypeEmbeddedDocument
 	}
-	vr := newValueReader(raw.Type, bytes.NewReader(raw.Value))
+	vr := newBufferedValueReader(raw.Type, raw.Value)
 	err = decoder.DecodeValue(DecodeContext{Registry: NewMgoRegistry()}, vr, rval)
 	if err != nil {
 		return err
@@ -1315,7 +1315,7 @@ func (i *getterSetterInt) SetBSON(raw RawValue) error {
 	if raw.Type == 0x00 {
 		raw.Type = TypeEmbeddedDocument
 	}
-	vr := newValueReader(raw.Type, bytes.NewReader(raw.Value))
+	vr := newBufferedValueReader(raw.Type, raw.Value)
 	err = decoder.DecodeValue(DecodeContext{Registry: NewMgoRegistry()}, vr, rval)
 	if err != nil {
 		return err
@@ -1337,7 +1337,7 @@ func (s *ifaceSlice) SetBSON(raw RawValue) error {
 	if err != nil {
 		return err
 	}
-	vr := newValueReader(raw.Type, bytes.NewReader(raw.Value))
+	vr := newBufferedValueReader(raw.Type, raw.Value)
 	err = decoder.DecodeValue(DecodeContext{Registry: NewMgoRegistry()}, vr, rval)
 	if err != nil {
 		return err