Struct TitoModel 

pub struct TitoModel<E: TitoEngine, T> {
    pub model: T,
    pub engine: E,
}

Fields

model: T

engine: E

Implementations

impl<E: TitoEngine, T: TitoModelConstraints> TitoModel<E, T>

pub fn get_embedded_relationships(&self) -> Vec<TitoEmbeddedRelationshipConfig>

pub fn get_table(&self) -> String

pub fn get_id_from_table(&self, key: String) -> String

pub fn query_by_index( &self, index: impl Into<String>, ) -> IndexQueryBuilder<E, T>

Examples found in repository

examples/blog.rs (line 288)

async fn main() -> Result<(), TitoError> {
    // Connect to TiKV
    let tito_db = TiKV::connect(vec!["127.0.0.1:2379"]).await?;

    // Create models
    let post_model = tito_db.clone().model::<Post>();
    let tag_model = tito_db.clone().model::<Tag>();

    // Create some tags
    let tech_tag = tito_db
        .transaction(|tx| {
            let tag_model = tag_model.clone();
            let tag = Tag {
                id: DBUuid::new_v4().to_string(),
                name: "Technology".to_string(),
                description: "All about tech".to_string(),
            };
            let tag_clone = tag.clone();

            async move {
                tag_model.build(tag_clone, &tx).await?;
                Ok::<_, TitoError>(tag)
            }
        })
        .await?;

    let travel_tag = tito_db
        .transaction(|tx| {
            let tag_model = tag_model.clone();
            let tag = Tag {
                id: DBUuid::new_v4().to_string(),
                name: "Travel".to_string(),
                description: "Adventures around the world".to_string(),
            };
            let tag_clone = tag.clone();

            async move {
                tag_model.build(tag_clone, &tx).await?;
                Ok::<_, TitoError>(tag)
            }
        })
        .await?;

    let rust_tag = tito_db
        .transaction(|tx| {
            let tag_model = tag_model.clone();
            let tag = Tag {
                id: DBUuid::new_v4().to_string(),
                name: "Rust".to_string(),
                description: "Rust programming language".to_string(),
            };
            let tag_clone = tag.clone();

            async move {
                tag_model.build(tag_clone, &tx).await?;
                Ok::<_, TitoError>(tag)
            }
        })
        .await?;

    let database_tag = tito_db
        .transaction(|tx| {
            let tag_model = tag_model.clone();
            let tag = Tag {
                id: DBUuid::new_v4().to_string(),
                name: "Databases".to_string(),
                description: "Database systems and technologies".to_string(),
            };
            let tag_clone = tag.clone();

            async move {
                tag_model.build(tag_clone, &tx).await?;
                Ok::<_, TitoError>(tag)
            }
        })
        .await?;

    println!("Created tags:");
    println!("- {}: {}", tech_tag.name, tech_tag.id);
    println!("- {}: {}", travel_tag.name, travel_tag.id);
    println!("- {}: {}", rust_tag.name, rust_tag.id);
    println!("- {}: {}", database_tag.name, database_tag.id);

    // Create some posts with multiple tags
    let post1 = tito_db
        .transaction(|tx| {
            let post_model = post_model.clone();
            let post = Post {
                id: DBUuid::new_v4().to_string(),
                title: "Introduction to TiKV".to_string(),
                content: "TiKV is a distributed key-value storage system...".to_string(),
                author: "Alice".to_string(),
                tag_ids: vec![tech_tag.id.clone(), database_tag.id.clone()],
                tags: Vec::new(),
            };
            let post_clone = post.clone();

            async move {
                post_model.build(post_clone, &tx).await?;
                Ok::<_, TitoError>(post)
            }
        })
        .await?;

    let post2 = tito_db
        .transaction(|tx| {
            let post_model = post_model.clone();
            let post = Post {
                id: DBUuid::new_v4().to_string(),
                title: "Best cities to visit in Europe".to_string(),
                content: "Europe offers a diverse range of cities...".to_string(),
                author: "Bob".to_string(),
                tag_ids: vec![travel_tag.id.clone()],
                tags: Vec::new(),
            };
            let post_clone = post.clone();

            async move {
                post_model.build(post_clone, &tx).await?;
                Ok::<_, TitoError>(post)
            }
        })
        .await?;

    let post3 = tito_db
        .transaction(|tx| {
            let post_model = post_model.clone();
            let post = Post {
                id: DBUuid::new_v4().to_string(),
                title: "Using Rust with TiKV".to_string(),
                content: "Here are some examples of using Rust with TiKV...".to_string(),
                author: "Alice".to_string(),
                tag_ids: vec![
                    tech_tag.id.clone(),
                    rust_tag.id.clone(),
                    database_tag.id.clone(),
                ],
                tags: Vec::new(),
            };
            let post_clone = post.clone();

            async move {
                post_model.build(post_clone, &tx).await?;
                Ok::<_, TitoError>(post)
            }
        })
        .await?;

    println!("\nCreated posts:");
    println!("1. {} (by {})", post1.title, post1.author);
    println!("2. {} (by {})", post2.title, post2.author);
    println!("3. {} (by {})", post3.title, post3.author);

    // Get a post with all its tags
    let post_with_tags = post_model
        .find_by_id(&post1.id, vec!["tags".to_string()])
        .await?;
    println!("\nPost with tags:");
    println!("Title: {}", post_with_tags.title);
    println!("Tags:");
    for tag in &post_with_tags.tags {
        println!("- {}", tag.name);
    }

    // Find posts by tag using the query builder
    let mut tech_query = post_model.query_by_index("post-by-tag");
    let tech_results = tech_query
        .value(tech_tag.id.clone())
        .relationship("tags")
        .execute()
        .await?;

    println!("\nTechnology posts:");
    for post in &tech_results.items {
        println!("- {} (by {})", post.title, post.author);
        println!(
            "  Tags: {}",
            post.tags
                .iter()
                .map(|t| t.name.clone())
                .collect::<Vec<_>>()
                .join(", ")
        );
    }

    // Find posts by author using the query builder
    let mut alice_query = post_model.query_by_index("post-by-author");
    let alice_results = alice_query
        .value("Alice".to_string())
        .relationship("tags")
        .execute()
        .await?;

    println!("\nAlice's posts:");
    for post in &alice_results.items {
        println!("- {}", post.title);
        println!(
            "  Tags: {}",
            post.tags
                .iter()
                .map(|t| t.name.clone())
                .collect::<Vec<_>>()
                .join(", ")
        );
    }

    Ok(())
}

