Struct Model

pub struct Model<'a, M> { /* private fields */ }

Implementations

impl<'a, M> Model<'a, M>

where M: Default + Serialize + DeserializeOwned + Send + Sync + Unpin + Debug + ModelTimestamps + Observer<M>,

pub fn new(db: Option<&Arc<Database>>, collection_name: &'a str) -> Model<'a, M>

makes a model and stores the data and collection_name to creating collection object to store data into it

Arguments

• db: you cna pass None , in this way model created by global spark connection , or you can pass your own database
• collection_name: it’s collection name that we use in create collection object

returns: Model

Examples

struct User{
    name: String
}
let db = ...;
let user_model = Model::<User>::new(Arc::clone(db) , "users");

pub async fn save( &mut self, options: impl Into<Option<InsertOneOptions>>, ) -> MongodbResult<Bson>

saves the change , if the inner has some _id then it’s update the existing unless it’s create new document

pub async fn find_one( &mut self, doc: impl Into<Document>, options: impl Into<Option<FindOneOptions>>, ) -> MongodbResult<Option<&mut Self>>

pub async fn update( &self, query: impl Into<Document>, doc: impl Into<Document>, options: impl Into<Option<UpdateOptions>>, ) -> MongodbResult<UpdateResult>

this is raw update , and you can pass document or your model

Examples

with the raw doc

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

with the model

let user_model = User::new_model(Some(&db)); let mut sample_user = User::default(); sample_user.name = “Hossein 33”.to_string(); let updated = user_model.update( &sample_user, doc! { “$set”: { “name”: “Hossein 3355” } }, None, ).await.unwrap();

with_model_instance

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

user_model.name = “Hossein 3355”.to_string(); user_model.age = 58; let updated = user_model.update( &user_model, doc! { “$set”: { “name”: “Hossein 325” } }, None, ).await.unwrap();

NOTE : updated observer doesn’t execute in this method

pub async fn find( &self, filter: impl Into<Document>, options: impl Into<Option<FindOptions>>, ) -> MongodbResult<Cursor<M>>

pub async fn find_and_collect( &self, filter: impl Into<Document>, options: impl Into<Option<FindOptions>>, ) -> MongodbResult<Vec<MongodbResult<M>>>

pub fn register_attributes(&self, attributes: Vec<&str>)

pub async fn delete( &mut self, query: impl Into<Document>, options: impl Into<Option<DeleteOptions>>, ) -> MongodbResult<u64>

pub fn fill(&mut self, inner: M)

impl<'a, M> Model<'a, M>

where M: Default + Serialize,

pub fn take_inner(&mut self) -> M

this method takes the inner and gives you ownership of inner then replace it with default value

pub fn inner_ref(&self) -> &M

pub fn inner_mut(&mut self) -> &mut M

pub fn inner_to_doc(&self) -> MongodbResult<Document>

Trait Implementations

impl<'a, M: Debug> Debug for Model<'a, M>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'a, T: 'a> Deref for Model<'a, T>

type Target = T

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<'a, T: 'a> DerefMut for Model<'a, T>

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl<'a, M> From<&Model<'a, M>> for Document

where M: Serialize,

fn from(value: &Model<'a, M>) -> Self

Converts to this type from the input type.

impl<'a, M> From<&mut Model<'a, M>> for Document

where M: Serialize,

fn from(value: &mut Model<'a, M>) -> Self

Converts to this type from the input type.

impl<'a, M> From<Model<'a, M>> for Document

where M: Serialize,

fn from(value: Model<'_, M>) -> Self

Converts to this type from the input type.

impl<'a, M> Serialize for Model<'a, M>

where M: Serialize,

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.