Struct aragog::DatabaseRecord

pub struct DatabaseRecord<T: Serialize + DeserializeOwned + Clone + Record> {
    pub key: String,
    pub id: String,
    pub rev: String,
    pub record: T,
}

Struct representing database stored documents

The document of type T mut implement Serialize, DeserializeOwned, Clone and Record

Fields

key: String

The Document unique and indexed _key

id: String

The Document unique and indexed _id

rev: String

The Document revision _rev

record: T

The deserialized stored document

Implementations

impl<T: Serialize + DeserializeOwned + Clone + Record> DatabaseRecord<T>

pub async fn save<'_, '_>(
    &'_ mut self,
    db_pool: &'_ DatabaseConnectionPool
) -> Result<(), ServiceError> where
    T: Validate, 

Writes in the database the new state of the record, "saving it". The record will first be validates as it should implement the Validate trait.

Arguments:

• db_pool - database connection pool reference

Returns

On success () is returned, meaning that the current instance is up to date with the database state. On failure a ServiceError is returned:

• Conflict on index uniqueness conflict
• UnprocessableEntity on data corruption
• ValidationError on failed field validations

pub async fn delete<'_, '_>(
    &'_ self,
    db_pool: &'_ DatabaseConnectionPool
) -> Result<(), ServiceError>

Removes the record from the database. The structure won't be freed or emptied but the document won't exist in the global state

Arguments:

• db_pool - database connection pool reference

Returns

On success () is returned, meaning that the record is now deleted, the structure should not be used afterwards. On failure a ServiceError is returned:

• NotFound on invalid document key
• UnprocessableEntity on data corruption

pub async fn find<'_, '_>(
    key: &'_ str,
    db_pool: &'_ DatabaseConnectionPool
) -> Result<Self, ServiceError>

Retrieves a record from the database with the associated unique key

Arguments:

• key - the unique record key as a string slice
• db_pool - database connection pool reference

Returns

On success Self is returned, On failure a ServiceError is returned:

• NotFound on invalid document key
• UnprocessableEntity on data corruption

pub async fn get<'_>(
    query: Query,
    db_pool: &'_ DatabaseConnectionPool
) -> Result<RecordQueryResult<T>, ServiceError>

Retrieves all records from the database matching the associated conditions.

Arguments:

• query - The Query to match
• db_pool - database connection pool reference

Note

This is simply an AQL request wrapper.

Returns

On success a QueryResult with a vector of Self is returned. It is can be empty. On failure a ServiceError is returned:

• NotFound if no document matches the condition
• UnprocessableEntity on data corruption

Example

use aragog::query::{Query, Comparison};

let mut query = Query::new().filter(Filter::new(Comparison::field("username").equals_str("MichelDu93"))
    .and(Comparison::field("age").greater_than(10));

User::get(query, &db_pool).await.unwrap();

pub async fn aql_get<'_, '_>(
    query: &'_ str,
    db_pool: &'_ DatabaseConnectionPool
) -> Result<RecordQueryResult<T>, ServiceError>

Retrieves all records from the database matching the associated conditions.

Arguments:

• query - The AQL request string
• db_pool - database connection pool reference

Returns

On success a QueryResult with a vector of Self is returned. It is can be empty. On failure a ServiceError is returned:

• NotFound if no document matches the condition
• UnprocessableEntity on data corruption

Warning

If you call this method on a graph query only the documents that can be serialized into T will be returned.

Example

use aragog::query::{Query, Comparison};

let mut query = r#"FOR i in User FILTER i.username == "MichelDu93" && i.age > 10 return i"#;

User::aql_get(query, &db_pool).await.unwrap();

pub fn outbound_query(&self, min: u16, max: u16, edge_collection: &str) -> Query

Creates a new outbound graph Query with self as a start vertex

Arguments

• edge_collection- The name of the queried edge collection
• min - The minimum depth of the graph request
• max - The maximum depth of the graph request

Example

let record = User::find("123", &database_pool).await.unwrap();
// Both statements are equivalent
let q = record.outbound_query(1, 2, "ChildOf");
let q = Query::outbound(1, 2, "ChildOf", record.id);

pub fn inbound_query(&self, min: u16, max: u16, edge_collection: &str) -> Query

Creates a new inbound graph Query with self as a start vertex

Arguments

• edge_collection- The name of the queried edge collection
• min - The minimum depth of the graph request
• max - The maximum depth of the graph request

Example

let record = User::find("123", &database_pool).await.unwrap();
// Both statements are equivalent
let q = record.inbound_query(1, 2, "ChildOf");
let q = Query::inbound(1, 2, "ChildOf", record.id);

pub fn outbound_graph(&self, min: u16, max: u16, named_graph: &str) -> Query

Creates a new outbound graph Query with self as a start vertex

Arguments

• min - The minimum depth of the graph request
• max - The maximum depth of the graph request
• named_graph- The named graph to traverse

Example

let record = User::find("123", &database_pool).await.unwrap();
// Both statements are equivalent
let q = record.outbound_graph(1, 2, "SomeGraph");
let q = Query::outbound_graph(1, 2, "SomeGraph", record.id);

pub fn inbound_graph(&self, min: u16, max: u16, named_graph: &str) -> Query

Creates a new inbound graph Query with self as a start vertex

Arguments

• min - The minimum depth of the graph request
• max - The maximum depth of the graph request
• named_graph- The named graph to traverse

Example

let record = User::find("123", &database_pool).await.unwrap();
// Both statements are equivalent
let q = record.inbound_graph(1, 2, "SomeGraph");
let q = Query::inbound_graph(1, 2, "SomeGraph", record.id);

pub async fn link<U, V, W, '_, '_, '_>(
    from_record: &'_ DatabaseRecord<U>,
    to_record: &'_ DatabaseRecord<V>,
    db_pool: &'_ DatabaseConnectionPool,
    document: W
) -> Result<DatabaseRecord<T>, ServiceError> where
    U: Serialize + DeserializeOwned + Clone + Record,
    V: Serialize + DeserializeOwned + Clone + Record,
    T: EdgeRecord,
    W: FnOnce(String, String) -> T, 