pub async fn tx<F, Fut, R, Err>(&self, f: F) -> Result<R, Err>

where F: FnOnce(E::Transaction) -> Fut + Send, Fut: Future<Output = Result<R, Err>> + Send, Err: From<TitoError> + Send + Sync + Debug, R: Send,

pub async fn get_key( &self, key: &str, tx: &E::Transaction, ) -> Result<Value, TitoError>

pub async fn delete( &self, key: String, tx: &E::Transaction, ) -> Result<bool, TitoError>

pub fn to_paginated_items_with_cursor( &self, items: Vec<(String, Value)>, cursor: String, ) -> Result<TitoPaginated<T>, TitoError>

pub fn to_paginated_items( &self, items: Vec<(String, Value)>, has_more: bool, ) -> Result<TitoPaginated<T>, TitoError>

pub fn get_nested_values( &self, json: &Value, field_path: &str, ) -> Option<Vec<Value>>

pub async fn build( &self, payload: T, tx: &E::Transaction, ) -> Result<T, TitoError>

where T: DeserializeOwned,

Examples found in repository

examples/crud.rs (line 68)

async fn main() -> Result<(), TitoError> {
    // Connect to TiKV
    let tito_db = TiKV::connect(vec!["127.0.0.1:2379"]).await?;

    // Create model with dynamic backend
    let user_model = tito_db.clone().model::<User>();

    // Create a user
    let user_id = DBUuid::new_v4().to_string();
    let user = User {
        id: user_id.clone(),
        name: "John Doe".to_string(),
        email: "john@example.com".to_string(),
    };

    // Create user with transaction
    let saved_user = tito_db
        .transaction(|tx| {
            let user_model = user_model.clone();
            async move { user_model.build(user, &tx).await }
        })
        .await?;

    println!("Created user: {:?}", saved_user);

    // Find user (find_by_id already uses transaction internally)
    let found_user = user_model.find_by_id(&user_id, vec![]).await?;
    println!("Found user: {:?}", found_user);

    // Update user
    let updated_user = User {
        id: user_id.clone(),
        name: "John Updated".to_string(),
        email: "john_updated@example.com".to_string(),
    };

    tito_db
        .transaction(|tx| {
            let user_model = user_model.clone();
            async move { user_model.update(updated_user, &tx).await }
        })
        .await?;

    println!("User updated successfully");

    // Delete user
    tito_db
        .transaction(|tx| {
            let user_model = user_model.clone();
            async move { user_model.delete_by_id(&user_id, &tx).await }
        })
        .await?;

    println!("User deleted successfully");

    Ok(())
}

