Struct aragog::DatabaseRecord

pub struct DatabaseRecord<T: Record> {
    pub record: T,
    // some fields omitted
}

Struct representing database stored documents.

The document of type T mut implement Record

Note

DatabaseRecord implements Deref and DerefMut into T

Fields

record: T

The deserialized stored document

Implementations

impl<T: Record> DatabaseRecord<T>

pub async fn create<D>(record: T, db_accessor: &D) -> Result<Self, ServiceError> where
    D: DatabaseAccess, 

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

Hooks

This function will launch T hooks before_create and after_create.

Arguments

• record - The document to create, it will be returned exactly as the DatabaseRecord<T> record
• db_accessor - 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
• Any error returned by hooks

pub async fn force_create<D>(
    record: T,
    db_accessor: &D
) -> Result<Self, ServiceError> where
    D: DatabaseAccess, 

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

Hooks

This function will skip all hooks.

Arguments

• record - The document to create, it will be returned exactly as the DatabaseRecord<T> record
• db_accessor - 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 async fn save<D>(&mut self, db_accessor: &D) -> Result<(), ServiceError> where
    D: DatabaseAccess, 

Writes in the database the new state of the record, "saving it".

Hooks

This function will launch T hooks before_save and after_save.

Arguments:

• db_accessor - 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
• Any error returned by hooks

pub async fn force_save<D>(
    &mut self,
    db_accessor: &D
) -> Result<(), ServiceError> where
    D: DatabaseAccess, 

Writes in the database the new state of the record, skipping hooks.

Hooks

This function will skip all hooks.

Arguments:

• db_accessor - 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

pub async fn delete<D>(&mut self, db_accessor: &D) -> Result<(), ServiceError> where
    D: DatabaseAccess, 

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

Hooks

This function will launch T hooks before_delete and after_delete.

Arguments:

• db_accessor - 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
• Any error returned by hooks

pub async fn force_delete<D>(&self, db_accessor: &D) -> Result<(), ServiceError> where
    D: DatabaseAccess, 

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

Hooks

This function will skip all hooks.

Arguments:

• db_accessor - 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 link<A, B, D, E>(
    from_record: &DatabaseRecord<A>,
    to_record: &DatabaseRecord<B>,
    db_accessor: &D,
    edge_record: E
) -> Result<DatabaseRecord<T>, ServiceError> where
    A: Serialize + DeserializeOwned + Clone + Record,
    B: Serialize + DeserializeOwned + Clone + Record,
    D: DatabaseAccess,
    E: FnOnce(String, String) -> T,
    T: EdgeRecord, 

Creates and returns edge between from_record and target_record.

Hooks

This function will launch T hooks before_create and after_create.

Example

#[derive(Clone, EdgeRecord, Record, Serialize, Deserialize)]
struct Edge {
    _from: String,
    _to: String,
    description: String,
}
let record_a = User::find("123", &db_accessor).await.unwrap();
let record_b = User::find("234", &db_accessor).await.unwrap();

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

pub async fn find<D>(key: &str, db_accessor: &D) -> Result<Self, ServiceError> where
    D: DatabaseAccess, 

Retrieves a record from the database with the associated unique key

Arguments:

• key - the unique record key as a string slice
• db_accessor - 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 reload<D>(self, db_accessor: &D) -> Result<Self, ServiceError> where
    D: DatabaseAccess,
    T: Send, 

Reloads a record from the database, returning the new record.

Arguments

• db_accessor - 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 reload_mut<D>(
    &mut self,
    db_accessor: &D
) -> Result<(), ServiceError> where
    D: DatabaseAccess,
    T: Send, 

Reloads a record from the database.

Returns

On success () is returned and self is updated, On failure a ServiceError is returned:

• NotFound on invalid document key
• UnprocessableEntity on data corruption

pub async fn get<D>(
    query: Query,
    db_accessor: &D
) -> Result<RecordQueryResult<T>, ServiceError> where
    D: DatabaseAccess, 

Retrieves all records from the database matching the associated conditions.

Arguments:

• query - The Query to match
• db_accessor - 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

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

// Both lines are equivalent:
DatabaseRecord::<User>::get(query.clone(), &db_accessor).await.unwrap();
User::get(query.clone(), &db_accessor).await.unwrap();

pub async fn aql_get<D>(
    query: &str,
    db_accessor: &D
) -> Result<RecordQueryResult<T>, ServiceError> where
    D: DatabaseAccess, 

Retrieves all records from the database matching the associated conditions.

Arguments:

• query - The AQL request string
• db_accessor - 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

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

DatabaseRecord::<User>::aql_get(query, &db_accessor).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", &db_accessor).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", &db_accessor).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", &db_accessor).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", &db_accessor).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 exists<D>(query: Query, db_accessor: &D) -> bool where
    D: DatabaseAccess, 

Checks if any document matching the associated conditions exist

Arguments:

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

Note

This is simply an AQL request wrapper.

Returns

On success true is returned, false if nothing exists.

Example

let query = User::query().filter(
    Filter::new(Comparison::field("username").equals_str("MichelDu93"))
        .and(Comparison::field("age").greater_than(10)));
User::exists(query, &db_accessor).await;

pub fn id(&self) -> &String

Getter for the Document _id built as `$collection_name/$_key

pub fn key(&self) -> &String

Getter for the Document _key

pub fn rev(&self) -> &String

Getter for the Document _rev

Trait Implementations

impl<T: Clone + Record> Clone for DatabaseRecord<T>

fn clone(&self) -> DatabaseRecord<T>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Debug + Record> Debug for DatabaseRecord<T>

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

Formats the value using the given formatter.

impl<T: Record> Deref for DatabaseRecord<T>

type Target = T

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<T: Record> DerefMut for DatabaseRecord<T>

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

Mutably dereferences the value.

impl<T: Record> Display for DatabaseRecord<T>

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

Formats the value using the given formatter.

impl<T: Record> From<Document<T>> for DatabaseRecord<T>

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

Performs the conversion.