flowchart TB
    subgraph "BSON对象层"
        BSONObj[BSONObj<br/>BSON文档对象]
        BSONElement[BSONElement<br/>BSON字段元素]
        BSONObjIterator[BSONObjIterator<br/>文档迭代器]
    end
    
    subgraph "BSON构建层"
        BSONObjBuilder[BSONObjBuilder<br/>文档构建器]
        BSONArrayBuilder[BSONArrayBuilder<br/>数组构建器]
        BufBuilder[BufBuilder<br/>缓冲区构建器]
    end
    
    subgraph "BSON类型层"
        BSONType[BSONType枚举<br/>类型定义]
        OID[ObjectId<br/>对象ID]
        Timestamp[Timestamp<br/>时间戳]
        Decimal128[Decimal128<br/>高精度小数]
        BinData[BinData<br/>二进制数据]
    end
    
    subgraph "序列化层"
        BSONObjAppender[BSONObj Appender<br/>对象追加器]
        BSONValidator[BSON Validator<br/>格式验证器]
        BSONSizeTracker[BSON Size Tracker<br/>大小跟踪器]
    end
    
    subgraph "比较与操作"
        BSONComparator[BSON Comparator<br/>文档比较器]
        BSONMatcher[BSON Matcher<br/>模式匹配器]
        BSONExtractor[BSON Extractor<br/>字段提取器]
    end
    
    BSONObj --> BSONElement
    BSONObj --> BSONObjIterator
    BSONObjIterator --> BSONElement
    
    BSONObjBuilder --> BufBuilder
    BSONObjBuilder --> BSONObj
    BSONArrayBuilder --> BSONObjBuilder
    
    BSONElement --> BSONType
    BSONType --> OID
    BSONType --> Timestamp
    BSONType --> Decimal128
    BSONType --> BinData
    
    BSONObjBuilder --> BSONObjAppender
    BSONObjBuilder --> BSONValidator
    BSONObjBuilder --> BSONSizeTracker
    
    BSONObj --> BSONComparator
    BSONObj --> BSONMatcher
    BSONObj --> BSONExtractor

BSON文档格式：
+-------------------+
| int32 totalSize   | 4字节：文档总长度（包含此字段）
+-------------------+
| element1          | 字段1
+-------------------+
| element2          | 字段2
+-------------------+
| ...               | 更多字段
+-------------------+
| 0x00 (EOO)        | 1字节：文档结束标记
+-------------------+

BSON元素格式：
+-------------------+
| byte type         | 1字节：类型标识符
+-------------------+
| cstring name      | 字段名（以\0结尾）
+-------------------+
| value             | 值（格式取决于类型）
+-------------------+

常见类型值格式：
- String:    int32 length + UTF-8字符串 + \0
- Int32:     int32值（4字节）
- Int64:     int64值（8字节）
- Double:    double值（8字节，IEEE 754）
- Object:    嵌套BSON文档
- Array:     BSON文档（字段名为"0", "1", "2"...）
- Boolean:   byte值（0x00或0x01）
- Date:      int64毫秒时间戳
- ObjectId:  12字节二进制
- Null:      无值

// BSONObjBuilder核心实现
class BSONObjBuilder {
public:
    BSONObjBuilder() : _buf(512), _doneCalled(false) {
        // 1) 预留4字节存储文档大小
        _buf.skip(sizeof(int32_t));
    }
    
    // 追加String字段
    BSONObjBuilder& append(StringData fieldName, StringData value) {
        // 1) 写入类型标识符
        _buf.appendChar(static_cast<char>(BSONType::String));
        
        // 2) 写入字段名（以\0结尾）
        _buf.appendStr(fieldName, true);
        
        // 3) 写入字符串长度（包含\0）
        int32_t len = value.size() + 1;
        _buf.appendNum(len);
        
        // 4) 写入字符串内容
        _buf.appendStr(value, true);
        
        return *this;
    }
    
    // 追加Int32字段
    BSONObjBuilder& append(StringData fieldName, int32_t value) {
        _buf.appendChar(static_cast<char>(BSONType::NumberInt));
        _buf.appendStr(fieldName, true);
        _buf.appendNum(value);
        return *this;
    }
    
    // 追加嵌套对象
    BSONObjBuilder& append(StringData fieldName, const BSONObj& obj) {
        _buf.appendChar(static_cast<char>(BSONType::Object));
        _buf.appendStr(fieldName, true);
        
        // 直接追加整个BSON文档
        _buf.appendBuf(obj.objdata(), obj.objsize());
        
        return *this;
    }
    