examples/blog.rs (line 143)

async fn main() -> Result<(), TitoError> {
    // Connect to TiKV
    let tito_db = TiKV::connect(vec!["127.0.0.1:2379"]).await?;

    // Create models
    let post_model = tito_db.clone().model::<Post>();
    let tag_model = tito_db.clone().model::<Tag>();

    // Create some tags
    let tech_tag = tito_db
        .transaction(|tx| {
            let tag_model = tag_model.clone();
            let tag = Tag {
                id: DBUuid::new_v4().to_string(),
                name: "Technology".to_string(),
                description: "All about tech".to_string(),
            };
            let tag_clone = tag.clone();

            async move {
                tag_model.build(tag_clone, &tx).await?;
                Ok::<_, TitoError>(tag)
            }
        })
        .await?;

    let travel_tag = tito_db
        .transaction(|tx| {
            let tag_model = tag_model.clone();
            let tag = Tag {
                id: DBUuid::new_v4().to_string(),
                name: "Travel".to_string(),
                description: "Adventures around the world".to_string(),
            };
            let tag_clone = tag.clone();

            async move {
                tag_model.build(tag_clone, &tx).await?;
                Ok::<_, TitoError>(tag)
            }
        })
        .await?;

    let rust_tag = tito_db
        .transaction(|tx| {
            let tag_model = tag_model.clone();
            let tag = Tag {
                id: DBUuid::new_v4().to_string(),
                name: "Rust".to_string(),
                description: "Rust programming language".to_string(),
            };
            let tag_clone = tag.clone();

            async move {
                tag_model.build(tag_clone, &tx).await?;
                Ok::<_, TitoError>(tag)
            }
        })
        .await?;

    let database_tag = tito_db
        .transaction(|tx| {
            let tag_model = tag_model.clone();
            let tag = Tag {
                id: DBUuid::new_v4().to_string(),
                name: "Databases".to_string(),
                description: "Database systems and technologies".to_string(),
            };
            let tag_clone = tag.clone();

            async move {
                tag_model.build(tag_clone, &tx).await?;
                Ok::<_, TitoError>(tag)
            }
        })
        .await?;

    println!("Created tags:");
    println!("- {}: {}", tech_tag.name, tech_tag.id);
    println!("- {}: {}", travel_tag.name, travel_tag.id);
    println!("- {}: {}", rust_tag.name, rust_tag.id);
    println!("- {}: {}", database_tag.name, database_tag.id);

    // Create some posts with multiple tags
    let post1 = tito_db
        .transaction(|tx| {
            let post_model = post_model.clone();
            let post = Post {
                id: DBUuid::new_v4().to_string(),
                title: "Introduction to TiKV".to_string(),
                content: "TiKV is a distributed key-value storage system...".to_string(),
                author: "Alice".to_string(),
                tag_ids: vec![tech_tag.id.clone(), database_tag.id.clone()],
                tags: Vec::new(),
            };
            let post_clone = post.clone();

            async move {
                post_model.build(post_clone, &tx).await?;
                Ok::<_, TitoError>(post)
            }
        })
        .await?;

    let post2 = tito_db
        .transaction(|tx| {
            let post_model = post_model.clone();
            let post = Post {
                id: DBUuid::new_v4().to_string(),
                title: "Best cities to visit in Europe".to_string(),
                content: "Europe offers a diverse range of cities...".to_string(),
                author: "Bob".to_string(),
                tag_ids: vec![travel_tag.id.clone()],
                tags: Vec::new(),
            };
            let post_clone = post.clone();

            async move {
                post_model.build(post_clone, &tx).await?;
                Ok::<_, TitoError>(post)
            }
        })
        .await?;

    let post3 = tito_db
        .transaction(|tx| {
            let post_model = post_model.clone();
            let post = Post {
                id: DBUuid::new_v4().to_string(),
                title: "Using Rust with TiKV".to_string(),
                content: "Here are some examples of using Rust with TiKV...".to_string(),
                author: "Alice".to_string(),
                tag_ids: vec![
                    tech_tag.id.clone(),
                    rust_tag.id.clone(),
                    database_tag.id.clone(),
                ],
                tags: Vec::new(),
            };
            let post_clone = post.clone();

            async move {
                post_model.build(post_clone, &tx).await?;
                Ok::<_, TitoError>(post)
            }
        })
        .await?;

    println!("\nCreated posts:");
    println!("1. {} (by {})", post1.title, post1.author);
    println!("2. {} (by {})", post2.title, post2.author);
    println!("3. {} (by {})", post3.title, post3.author);

    // Get a post with all its tags
    let post_with_tags = post_model
        .find_by_id(&post1.id, vec!["tags".to_string()])
        .await?;
    println!("\nPost with tags:");
    println!("Title: {}", post_with_tags.title);
    println!("Tags:");
    for tag in &post_with_tags.tags {
        println!("- {}", tag.name);
    }

    // Find posts by tag using the query builder
    let mut tech_query = post_model.query_by_index("post-by-tag");
    let tech_results = tech_query
        .value(tech_tag.id.clone())
        .relationship("tags")
        .execute()
        .await?;

    println!("\nTechnology posts:");
    for post in &tech_results.items {
        println!("- {} (by {})", post.title, post.author);
        println!(
            "  Tags: {}",
            post.tags
                .iter()
                .map(|t| t.name.clone())
                .collect::<Vec<_>>()
                .join(", ")
        );
    }

    // Find posts by author using the query builder
    let mut alice_query = post_model.query_by_index("post-by-author");
    let alice_results = alice_query
        .value("Alice".to_string())
        .relationship("tags")
        .execute()
        .await?;

    println!("\nAlice's posts:");
    for post in &alice_results.items {
        println!("- {}", post.title);
        println!(
            "  Tags: {}",
            post.tags
                .iter()
                .map(|t| t.name.clone())
                .collect::<Vec<_>>()
                .join(", ")
        );
    }

    Ok(())
}

