Struct Model

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

Implementations

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

where M: Boot + Default + Serialize + DeserializeOwned + Send + Sync + Unpin,

pub fn new( db: &Database, collection_name: &'a str, columns: &'a str, add_times: bool, ) -> Model<'a, M>

pub fn set_request(self, req: M::Req) -> Model<'a, M>

Set Request to model

pub fn add_columns(&mut self, names: Vec<&'a str>)

add lazy column to model

pub fn collection_name(&self) -> &'a str

Gets the collection name

pub fn collection(&self) -> Collection<M>

Gets a handle to the MongoDB collection

pub fn set_collection(self, name: &'a str) -> Model<'a, M>

Changes the collection name for this model

pub async fn register_indexes(&self)

Registers indexes based on column attributes

This will:

1. Check existing indexes
2. Remove indexes for fields that no longer exist in the model
3. Create new indexes for fields marked as indexes in column attributes

pub fn reset(self) -> Model<'a, M>

Reset all filters

pub fn where(self, data: Document) -> Model<'a, M>

Adds a filter condition to the query

pub fn skip(self, count: u32) -> Model<'a, M>

Sets the number of documents to skip

pub async fn distinct(&self, name: &str) -> Result<Vec<Bson>>

Gets distinct values for a field

pub fn limit(self, count: u32) -> Model<'a, M>

Sets the maximum number of documents to return

pub fn sort(self, data: Document) -> Model<'a, M>

Sets the sort order

pub fn all(self) -> Model<'a, M>

Sets whether to affect all matching documents (for update/delete)

pub fn select(self, data: Document) -> Model<'a, M>

Sets the projection (field selection)

pub fn visible(self, data: Vec<&str>) -> Model<'a, M>

Sets which fields should be visible (overrides hidden fields)

pub fn upsert(self) -> Model<'a, M>

Sets whether to upsert on update

pub async fn count_documents(self) -> Result<u64>

Get Documents count with filters

pub async fn create( &self, session: Option<&mut ClientSession>, ) -> Result<InsertOneResult>

Creates a new document in the collection

Arguments

• session - Optional MongoDB transaction session

Notes

• Automatically adds timestamps if configured

pub async fn create_doc( &self, data: Document, session: Option<&mut ClientSession>, ) -> Result<InsertOneResult>

Creates a new document from raw BSON

pub async fn update( &self, data: Document, session: Option<&mut ClientSession>, ) -> Result<Document>

Updates documents in the collection

Arguments

• data - Update operations
• session - Optional MongoDB transaction session

Notes

• Automatically adds updated_at timestamp if configured
• Handles both single and multi-document updates based on all() setting
• Supports upsert if configured

pub async fn delete( &self, session: Option<&mut ClientSession>, ) -> Result<Document>

Deletes documents from the collection

Arguments

• session - Optional MongoDB transaction session

Notes

• Handles both single and multi-document deletes based on all() setting

pub async fn get(&self, session: Option<&mut ClientSession>) -> Result<Vec<M>>

Queries documents from the collection

Arguments

• session - Optional MongoDB transaction session

Notes

• Respects skip/limit/sort/select settings
• Filters out hidden fields unless explicitly made visible

pub async fn first( &mut self, session: Option<&mut ClientSession>, ) -> Result<Option<M>>

Gets the first matching document

pub async fn aggregate( &mut self, pipeline: impl IntoIterator<Item = Document>, session: Option<&mut ClientSession>, ) -> Result<Vec<M>>

Runs an aggregation pipeline

pub async fn get_doc( &self, session: Option<&mut ClientSession>, ) -> Result<Vec<Document>>

Queries documents and returns raw BSON

pub async fn first_doc( &mut self, session: Option<&mut ClientSession>, ) -> Result<Option<Document>>

Queries documents and returns first raw BSON

pub async fn aggregate_doc( &mut self, pipeline: impl IntoIterator<Item = Document>, session: Option<&mut ClientSession>, ) -> Result<Vec<Document>>

Runs an aggregation pipeline and returns raw BSON

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

where M: Boot + 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>

pub fn fill(self, inner: M) -> Model<'a, M>

Trait Implementations

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

where M: Boot + Clone, M::Req: Clone,

fn clone(&self) -> Model<'a, M>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

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

where M: Boot + Debug, M::Req: Debug,

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

Formats the value using the given formatter.

impl<'a, T: 'a + Boot> 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 + Boot> DerefMut for Model<'a, T>

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

Mutably dereferences the value.

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

where M: Boot + Serialize,

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

where __S: Serializer,

Serialize this value into the given Serde serializer.