    // 完成构建，生成BSONObj
    BSONObj obj() {
        if (!_doneCalled) {
            _done();
        }
        
        // 创建BSONObj，共享缓冲区
        return BSONObj(_buf.buf(), BSONObj::ShareOwnership(_buf.release()));
    }

private:
    void _done() {
        // 1) 写入文档结束标记
        _buf.appendChar(0);
        
        // 2) 回填文档大小到开头4字节
        int32_t totalSize = _buf.len();
        DataView(_buf.buf()).write<LittleEndian<int32_t>>(totalSize);
        
        _doneCalled = true;
    }
    
    BufBuilder _buf;      // 底层缓冲区
    bool _doneCalled;     // 是否已完成
};

// BSONObj核心实现
class BSONObj {
public:
    // 从字节流构造（零拷贝）
    explicit BSONObj(const char* bsonData) {
        // 1) 验证基本格式
        uassert(ErrorCodes::InvalidBSON,
                "BSON data too small",
                bsonData != nullptr);
        
        // 2) 读取文档大小
        int32_t size = ConstDataView(bsonData).read<LittleEndian<int32_t>>();
        
        // 3) 基本大小检查
        uassert(ErrorCodes::InvalidBSON,
                "BSON object size is invalid",
                size >= kMinBSONLength && size <= BSONObjMaxInternalSize);
        
        // 4) 仅存储指针，不拷贝数据
        _objdata = bsonData;
    }
    
    // 获取字段值
    BSONElement getField(StringData fieldName) const {
        // 1) 创建迭代器
        BSONObjIterator it(*this);
        
        // 2) 线性查找字段
        while (it.more()) {
            BSONElement elem = it.next();
            if (elem.fieldNameStringData() == fieldName) {
                return elem;
            }
        }
        
        // 3) 未找到，返回EOO
        return BSONElement();
    }
    
    // 获取嵌套字段（支持点分路径）
    BSONElement getFieldDotted(StringData path) const {
        // "user.address.city" -> ["user", "address", "city"]
        
        BSONObj current = *this;
        size_t dotPos = 0;
        
        while ((dotPos = path.find('.')) != std::string::npos) {
            // 1) 提取路径段
            StringData segment = path.substr(0, dotPos);
            
            // 2) 获取字段
            BSONElement elem = current.getField(segment);
            if (elem.eoo() || elem.type() != BSONType::Object) {
                return BSONElement();  // 路径不存在
            }
            
            // 3) 进入嵌套对象
            current = elem.Obj();
            path = path.substr(dotPos + 1);
        }
        
        // 4) 获取最后一段
        return current.getField(path);
    }
    
    // 文档大小
    int objsize() const {
        return ConstDataView(_objdata).read<LittleEndian<int32_t>>();
    }

private:
    const char* _objdata;  // 指向BSON字节流
};

classDiagram
    class BSONObj {
        -const char* _objdata
        -ConstSharedBuffer _ownedBuffer
        +BSONObj()
        +BSONObj(const char* data)
        +int objsize() const
        +BSONElement getField(StringData) const
        +BSONElement operator[](StringData) const
        +bool hasField(StringData) const
        +bool isEmpty() const
        +BSONObjIterator begin() const
        +bool isValid() const
        +int nFields() const
        +std::string toString() const
        +BSONObj getOwned() const
    }
    
    class BSONElement {
        -const char* _data
        +BSONElement()
        +BSONElement(const char* data)
        +BSONType type() const
        +StringData fieldNameStringData() const
        +const char* value() const
        +int size() const
        +bool eoo() const
        +std::string String() const
        +int32_t Int() const
        +int64_t Long() const
        +double Double() const
        +bool Bool() const
        +Date_t Date() const
        +OID OID() const
        +BSONObj Obj() const
        +std::vector~BSONElement~ Array() const
    }
    
    class BSONObjIterator {
        -const char* _pos
        -const char* _end
        +BSONObjIterator(const BSONObj&)
        +bool more() const
        +BSONElement next()
        +BSONElement operator*() const
        +BSONObjIterator& operator++()
    }
    
    class BSONObjBuilder {
        -BufBuilder _buf
        -bool _doneCalled
        -int _nFields
        +BSONObjBuilder()
        +BSONObjBuilder(int initSize)
        +append(StringData, T value)
        +appendNumber(StringData, T)
        +appendStr(StringData, StringData)
        +appendBool(StringData, bool)
        +appendDate(StringData, Date_t)
        +appendNull(StringData)
        +appendObject(StringData, BSONObj)
        +appendArray(StringData, BSONArray)
        +appendElements(BSONObj)
        +BSONObj obj()
        +BSONObj done()
        +int len() const
    }
    
    class BSONArrayBuilder {
        -BSONObjBuilder _builder
        -int _index
        +BSONArrayBuilder()
        +append(T value)
        +BSONArray arr()
        +BSONArray done()
        +int len() const
    }
    
    class BufBuilder {
        -char* _buf
        -size_t _size
        -size_t _len
        +BufBuilder(int initSize)
        +~BufBuilder()
        +appendBuf(const void*, size_t)
        +appendStr(StringData, bool includeNull)
        +appendNum~T~(T)
        +appendChar(char)
        +skip(size_t)
        +char* buf()
        +int len() const
        +void reset()
        +SharedBuffer release()
    }
    
    BSONObj "1" o-- "*" BSONElement : contains
    BSONObj "1" --> "1" BSONObjIterator : creates
    BSONObjBuilder "1" --> "1" BSONObj : builds
    BSONObjBuilder "1" *-- "1" BufBuilder : uses
    BSONArrayBuilder "1" *-- "1" BSONObjBuilder : wraps
    BSONElement "1" --> "0..1" BSONObj : for nested objects