pub async fn build_with_options( &self, payload: T, options: TitoOptions, tx: &E::Transaction, ) -> Result<T, TitoError>

where T: DeserializeOwned,

pub async fn find_by_id_tx( &self, id: &str, rels: Vec<String>, tx: &E::Transaction, ) -> Result<T, TitoError>

where T: DeserializeOwned,

pub async fn find_by_id( &self, id: &str, rels: Vec<String>, ) -> Result<T, TitoError>

where T: DeserializeOwned,

Examples found in repository

examples/crud.rs (line 75)

async fn main() -> Result<(), TitoError> {
    // Connect to TiKV
    let tito_db = TiKV::connect(vec!["127.0.0.1:2379"]).await?;

    // Create model with dynamic backend
    let user_model = tito_db.clone().model::<User>();

    // Create a user
    let user_id = DBUuid::new_v4().to_string();
    let user = User {
        id: user_id.clone(),
        name: "John Doe".to_string(),
        email: "john@example.com".to_string(),
    };

    // Create user with transaction
    let saved_user = tito_db
        .transaction(|tx| {
            let user_model = user_model.clone();
            async move { user_model.build(user, &tx).await }
        })
        .await?;

    println!("Created user: {:?}", saved_user);

    // Find user (find_by_id already uses transaction internally)
    let found_user = user_model.find_by_id(&user_id, vec![]).await?;
    println!("Found user: {:?}", found_user);

    // Update user
    let updated_user = User {
        id: user_id.clone(),
        name: "John Updated".to_string(),
        email: "john_updated@example.com".to_string(),
    };

    tito_db
        .transaction(|tx| {
            let user_model = user_model.clone();
            async move { user_model.update(updated_user, &tx).await }
        })
        .await?;

    println!("User updated successfully");

    // Delete user
    tito_db
        .transaction(|tx| {
            let user_model = user_model.clone();
            async move { user_model.delete_by_id(&user_id, &tx).await }
        })
        .await?;

    println!("User deleted successfully");

    Ok(())
}

