处理MongoDB中字段类型不确定性的MongoEngine策略

from mongoengine import Document, EmbeddedDocument, DynamicField, fields, ValidationError

class MyParticularField(EmbeddedDocument):
    """
    表示 my_field 字段可能存储的特定对象类型。
    """
    name = fields.StringField(required=True, help_text="对象的名称")
    value = fields.IntField(default=0, help_text="对象的数值")
    description = fields.StringField(required=False, help_text="对象的描述")

    def __str__(self):
        return f"MyParticularField(name='{self.name}', value={self.value})"

class MyDBEntity(Document):
    """
    主文档模型，my_field 字段可以为 null、list 或 MyParticularField 对象。
    """
    my_field = DynamicField(null=True, help_text="一个可以存储 null、列表或特定对象的字段")
    other_field = fields.StringField(help_text="其他常规字段")

    def clean(self):
        """
        自定义校验方法，确保 my_field 的类型和结构符合预期。
        """
        # 允许 my_field 为 None
        if self.my_field is None:
            return

        # 允许 my_field 为列表
        if isinstance(self.my_field, list):
            # 如果列表内的元素也需要特定校验，可以在这里添加。
            # 例如：检查列表是否只包含字符串或特定类型
            # for item in self.my_field:
            #     if not isinstance(item, str):
            #         raise ValidationError("列表中的所有元素必须是字符串")
            return

        # 如果 my_field 既不是 None 也不是列表，那么它必须是 MyParticularField 对象或可转换为它的字典
        if isinstance(self.my_field, MyParticularField):
            # 如果已经是 MyParticularField 实例，则认为是有效的
            return
        elif isinstance(self.my_field, dict):
            # 如果是字典，尝试将其作为 MyParticularField 进行验证
            try:
                # 尝试创建 MyParticularField 实例并触发其内部验证
                temp_field = MyParticularField(**self.my_field)
                temp_field.validate() # 显式调用 validate 方法进行字段级校验
            except (ValidationError, TypeError, KeyError) as e:
                # 捕获验证错误、类型错误或键错误，说明字典结构不符合 MyParticularField 的要求
                raise ValidationError(
                    f"my_field 的对象结构不符合 MyParticularField 的定义: {e}"
                )
            return
        else:
            # 如果是其他任何类型，则抛出验证错误
            raise ValidationError(
                "my_field 必须为 None、一个列表或一个符合 MyParticularField 结构的对象。"
            )

    meta = {
        'collection': 'my_db_entities',
        'strict': False # 允许存储未在模型中定义的字段，但建议谨慎使用
    }

from mongoengine import connect

# 连接到 MongoDB 数据库
connect('mydatabase', host='mongodb://localhost/mydatabase')

# 清空集合以便测试
MyDBEntity.drop_collection()

# 示例 1: my_field 为 None
entity1 = MyDBEntity(other_field="Entity with null my_field")
entity1.save()
print(f"Saved entity 1 (null my_field): {entity1.id}")

# 示例 2: my_field 为列表
entity2 = MyDBEntity(
    my_field=["item1", "item2", 123],
    other_field="Entity with list my_field"
)
entity2.save()
print(f"Saved entity 2 (list my_field): {entity2.id}")

# 示例 3: my_field 为 MyParticularField 对象 (直接传入实例)
particular_obj_instance = MyParticularField(name="Instance A", value=100)
entity3 = MyDBEntity(
    my_field=particular_obj_instance,
    other_field="Entity with object instance my_field"
)
entity3.save()
print(f"Saved entity 3 (object instance my_field): {entity3.id}")

# 示例 4: my_field 为 MyParticularField 对象 (传入字典，由 clean 方法校验)
entity4 = MyDBEntity(
    my_field={"name": "Instance B", "value": 200, "description": "Another object"},
    other_field="Entity with object dict my_field"
)
entity4.save()
print(f"Saved entity 4 (object dict my_field): {entity4.id}")

# 示例 5: 尝试保存一个无效的 my_field (非 None, 非 list, 非 MyParticularField 结构)
try:
    entity5 = MyDBEntity(
        my_field="just a string",
        other_field="Entity with invalid my_field"
    )
    entity5.save()
except ValidationError as e:
    print(f"\nCaught expected validation error for entity 5: {e}")

# 示例 6: 尝试保存一个结构不完整的 MyParticularField 对象 (缺少 required 字段)
try:
    entity6 = MyDBEntity(
        my_field={"value": 300}, # 缺少 'name' 字段
        other_field="Entity with incomplete object my_field"
    )
    entity6.save()
except ValidationError as e:
    print(f"Caught expected validation error for entity 6: {e}")

# 从数据库中加载并验证
print("\n--- Loaded Entities ---")
for entity in MyDBEntity.objects:
    print(f"ID: {entity.id}, Other Field: {entity.other_field}, My Field Type: {type(entity.my_field)}, Value: {entity.my_field}")
    # 验证加载后的 my_field 类型
    if isinstance(entity.my_field, dict) and 'name' in entity.my_field and 'value' in entity.my_field:
        # 对于通过字典保存的 EmbeddedDocument，加载时会是字典。
        # 如果需要将其转换为 MyParticularField 实例，可以在加载后手动处理或使用更复杂的字段类型。
        print(f"  (Loaded as dict, looks like MyParticularField: {entity.my_field})")
    elif isinstance(entity.my_field, MyParticularField):
        print(f"  (Loaded as MyParticularField instance: {entity.my_field})")