classDiagram
    class BSONType {
        <<enumeration>>
        EOO = 0
        NumberDouble = 1
        String = 2
        Object = 3
        Array = 4
        BinData = 5
        Undefined = 6
        jstOID = 7
        Bool = 8
        Date = 9
        jstNULL = 10
        RegEx = 11
        DBRef = 12
        Code = 13
        Symbol = 14
        CodeWScope = 15
        NumberInt = 16
        bsonTimestamp = 17
        NumberLong = 18
        NumberDecimal = 19
        MinKey = -1
        MaxKey = 127
    }
    
    class OID {
        -unsigned char _data[12]
        +OID()
        +OID(StringData)
        +static OID gen()
        +std::string toString() const
        +Date_t asDateT() const
        +bool operator==(const OID&) const
        +bool operator<(const OID&) const
        +int compare(const OID&) const
    }
    
    class Timestamp {
        -uint32_t _seconds
        -uint32_t _increment
        +Timestamp()
        +Timestamp(uint32_t s, uint32_t i)
        +uint32_t getSecs() const
        +uint32_t getInc() const
        +long long asULL() const
        +bool operator==(Timestamp) const
        +bool operator<(Timestamp) const
    }
    
    class Decimal128 {
        -Value _value
        +Decimal128()
        +Decimal128(std::string)
        +Decimal128(double)
        +static Decimal128 kPositiveInfinity
        +static Decimal128 kNegativeInfinity
        +static Decimal128 kPositiveNaN
        +std::string toString() const
        +double toDouble() const
        +bool isZero() const
        +bool isNaN() const
        +bool isInfinite() const
        +Decimal128 add(Decimal128) const
        +Decimal128 multiply(Decimal128) const
    }
    
    class Date_t {
        -int64_t _millis
        +Date_t()
        +Date_t(int64_t)
        +static Date_t now()
        +static Date_t max()
        +int64_t toMillisSinceEpoch() const
        +std::string toString() const
        +bool operator==(Date_t) const
        +bool operator<(Date_t) const
    }
    
    class BinData {
        -const char* _data
        -int _length
        -BinDataType _type
        +BinData(const void*, int, BinDataType)
        +const char* data() const
        +int length() const
        +BinDataType type() const
    }
    
    BSONElement --> BSONType : has type
    BSONElement --> OID : for ObjectId
    BSONElement --> Timestamp : for Timestamp
    BSONElement --> Decimal128 : for NumberDecimal
    BSONElement --> Date_t : for Date
    BSONElement --> BinData : for BinData

_data指向：
+-------+----------+-----+-------+
| type  | name\0   | ... | value |
+-------+----------+-----+-------+
  1字节   可变长      1字节  可变长

+----------+--------+---------+----------+
| 4字节    | 3字节  | 2字节   | 3字节    |
| 时间戳   | 机器ID | 进程ID  | 计数器   |
+----------+--------+---------+----------+

class BSONObj {
public:
    // 1) 默认构造（空对象{}）
    BSONObj() {
        _objdata = kEmptyObjectPrototype; // 指向静态空对象
    }
    