examples/blog.rs (line 278)

async fn main() -> Result<(), TitoError> {
    // Connect to TiKV
    let tito_db = TiKV::connect(vec!["127.0.0.1:2379"]).await?;

    // Create models
    let post_model = tito_db.clone().model::<Post>();
    let tag_model = tito_db.clone().model::<Tag>();

    // Create some tags
    let tech_tag = tito_db
        .transaction(|tx| {
            let tag_model = tag_model.clone();
            let tag = Tag {
                id: DBUuid::new_v4().to_string(),
                name: "Technology".to_string(),
                description: "All about tech".to_string(),
            };
            let tag_clone = tag.clone();

            async move {
                tag_model.build(tag_clone, &tx).await?;
                Ok::<_, TitoError>(tag)
            }
        })
        .await?;

    let travel_tag = tito_db
        .transaction(|tx| {
            let tag_model = tag_model.clone();
            let tag = Tag {
                id: DBUuid::new_v4().to_string(),
                name: "Travel".to_string(),
                description: "Adventures around the world".to_string(),
            };
            let tag_clone = tag.clone();

            async move {
                tag_model.build(tag_clone, &tx).await?;
                Ok::<_, TitoError>(tag)
            }
        })
        .await?;

    let rust_tag = tito_db
        .transaction(|tx| {
            let tag_model = tag_model.clone();
            let tag = Tag {
                id: DBUuid::new_v4().to_string(),
                name: "Rust".to_string(),
                description: "Rust programming language".to_string(),
            };
            let tag_clone = tag.clone();

            async move {
                tag_model.build(tag_clone, &tx).await?;
                Ok::<_, TitoError>(tag)
            }
        })
        .await?;

    let database_tag = tito_db
        .transaction(|tx| {
            let tag_model = tag_model.clone();
            let tag = Tag {
                id: DBUuid::new_v4().to_string(),
                name: "Databases".to_string(),
                description: "Database systems and technologies".to_string(),
            };
            let tag_clone = tag.clone();

            async move {
                tag_model.build(tag_clone, &tx).await?;
                Ok::<_, TitoError>(tag)
            }
        })
        .await?;

    println!("Created tags:");
    println!("- {}: {}", tech_tag.name, tech_tag.id);
    println!("- {}: {}", travel_tag.name, travel_tag.id);
    println!("- {}: {}", rust_tag.name, rust_tag.id);
    println!("- {}: {}", database_tag.name, database_tag.id);

    // Create some posts with multiple tags
    let post1 = tito_db
        .transaction(|tx| {
            let post_model = post_model.clone();
            let post = Post {
                id: DBUuid::new_v4().to_string(),
                title: "Introduction to TiKV".to_string(),
                content: "TiKV is a distributed key-value storage system...".to_string(),
                author: "Alice".to_string(),
                tag_ids: vec![tech_tag.id.clone(), database_tag.id.clone()],
                tags: Vec::new(),
            };
            let post_clone = post.clone();

            async move {
                post_model.build(post_clone, &tx).await?;
                Ok::<_, TitoError>(post)
            }
        })
        .await?;

    let post2 = tito_db
        .transaction(|tx| {
            let post_model = post_model.clone();
            let post = Post {
                id: DBUuid::new_v4().to_string(),
                title: "Best cities to visit in Europe".to_string(),
                content: "Europe offers a diverse range of cities...".to_string(),
                author: "Bob".to_string(),
                tag_ids: vec![travel_tag.id.clone()],
                tags: Vec::new(),
            };
            let post_clone = post.clone();

            async move {
                post_model.build(post_clone, &tx).await?;
                Ok::<_, TitoError>(post)
            }
        })
        .await?;

    let post3 = tito_db
        .transaction(|tx| {
            let post_model = post_model.clone();
            let post = Post {
                id: DBUuid::new_v4().to_string(),
                title: "Using Rust with TiKV".to_string(),
                content: "Here are some examples of using Rust with TiKV...".to_string(),
                author: "Alice".to_string(),
                tag_ids: vec![
                    tech_tag.id.clone(),
                    rust_tag.id.clone(),
                    database_tag.id.clone(),
                ],
                tags: Vec::new(),
            };
            let post_clone = post.clone();

            async move {
                post_model.build(post_clone, &tx).await?;
                Ok::<_, TitoError>(post)
            }
        })
        .await?;

    println!("\nCreated posts:");
    println!("1. {} (by {})", post1.title, post1.author);
    println!("2. {} (by {})", post2.title, post2.author);
    println!("3. {} (by {})", post3.title, post3.author);

    // Get a post with all its tags
    let post_with_tags = post_model
        .find_by_id(&post1.id, vec!["tags".to_string()])
        .await?;
    println!("\nPost with tags:");
    println!("Title: {}", post_with_tags.title);
    println!("Tags:");
    for tag in &post_with_tags.tags {
        println!("- {}", tag.name);
    }

    // Find posts by tag using the query builder
    let mut tech_query = post_model.query_by_index("post-by-tag");
    let tech_results = tech_query
        .value(tech_tag.id.clone())
        .relationship("tags")
        .execute()
        .await?;

    println!("\nTechnology posts:");
    for post in &tech_results.items {
        println!("- {} (by {})", post.title, post.author);
        println!(
            "  Tags: {}",
            post.tags
                .iter()
                .map(|t| t.name.clone())
                .collect::<Vec<_>>()
                .join(", ")
        );
    }

    // Find posts by author using the query builder
    let mut alice_query = post_model.query_by_index("post-by-author");
    let alice_results = alice_query
        .value("Alice".to_string())
        .relationship("tags")
        .execute()
        .await?;

    println!("\nAlice's posts:");
    for post in &alice_results.items {
        println!("- {}", post.title);
        println!(
            "  Tags: {}",
            post.tags
                .iter()
                .map(|t| t.name.clone())
                .collect::<Vec<_>>()
                .join(", ")
        );
    }

    Ok(())
}

