Struct TitoModel 

pub struct TitoModel<E: TitoEngine, T> {
    pub engine: E,
    pub partition_count: u32,
    /* private fields */
}

Fields

engine: E

partition_count: u32

Implementations

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

pub fn new(engine: E, options: TitoModelOptions) -> Self

pub fn relationships(&self) -> Vec<TitoRelationshipConfig>

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 161)

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

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

where F: FnOnce(E::Transaction) -> Fut + Clone + 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<FieldValue>>

pub fn set(&self, payload: T) -> SetBuilder<'_, E, T>

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

pub fn get(&self, id: &str) -> GetBuilder<'_, E, T>

Examples found in repository

examples/crud.rs (line 58)

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 150)

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

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

where T: DeserializeOwned,

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

where T: DeserializeOwned,

pub fn get_many(&self, ids: Vec<String>) -> GetManyBuilder<'_, E, T>

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

where T: DeserializeOwned,

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

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

pub async fn remove_by_index( &self, index: &str, value: &str, batch_size: u32, tx: &E::Transaction, ) -> Result<Vec<String>, TitoError>

where T: DeserializeOwned,

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

Examples found in repository

examples/crud.rs (line 79)

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

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

where T: DeserializeOwned,

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( &self, payload: TitoFindByIndexPayload, tx: Option<&E::Transaction>, ) -> Result<TitoPaginated<T>, TitoError>

where T: DeserializeOwned,

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

where T: DeserializeOwned,

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

where T: DeserializeOwned,

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: &TitoRelationshipConfig, )

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

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

pub fn extract_relationship(&self, input: &str) -> Option<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.