    // 2) 从BSON数据构造
    template <typename Traits = DefaultSizeTrait>
    explicit BSONObj(const char* bsonData, Traits t = Traits{}) {
        init<Traits>(bsonData);
    }
    
    // 3) 从共享缓冲区构造
    explicit BSONObj(ConstSharedBuffer ownedBuffer)
        : _objdata(ownedBuffer.get() ? ownedBuffer.get() : BSONObj().objdata()),
          _ownedBuffer(std::move(ownedBuffer)) {}
    
    // 4) 基本属性查询
    bool isEmpty() const {
        return objsize() <= 5; // 空对象只有长度(4字节) + EOO(1字节)
    }
    
    int objsize() const {
        return ConstDataView(objdata()).read<LittleEndian<int>>();
    }
    
    int nFields() const {
        int count = 0;
        BSONObjIterator it(*this);
        while (it.more()) {
            it.next();
            count++;
        }
        return count;
    }
    
    // 5) 字段访问接口
    BSONElement getField(StringData name) const {
        BSONObjIterator it(*this);
        while (it.more()) {
            BSONElement e = it.next();
            if (e.fieldNameStringData() == name)
                return e;
        }
        return BSONElement(); // 返回EOO元素
    }
    
    BSONElement operator[](StringData field) const {
        return getField(field);
    }
    
    // 6) 嵌套字段访问（支持点号路径）
    BSONElement getFieldDotted(StringData name) const {
        if (name.find('.') == std::string::npos) {
            return getField(name);
        }
        
        // 递归解析点号路径
        size_t dot = name.find('.');
        StringData prefix = name.substr(0, dot);
        StringData suffix = name.substr(dot + 1);
        
        BSONElement sub = getField(prefix);
        if (sub.type() == BSONType::Object) {
            return sub.Obj().getFieldDotted(suffix);
        }
        return BSONElement(); // 路径不存在
    }
    
    // 7) 对象比较
    int woCompare(const BSONObj& r, const Ordering& order = Ordering::make(BSONObj())) const {
        BSONObjIterator i(*this);
        BSONObjIterator j(r);
        
        while (i.more() && j.more()) {
            BSONElement l = i.next();
            BSONElement r = j.next();
            int cmp = l.woCompare(r, false);
            if (cmp != 0) return cmp;
        }
        
        // 字段数量不同的处理
        if (i.more()) return 1;
        if (j.more()) return -1;
        return 0;
    }
    
    // 8) 序列化到JSON
    std::string jsonString(JsonStringFormat format = ExtendedRelaxedV200) const {
        BSONObjBuilder builder;
        // （此处省略格式转换细节）
        return builder.obj().toString();
    }
};

class BSONObjBuilder {
private:
    BufBuilder _b;              // 内部缓冲区
    int _offset;               // 当前写入偏移
    
public:
    // 1) 构造函数（指定初始容量）
    explicit BSONObjBuilder(int initsize = kBSONObjBuilderInitialCapacity) 
        : _b(initsize + 4), _offset(4) {
        // 预留4字节存储对象总长度
        _b.skip(4);
    }
    
    // 2) 基本类型追加
    BSONObjBuilder& append(StringData fieldName, int val) {
        _b.appendNum(static_cast<char>(BSONType::numberInt));
        _b.appendStr(fieldName);
        _b.appendNum(val);
        return *this;
    }
    
    BSONObjBuilder& append(StringData fieldName, StringData str) {
        _b.appendNum(static_cast<char>(BSONType::string));
        _b.appendStr(fieldName);
        _b.appendNum(static_cast<int>(str.size() + 1)); // 包含null终止符
        _b.appendStr(str);
        _b.appendChar('\0');
        return *this;
    }
    
    // 3) 嵌套对象追加
    BSONObjBuilder& append(StringData fieldName, const BSONObj& obj) {
        _b.appendNum(static_cast<char>(BSONType::object));
        _b.appendStr(fieldName);
        _b.appendBuf(obj.objdata(), obj.objsize());
        return *this;
    }
    
    // 4) 条件追加
    BSONObjBuilder& appendIf(bool condition, StringData fieldName, int val) {
        if (condition) {
            append(fieldName, val);
        }
        return *this;
    }
    
    // 5) 完成构建
    BSONObj obj() {
        if (_doneCalled) {
            return BSONObj(_b.buf()); // 复用已完成的缓冲区
        }
        return done();
    }
    
private:
    BSONObj done() {
        _doneCalled = true;
        _b.appendChar(EOO); // 添加结束标记
        
        // 回填对象总长度
        int totalSize = _b.len();
        DataView(_b.buf()).write<LittleEndian<int>>(totalSize);
        
        return BSONObj(_b.buf());
    }
};