pub async fn scan( &self, payload: TitoScanPayload, tx: &E::Transaction, ) -> Result<(Vec<(String, Value)>, bool), TitoError>

where T: DeserializeOwned,

pub async fn find_by_ids_tx( &self, ids: Vec<String>, rels: Vec<String>, tx: &E::Transaction, ) -> Result<Vec<T>, TitoError>

where T: DeserializeOwned,

pub async fn find_by_ids_raw( &self, ids: Vec<String>, rels: Vec<String>, tx: &E::Transaction, ) -> Result<Vec<(String, Value)>, TitoError>

where T: DeserializeOwned,

pub async fn find_by_ids( &self, ids: Vec<String>, rels: Vec<String>, ) -> Result<Vec<T>, TitoError>

where T: DeserializeOwned,

pub async fn scan_reverse( &self, payload: TitoScanPayload, tx: &E::Transaction, ) -> Result<(Vec<(String, Value)>, bool), TitoError>

where T: DeserializeOwned,

pub async fn update( &self, payload: T, tx: &E::Transaction, ) -> Result<bool, TitoError>

where T: DeserializeOwned,

Examples found in repository

examples/crud.rs (line 88)

async fn main() -> Result<(), TitoError> {
    // Connect to TiKV
    let tito_db = TiKV::connect(vec!["127.0.0.1:2379"]).await?;

    // Create model with dynamic backend
    let user_model = tito_db.clone().model::<User>();

    // Create a user
    let user_id = DBUuid::new_v4().to_string();
    let user = User {
        id: user_id.clone(),
        name: "John Doe".to_string(),
        email: "john@example.com".to_string(),
    };

    // Create user with transaction
    let saved_user = tito_db
        .transaction(|tx| {
            let user_model = user_model.clone();
            async move { user_model.build(user, &tx).await }
        })
        .await?;

    println!("Created user: {:?}", saved_user);

    // Find user (find_by_id already uses transaction internally)
    let found_user = user_model.find_by_id(&user_id, vec![]).await?;
    println!("Found user: {:?}", found_user);

    // Update user
    let updated_user = User {
        id: user_id.clone(),
        name: "John Updated".to_string(),
        email: "john_updated@example.com".to_string(),
    };

    tito_db
        .transaction(|tx| {
            let user_model = user_model.clone();
            async move { user_model.update(updated_user, &tx).await }
        })
        .await?;

    println!("User updated successfully");

    // Delete user
    tito_db
        .transaction(|tx| {
            let user_model = user_model.clone();
            async move { user_model.delete_by_id(&user_id, &tx).await }
        })
        .await?;

    println!("User deleted successfully");

    Ok(())
}

