Struct SetBuilder 

pub struct SetBuilder<'a, E: TitoEngine, T: TitoModelConstraints> { /* private fields */ }

Implementations

impl<'a, E: TitoEngine, T: TitoModelConstraints> SetBuilder<'a, E, T>

pub fn timestamps(self, timestamps: bool) -> Self

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

Examples found in repository

examples/crud.rs (line 52)

async fn main() -> Result<(), TitoError> {
    let tito_db = TiKV::connect(vec!["127.0.0.1:2379"]).await?;
    let user_model = tito_db.clone().model::<User>(TitoModelOptions::default());

    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(),
    };

    let saved_user = tito_db
        .transaction(|tx| {
            let user_model = user_model.clone();
            async move { user_model.set(user).execute(&tx).await }
        })
        .await?;

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

    let found_user = user_model.get(&user_id).execute(None).await?;
    println!("Found user: {:?}", found_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.set(updated_user).execute(&tx).await }
        })
        .await?;

    println!("User updated");

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

    println!("User deleted");

    Ok(())
}

examples/blog.rs (line 104)

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

    let post_model = tito_db.clone().model::<Post>(TitoModelOptions::default());
    let tag_model = tito_db.clone().model::<Tag>(TitoModelOptions::default());

    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.set(tag_clone).execute(&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".to_string(),
            };
            let tag_clone = tag.clone();
            async move {
                tag_model.set(tag_clone).execute(&tx).await?;
                Ok::<_, TitoError>(tag)
            }
        })
        .await?;

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

    let post = 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: "Examples of using Rust with TiKV...".to_string(),
                author: "Alice".to_string(),
                tag_ids: vec![tech_tag.id.clone(), rust_tag.id.clone()],
                tags: Vec::new(),
            };
            let post_clone = post.clone();
            async move {
                post_model.set(post_clone).execute(&tx).await?;
                Ok::<_, TitoError>(post)
            }
        })
        .await?;

    println!("Created post: {}", post.title);

    let post_with_tags = post_model
        .get(&post.id)
        .relationship("tags")
        .execute(None)
        .await?;

    println!("Post: {}", post_with_tags.title);
    println!("Tags:");
    for tag in &post_with_tags.tags {
        println!("- {}", tag.name);
    }

    let mut query = post_model.query_by_index("post-by-author");
    let results = query
        .value("Alice".to_string())
        .relationship("tags")
        .execute(None)
        .await?;

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

    Ok(())
}