class BSONElement {
private:
    const char* _data;  // 指向元素在BSON中的位置
    int _fieldNameSize; // 字段名长度（缓存优化）
    
public:
    // 1) 类型查询
    BSONType type() const {
        return static_cast<BSONType>(*_data);
    }
    
    // 2) 字段名访问
    StringData fieldNameStringData() const {
        return StringData(_data + 1, _fieldNameSize - 1);
    }
    
    const char* fieldName() const {
        return _data + 1;
    }
    
    // 3) 值访问（类型安全）
    template<typename T>
    T value() const {
        if constexpr (std::is_same_v<T, int>) {
            if (type() != BSONType::numberInt) {
                uasserted(ErrorCodes::TypeMismatch, "Expected int type");
            }
            return ConstDataView(valueData()).read<LittleEndian<int>>();
        } else if constexpr (std::is_same_v<T, std::string>) {
            if (type() != BSONType::string) {
                uasserted(ErrorCodes::TypeMismatch, "Expected string type");
            }
            int strLen = ConstDataView(valueData()).read<LittleEndian<int>>();
            return std::string(valueData() + 4, strLen - 1); // 去除null终止符
        }
        // 其他类型处理...
    }
    
    // 4) 数值类型统一访问
    double numberDouble() const {
        switch (type()) {
            case BSONType::numberDouble:
                return ConstDataView(valueData()).read<LittleEndian<double>>();
            case BSONType::numberInt:
                return static_cast<double>(ConstDataView(valueData()).read<LittleEndian<int>>());
            case BSONType::numberLong:
                return static_cast<double>(ConstDataView(valueData()).read<LittleEndian<long long>>());
            default:
                uasserted(ErrorCodes::TypeMismatch, "Element is not a number");
        }
    }
    
    // 5) 对象/数组访问
    BSONObj Obj() const {
        if (type() == BSONType::object || type() == BSONType::array) {
            return BSONObj(valueData());
        }
        return BSONObj(); // 返回空对象
    }
    
    // 6) 判断方法
    bool eoo() const {
        return type() == BSONType::eoo;
    }
    
    bool isNumber() const {
        BSONType t = type();
        return t == BSONType::numberDouble || 
               t == BSONType::numberInt || 
               t == BSONType::numberLong ||
               t == BSONType::numberDecimal;
    }
    
private:
    const char* valueData() const {
        return _data + 1 + _fieldNameSize;
    }
};

struct BSONArray : BSONObj {
    // 继承BSONObj的所有功能
    BSONArray() : BSONObj() {}
    explicit BSONArray(const BSONObj& obj) : BSONObj(obj) {}
    
    // 数组特有的访问方法
    BSONElement operator[](int index) const {
        return BSONObj::operator[](std::to_string(index));
    }
    
    // 获取数组长度（通过遍历计算）
    int size() const {
        return nFields();
    }
    
    // 转换为vector
    template<typename T>
    std::vector<T> toVector() const {
        std::vector<T> result;
        BSONObjIterator it(*this);
        while (it.more()) {
            BSONElement e = it.next();
            result.push_back(e.value<T>());
        }
        return result;
    }
};

class BSONArrayBuilder {
private:
    BSONObjBuilder _b;
    int _i;  // 当前数组索引
    
public:
    BSONArrayBuilder() : _i(0) {}
    
    // 追加元素（自动生成索引）
    template<typename T>
    BSONArrayBuilder& append(const T& val) {
        _b.append(std::to_string(_i++), val);
        return *this;
    }
    
    // 流式操作符
    template<typename T>
    BSONArrayBuilder& operator<<(const T& val) {
        return append(val);
    }
    
    // 完成构建
    BSONArray arr() {
        return BSONArray(_b.obj());
    }
    
    // 获取当前大小
    int len() const {
        return _i;
    }
};

enum class BSONType : int {
    minKey = -1,        // 最小值类型
    eoo = 0,           // 对象结束标记
    numberDouble = 1,   // 64位浮点数
    string = 2,        // UTF-8字符串
    object = 3,        // 嵌套对象
    array = 4,         // 数组
    binData = 5,       // 二进制数据
    oid = 7,          // ObjectId
    boolean = 8,       // 布尔值
    date = 9,         // 日期时间
    null = 10,        // null值
    numberInt = 16,   // 32位整数
    timestamp = 17,   // 时间戳
    numberLong = 18,  // 64位整数
    numberDecimal = 19, // 128位十进制
    maxKey = 127      // 最大值类型
};