pub fn get_last_id(&self, key: String) -> Option<String>

pub async fn update_with_options( &self, payload: T, options: TitoOptions, tx: &E::Transaction, ) -> Result<bool, TitoError>

where T: DeserializeOwned,

pub async fn lock_keys( &self, keys: Vec<String>, tx: &E::Transaction, ) -> Result<bool, TitoError>

pub async fn batch_get( &self, keys: Vec<String>, max_retries: usize, initial_delay_ms: u64, tx: &E::Transaction, ) -> Result<Vec<(String, Value)>, TitoError>

pub async fn delete_by_id_with_options( &self, raw_id: &str, options: TitoOptions, tx: &E::Transaction, ) -> Result<bool, TitoError>

pub async fn delete_by_id( &self, raw_id: &str, tx: &E::Transaction, ) -> Result<bool, TitoError>

Examples found in repository

examples/crud.rs (line 98)

async fn main() -> Result<(), TitoError> {
    // Connect to TiKV
    let tito_db = TiKV::connect(vec!["127.0.0.1:2379"]).await?;

    // Create model with dynamic backend
    let user_model = tito_db.clone().model::<User>();

    // Create a user
    let user_id = DBUuid::new_v4().to_string();
    let user = User {
        id: user_id.clone(),
        name: "John Doe".to_string(),
        email: "john@example.com".to_string(),
    };

    // Create user with transaction
    let saved_user = tito_db
        .transaction(|tx| {
            let user_model = user_model.clone();
            async move { user_model.build(user, &tx).await }
        })
        .await?;

    println!("Created user: {:?}", saved_user);

    // Find user (find_by_id already uses transaction internally)
    let found_user = user_model.find_by_id(&user_id, vec![]).await?;
    println!("Found user: {:?}", found_user);

    // Update user
    let updated_user = User {
        id: user_id.clone(),
        name: "John Updated".to_string(),
        email: "john_updated@example.com".to_string(),
    };

    tito_db
        .transaction(|tx| {
            let user_model = user_model.clone();
            async move { user_model.update(updated_user, &tx).await }
        })
        .await?;

    println!("User updated successfully");

    // Delete user
    tito_db
        .transaction(|tx| {
            let user_model = user_model.clone();
            async move { user_model.delete_by_id(&user_id, &tx).await }
        })
        .await?;

    println!("User deleted successfully");

    Ok(())
}

