Spark-ORM：Rust的MongoDB ORM库

Spark-ORM是一个高性能、开源的对象关系映射（ORM）库，专门为Rust中的MongoDB设计。它无缝地将Rust结构体与MongoDB集合连接起来，轻松地将结构体转换为模型。

功能

• 派生模型：使用Model特质派生，轻松将Rust结构体转换为MongoDB模型。

• 自定义集合名称：使用#[coll_name]属性为您的模型定制集合名称。

• 内存效率：Spark-ORM旨在速度和内存效率，为MongoDB提供非堆复制ORM解决方案。

入门指南

1. 通过简单地应用Model属性并使用coll_name设置集合名称来定义您的模型。

   #[Model(coll_name = "users")]
   #[derive(Serialize, Deserialize, Default, Debug)]
   struct User {
   age: u32,
   name: String,
   email: String,
   }
   

2. 以两种方式之一连接到数据库

   a. 建立全局连接

   Spark::global_connect("root", "123", "localhost", "6789", "rm_orm_db").await;
   

   b. 或者本地连接

   Spark::connect("root", "123", "localhost", "6789", "rm_orm_db").await;
   

   对于全局连接，Spark在整个程序中保留它，可以通过以下方式访问：Spark::get_db();

用法

实例化模型

    let mut user = User::new_model(Some(&db));

或者您可以使用全局连接

 let mut user = User::new_model(None);

如果没有设置全局连接，则new_model函数将panic

更新属性

   user.name = "Hossein".to_string();
   user.age = 22;

保存到数据库

   user.save().await.unwrap();

查找模型

        let mut user_model = User::new_model(Some(&db)); 
        let mut sample = User::default ();
        sample.name = "Hossein".to_string();
        let founded = user_model.find_one(
            sample,
            None,
            ).await.unwrap();
        println!("The founded object {:?} ", founded);

更新并保存

    let mut user = User::new_model(Some(&db));
    user.name = "Hossein".to_string();
    user.email = "spark_orm_test".to_string();

    user.save().await;

    user.name = "Nothing".to_string();

    user.save().await;

或者

      let db = get_db().await;
      let user_model = User::new_model(Some(&db));
      let updated = user_model.update(
      doc! {
                  "name": "Hossein",
              },
      doc! {
                  "$set": {
                      "name": "Hossein 33"
                  }
              },
      None,
      ).await.unwrap();
       println!("The Updated info {:?}", updated);

删除记录

        let mut user = User::new_model(Some(&db));
        user.delete().await;

注意：您可以使用?代替unwrap

模型

模型特质为您的结构体添加_id、时间戳（created_at、updated_at、deleted_at），并自动填充

属性

为结构体字段定义索引或唯一属性

   #[Model(coll_name = "products")]
   #[derive(Serialize, Deserialize, Default, Debug)]
   struct Product {
       #[index]
       age: u32,
       #[index]
       name: String,
       #[unique]
       email: String,
   }

这些索引在Product首次初始化时注册。

模型观察者

在模型中调用某些操作的观察者

要使用观察者，你只需要将 observer 放入 Model 宏中即可，例如： #[Model(coll_name='users' , observer)]

并为你的模型实现 Observer<T>，支持的方法有 创建、更新、删除

    
#[Model(coll_name = "users", observer)]
#[derive(Serialize, Deserialize, Debug, Default)]
struct User {
    name: String,
}

#[Model(coll_name = "persons", observer)]
#[derive(Serialize, Deserialize, Debug, Default)]
struct Person {
    name: String,
}


impl Observer<User> for User {
    async fn created(model: &mut Model<'_, User>) -> MongodbResult<()> {
        let mut person_model = Person::new_model(None);
        if model.name == "Hello".to_string() {
            model.name = "Something".to_string();
            model.save(None).await?;
        }
        person_model.name = "Naruto".to_string();
        person_model.save(None).await?;
        Ok(())
    }
}

#[allow(clippy::assigning_clones)]
impl Observer<Person> for Person {
    async fn created(model: &mut Model<'_, Person>) -> MongodbResult<()> {
        let mut jobs = Jobs::new_model(None);
        jobs.person.name = model.name.clone();
        jobs.save(None).await?;
        Ok(())
    }

    async fn updated(model: &mut Model<'_, Person>) -> MongodbResult<()> {
        Ok(())
    }

    async fn deleted(model: &mut Model<'_, Person>) -> MongodbResult<()> {
        Ok(())
    }
}

我非常感谢你在 GitHub 上的支持。请考虑给我一个 star 来表示你的支持。谢谢！

请注意，该库正在开发中，未来可能会有很多变化，甚至包括其基础部分