// 类型判断工具函数
inline bool isNumber(BSONType type) {
    return type == BSONType::numberDouble ||
           type == BSONType::numberInt ||
           type == BSONType::numberLong ||
           type == BSONType::numberDecimal;
}

// 类型优先级比较（用于排序）
int compareTypes(BSONType lhs, BSONType rhs);

// BSON到JSON转换
class BSONObj {
public:
    enum JsonStringFormat {
        ExtendedRelaxedV200,  // MongoDB Extended JSON v2.0 Relaxed
        ExtendedCanonicalV200, // MongoDB Extended JSON v2.0 Canonical
        LegacyStrict         // 传统严格格式
    };
    
    std::string jsonString(JsonStringFormat format = ExtendedRelaxedV200) const {
        StringBuilder builder;
        _jsonStringBuffer(format, 0, true, &builder);
        return builder.str();
    }
};

// JSON到BSON转换
StatusWith<BSONObj> fromjson(StringData jsonString) {
    try {
        // 使用JSON解析器
        JSONParser parser(jsonString);
        return parser.parse();
    } catch (const std::exception& e) {
        return Status(ErrorCodes::FailedToParse, 
                     str::stream() << "JSON parse error: " << e.what());
    }
}

// 场景：构建用户文档
BSONObjBuilder builder;

// 1) 基本字段
builder.append("_id", OID::gen());
builder.append("name", "Alice");
builder.append("age", 30);
builder.append("active", true);

// 2) 嵌套对象
BSONObjBuilder addressBuilder;
addressBuilder.append("city", "Beijing");
addressBuilder.append("country", "China");
builder.append("address", addressBuilder.obj());

// 3) 数组
BSONArrayBuilder tagsBuilder;
tagsBuilder.append("developer");
tagsBuilder.append("mongodb");
builder.append("tags", tagsBuilder.arr());

// 4) 生成文档
BSONObj userDoc = builder.obj();

// 场景：解析网络接收的BSON数据
const char* bsonData = receiveFromNetwork();
BSONObj doc(bsonData);

// 1) 访问顶层字段
std::string name = doc["name"].String();
int age = doc["age"].Int();

// 2) 访问嵌套字段
BSONObj address = doc["address"].Obj();
std::string city = address["city"].String();

// 或使用点分路径
std::string city2 = doc.getFieldDotted("address.city").String();

// 3) 遍历数组
BSONElement tagsElem = doc["tags"];
if (tagsElem.type() == BSONType::Array) {
    for (auto tag : tagsElem.Array()) {
        std::cout << tag.String() << std::endl;
    }
}

// 4) 遍历所有字段
for (auto elem : doc) {
    std::cout << elem.fieldNameStringData() 
              << ": " << elem.toString() << std::endl;
}

// ❌ 低效：多次拷贝BSONObj 
void processDocs(const std::vector<BSONObj>& docs) {
    for (BSONObj doc : docs) {  // 拷贝构造
        BSONObj copy = doc;     // 再次拷贝
        process(copy);
    }
}

// ✅ 高效：引用传递
void processDocs(const std::vector<BSONObj>& docs) {
    for (const BSONObj& doc : docs) {  // 引用，无拷贝
        process(doc);
    }
}

// ❌ 低效：频繁扩容
BSONObj buildLargeDoc() {
    BSONObjBuilder builder; // 默认64字节，需要多次扩容
    for (int i = 0; i < 1000; ++i) {
        builder.append("field" + std::to_string(i), i);
    }
    return builder.obj();
}

// ✅ 高效：预估大小
BSONObj buildLargeDoc() {
    BSONObjBuilder builder(16 * 1024); // 预分配16KB
    for (int i = 0; i < 1000; ++i) {
        builder.append("field" + std::to_string(i), i);
    }
    return builder.obj();
}

// ❌ 低效：重复查找
void processDoc(const BSONObj& doc) {
    if (doc.hasField("name")) {
        std::string name = doc["name"].String(); // 第一次查找
        if (doc["name"].String().length() > 10) { // 第二次查找
            // 处理长名称
        }
    }
}

// ✅ 高效：缓存元素
void processDoc(const BSONObj& doc) {
    BSONElement nameElem = doc["name"]; // 只查找一次
    if (!nameElem.eoo()) {
        std::string name = nameElem.String();
        if (name.length() > 10) {
            // 处理长名称
        }
    }
}