Creates and returns edge between from_record and target_record

Example

#[derive(Clone, EdgeRecord, Validate, Serialize, Deserialize)]
struct Edge {
    _from: String,
    _to: String,
    description: String,
}

let record_a = Character::find("123", &database_connection_pool).await.unwrap();
let record_b = Character::find("234", &database_connection_pool).await.unwrap();

let edge = DatabaseRecord::link(&record_a, &record_b, &database_connection_pool, |_from, _to| {
    Edge { _from, _to, description: "description".to_string() }
}).await.unwrap();

pub async fn exists<'_>(
    query: Query,
    db_pool: &'_ DatabaseConnectionPool
) -> bool

Checks if any document matching the associated conditions exist

Arguments:

• query - The Query to match
• db_pool - database connection pool reference

Note

This is simply an AQL request wrapper.

Returns

On success true is returned, false if nothing exists.

Example

use aragog::query::{Query, Comparison};

let mut query = Query::new().filter(Filter::new(Comparison::field("username").equals_str("MichelDu93"))
    .and(Comparison::field("age").greater_than(10));

User::exists(query, &db_pool).await;

pub async fn create<'_>(
    record: T,
    db_pool: &'_ DatabaseConnectionPool
) -> Result<Self, ServiceError> where
    T: Validate, 

Creates a document in database The function will write a new document and return a database record containing the newly created key

Arguments

• record - The document to create, it will be returned exactly as the DatabaseRecord<T> record
• db_pool - database connection pool reference

Returns

On success a new instance of Self is returned, with the key value filled and record filled with the argument value On failure a ServiceError is returned:

• UnprocessableEntity on data corruption

pub fn from_response(
    doc_response: DocumentResponse<T>
) -> Result<Self, ServiceError>

Builds a DatabaseRecord from a arangors crate DocumentResponse<T> It will return the filled DatabaseRecord on success or will return a ServiceError::UnprocessableEntity on failure

pub fn authenticate(&self, password: &str) -> Result<(), ServiceError> where
    T: Authenticate, 

Authenticates the instance. The method is available if T implements Authenticate and will simply call the authenticate method on the record

Arguments

• password - the value supposed to validate authentication, password or secret

Returns

On success () is returned, on failure it will return a ServiceError according to the Authenticate implementation

pub fn get_id(&self) -> String

Retrieves the ArangoDB _id built as `$collection_name/$_key

Trait Implementations

impl<T: Debug + Serialize + DeserializeOwned + Clone + Record> Debug for DatabaseRecord<T>

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

Formats the value using the given formatter.

impl<T: Serialize + DeserializeOwned + Clone + Record> From<Document<T>> for DatabaseRecord<T>

pub fn from(doc: Document<T>) -> Self

Performs the conversion.