// Recommended: Clear semantics and consistent style
{
    "_id": ObjectId("..."),
    "userName": "Zhang San",           // camelCase style
    "createTime": ISODate("..."),
    "orderItems": [...],
    "totalAmount": 199.00
}

// Not recommended: Confusing naming
{
    "_id": ObjectId("..."),
    "UN": "Zhang San",                 // Unclear abbreviation
    "Create_Time": ISODate("..."), // Mixed style
    "oi": [...],                  // Unclear meaning
    "_total": 199.00              // Business fields starting with an underscore are prone to conflict with system fields.
}

// View the size of a single document
Object.bsonsize(db.collection.findOne({ _id: xxx }))

// View the average document size of a collection (unit: bytes)
db.collection.stats().avgObjSize

// Recommendation: Maintain a moderate nesting level (2-3 layers)
{
    "_id": ObjectId("..."),
    "orderId": "ORD202403001",
    "customer": {                    // Layer 1
        "name": "Zhang San",
        "contact": {                 // Layer 2
            "phone": "13800138000",
            "email": "zhangsan@example.com"
        }
    },
    "items": [{ "productId": "P001", "quantity": 2 }]  // Layer 1 (array)
}

// Not recommended: Excessively deep nesting
{
    "level1": {
        "level2": {
            "level3": {
                "level4": {
                    "level5": {
                        "data": "Too deep to be maintained"
                    }
                }
            }
        }
    }
}

// Order + Order Items: Embedded (Always queried together; order items do not exist independently)
{
    "_id": ObjectId("..."),
    "orderId": "ORD202403001",
    "customerId": "C001",
    "items": [
        { "productId": "P001", "name": "Product A", "quantity": 2, "price": 99.00 },
        { "productId": "P002", "name": "Product B", "quantity": 1, "price": 199.00 }
    ],
    "totalAmount": 397.00,
    "status": "paid",
    "createTime": ISODate("2024-03-15T10:30:00Z")
}

// User + Article: Referenced (Articles are frequently queried independently and their number grows indefinitely)
// User Document
{
    "_id": ObjectId("user_001"),
    "userName": "Zhang San",
    "email": "zhangsan@example.com"
}

// Article Document (referencing the user via authorId)
{
    "_id": ObjectId("article_001"),
    "title": "MongoDB Best Practices",
    "authorId": ObjectId("user_001"),  // referencing the user
    "content": "...",
    "createTime": ISODate("...")
}

// ✅ Hybrid Mode: Redundantly embeds product names and prices (snapshots) in orders while preserving productId references.
{
    "orderId": "ORD001",
    "items": [
        {
            "productId": ObjectId("..."),  // reference (used to associate with the latest product information)
            "name": "Product A",               // redundant (snapshot at order placement to prevent product renaming from affecting historical orders)
            "price": NumberDecimal("99.00") // redundant (price snapshot at order placement)
        }
    ]
}

// Not recommended: unbounded, infinitely growing arrays

{
    "userId": "user_10001",
    "orders": [
        { "orderId": "ORD_001", "amount": 99.00, "date": ISODate("...") },
        { "orderId": "ORD_002", "amount": 158.00, "date": ISODate("...") },
        // ... Active users may accumulate tens of thousands of orders, triggering the 16MB limit.
    ]
}

// Recommended: Split array elements into separate documents and associate them via foreign keys.
// User Document
{
    "userId": "user_10001",
    "name": "Zhang San",
    "orderCount": 1024
}

// Order Document (Independent Collection)
{
    "orderId": "ORD_001",
    "userId": "user_10001",   // foreign key association
    "amount": 99.00,
    "date": ISODate("2024-03-15T10:30:00Z")
}

// Correct Type Usage
{
    "_id": ObjectId("65f3a2b8c1d2e3f4a5b6c7d8"),  // ObjectId
    "orderId": NumberLong("20240315000001"),       // Large integer
    "amount": NumberDecimal("199.99"),             // Use Decimal128 for monetary amounts
    "createTime": ISODate("2024-03-15T10:30:00Z"), // Use Date for dates
    "status": "paid"                               // Use string enumeration for status
}

// Incorrect Type Usage
{
    "_id": "random-uuid-string",          // Random strings impact performance
    "orderId": "20240315000001",          // Strings cannot be sorted numerically
    "amount": 199.99,                     // Double has precision issues
    "createTime": "2024-03-15 10:30:00",  // Strings cannot be used for date arithmetic
    "status": 1                           // Numeric meaning is unclear
}

// Recommendation: Use the default ObjectId
{ "_id": ObjectId("65f3a2b8c1d2e3f4a5b6c7d8") }

// Acceptable: Custom incremental ID (must ensure the incremental characteristic)
{ "_id": NumberLong("20240315000001") }

// Prohibited: Random strings (impact write performance)
{ "_id": "550e8400-e29b-41d4-a716-446655440000" }

// Create a collection with validation rules
db.createCollection("t_users", {
    validator: {
        $jsonSchema: {
            bsonType: "object",
            required: ["userName", "email", "createTime"],
            properties: {
                userName: {
                    bsonType: "string",
                    minLength: 2,
                    maxLength: 50,
                    description: "Username, required, 2-50 characters"
                },
                email: {
                    bsonType: "string",
                    pattern: "^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\\\\.[a-zA-Z]{2,}$",
                    description: "Email, required, must conform to email format"
                },
                age: {
                    bsonType: "int",
                    minimum: 0,
                    maximum: 150,
                    description: "Age, optional, an integer from 0 to 150"
                },
                status: {
                    enum: ["active", "inactive", "deleted"],
                    description: "Status, enumeration value"
                },
                createTime: {
                    bsonType: "date",
                    description: "Creation time, required"
                }
            }
        }
    },
    validationLevel: "strict",    // strict: validates all writes
    validationAction: "error"     // error: rejects writes if validation fails
});