pub async fn find( &self, payload: TitoFindPayload, ) -> Result<TitoPaginated<T>, TitoError>

where T: DeserializeOwned,

pub async fn add_field( &self, field_name: &str, field_value: Value, ) -> Result<(), TitoError>

pub async fn remove_field(&self, field_name: &str) -> Result<(), TitoError>

pub async fn find_all(&self) -> Result<TitoPaginated<T>, TitoError>

impl<E: TitoEngine, T: Default + Clone + Serialize + DeserializeOwned + Unpin + Send + Sync + TitoModelTrait> TitoModel<E, T>

pub fn get_index_keys( &self, id: String, value: &T, json: &Value, ) -> Result<Vec<(String, Value)>, TitoError>

pub async fn find_by_index_raw( &self, payload: TitoFindByIndexPayload, tx: &E::Transaction, ) -> Result<(Vec<(String, Value)>, bool), TitoError>

where T: DeserializeOwned,

pub async fn find_by_index_reverse_raw( &self, payload: TitoFindByIndexPayload, tx: &E::Transaction, ) -> Result<(Vec<(String, Value)>, bool), TitoError>

where T: DeserializeOwned,

pub async fn find_by_index_tx( &self, payload: TitoFindByIndexPayload, tx: &E::Transaction, ) -> Result<TitoPaginated<T>, TitoError>

where T: DeserializeOwned,

pub async fn find_by_index( &self, payload: TitoFindByIndexPayload, ) -> Result<TitoPaginated<T>, TitoError>

where T: DeserializeOwned,

pub async fn find_by_index_reverse_tx( &self, payload: TitoFindByIndexPayload, tx: &E::Transaction, ) -> Result<TitoPaginated<T>, TitoError>

where T: DeserializeOwned,

pub async fn find_by_index_reverse( &self, payload: TitoFindByIndexPayload, ) -> Result<TitoPaginated<T>, TitoError>

where T: DeserializeOwned,

pub async fn find_one_by_index_tx( &self, payload: TitoFindOneByIndexPayload, tx: &E::Transaction, ) -> Result<T, TitoError>

where T: DeserializeOwned,

pub async fn find_one_by_index( &self, payload: TitoFindOneByIndexPayload, ) -> Result<T, TitoError>

where T: DeserializeOwned,

pub async fn reindex(&self) -> Result<(), TitoError>

impl<E: TitoEngine, T: Default + Clone + Serialize + DeserializeOwned + Unpin + Send + Sync + TitoModelTrait> TitoModel<E, T>

pub fn stitch_relationship( &self, item: &mut Value, rel_map: &HashMap<String, Value>, config: &TitoEmbeddedRelationshipConfig, )

Public entry point for stitching a relationship into a JSON Value.

pub fn get_relationship_data( &self, items: &Vec<(String, Value)>, rels_config: &[TitoEmbeddedRelationshipConfig], rels: &Vec<String>, ) -> Vec<(TitoEmbeddedRelationshipConfig, String)>

Gathers all relationship keys that need to be fetched from a list of items.

pub async fn fetch_and_stitch_relationships( &self, items: Vec<(String, Value)>, rels: Vec<String>, tx: &E::Transaction, ) -> Result<Vec<(String, Value)>, TitoError>

Fetches and stitches all requested relationships for a vector of items.

pub fn extract_relationship(&self, input: &str) -> Option<String>

A helper function to extract a relationship string.

Trait Implementations

impl<E: Clone + TitoEngine, T: Clone> Clone for TitoModel<E, T>

fn clone(&self) -> TitoModel<E, T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.