Struct ruarango::Connection

pub struct Connection { /* private fields */ }

An ArangoDB connection implementing the database operation traits

Trait Implementations

impl Clone for Connection

fn clone(&self) -> Connection

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Collection for Connection

fn collections<'life0, 'async_trait>(
    &'life0 self,
    exclude_system: bool
) -> Pin<Box<dyn Future<Output = ArangoResult<Response<Vec<Collections>>>> + Send + 'async_trait>>where
    Self: 'async_trait,
    'life0: 'async_trait,

Returns a vector of collection descriptions

fn collection<'life0, 'life1, 'async_trait>(
    &'life0 self,
    name: &'life1 str
) -> Pin<Box<dyn Future<Output = ArangoResult<Coll>> + Send + 'async_trait>>where
    Self: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,

Return information about a single collection

fn create<'life0, 'life1, 'async_trait>(
    &'life0 self,
    config: &'life1 Config
) -> Pin<Box<dyn Future<Output = ArangoResult<Create>> + Send + 'async_trait>>where
    Self: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,

Create a collection

fn drop<'life0, 'life1, 'async_trait>(
    &'life0 self,
    name: &'life1 str,
    is_system: bool
) -> Pin<Box<dyn Future<Output = ArangoResult<Drop>> + Send + 'async_trait>>where
    Self: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,

Drop a collection

fn checksum<'life0, 'life1, 'async_trait>(
    &'life0 self,
    name: &'life1 str,
    with_revisions: bool,
    with_data: bool
) -> Pin<Box<dyn Future<Output = ArangoResult<Checksum>> + Send + 'async_trait>>where
    Self: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,

Will calculate a checksum of the meta-data (keys and optionally revision ids and optionally the document data) in the collection.

fn count<'life0, 'life1, 'async_trait>(
    &'life0 self,
    name: &'life1 str
) -> Pin<Box<dyn Future<Output = ArangoResult<Count>> + Send + 'async_trait>>where
    Self: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,

The number of documents in the collection. Note - this will always load the collection into memory.

fn figures<'life0, 'life1, 'async_trait>(
    &'life0 self,
    name: &'life1 str
) -> Pin<Box<dyn Future<Output = ArangoResult<Figures>> + Send + 'async_trait>>where
    Self: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,

Some figures and additional statistical information about the collection.

fn revision<'life0, 'life1, 'async_trait>(
    &'life0 self,
    name: &'life1 str
) -> Pin<Box<dyn Future<Output = ArangoResult<Revision>> + Send + 'async_trait>>where
    Self: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,

Get the revision id for a collection The revision id is a server-generated string that clients can use to check whether data in a collection has changed since the last revision check.

fn load<'life0, 'life1, 'async_trait>(
    &'life0 self,
    name: &'life1 str,
    include_count: bool
) -> Pin<Box<dyn Future<Output = ArangoResult<Load>> + Send + 'async_trait>>where
    Self: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,

Loads a collection into memory.

fn load_indexes<'life0, 'life1, 'async_trait>(
    &'life0 self,
    name: &'life1 str
) -> Pin<Box<dyn Future<Output = ArangoResult<LoadIndexes>> + Send + 'async_trait>>where
    Self: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,

load_indexes tries to cache all index entries of this collection into memory.

fn modify_props<'life0, 'life1, 'async_trait>(
    &'life0 self,
    name: &'life1 str,
    props: Props
) -> Pin<Box<dyn Future<Output = ArangoResult<ModifyProps>> + Send + 'async_trait>>where
    Self: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,

Change the properties of a collection

fn recalculate_count<'life0, 'life1, 'async_trait>(
    &'life0 self,
    name: &'life1 str
) -> Pin<Box<dyn Future<Output = ArangoResult<RecalculateCount>> + Send + 'async_trait>>where
    Self: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,

Recalculates the document count of a collection, if it ever becomes inconsistent.

fn rename<'life0, 'life1, 'life2, 'async_trait>(
    &'life0 self,
    name: &'life1 str,
    new_name: &'life2 str
) -> Pin<Box<dyn Future<Output = ArangoResult<Rename>> + Send + 'async_trait>>where
    Self: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,
    'life2: 'async_trait,

Renames a collection

fn truncate<'life0, 'life1, 'async_trait>(
    &'life0 self,
    name: &'life1 str
) -> Pin<Box<dyn Future<Output = ArangoResult<Truncate>> + Send + 'async_trait>>where
    Self: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,

Removes all documents from the collection, but leaves the indexes intact.

fn unload<'life0, 'life1, 'async_trait>(
    &'life0 self,
    name: &'life1 str
) -> Pin<Box<dyn Future<Output = ArangoResult<Unload>> + Send + 'async_trait>>where
    Self: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,

Removes a collection from memory. This call does not delete any documents. You can use the collection afterwards, in which case it will be loaded into memory.

impl Cursor for Connection

fn create<'life0, 'async_trait, T>(
    &'life0 self,
    config: CreateConfig
) -> Pin<Box<dyn Future<Output = ArangoResult<CursorMeta<T>>> + Send + 'async_trait>>where
    T: Serialize + DeserializeOwned + Send + Sync + 'async_trait,
    Self: 'async_trait,
    'life0: 'async_trait,

Create a cursor

fn delete<'life0, 'async_trait>(
    &'life0 self,
    config: DeleteConfig
) -> Pin<Box<dyn Future<Output = ArangoResult<()>> + Send + 'async_trait>>where
    Self: 'async_trait,
    'life0: 'async_trait,

Delete a cursor

fn next<'life0, 'async_trait, T>(
    &'life0 self,
    config: NextConfig
) -> Pin<Box<dyn Future<Output = ArangoResult<CursorMeta<T>>> + Send + 'async_trait>>where
    T: Serialize + DeserializeOwned + Send + Sync + 'async_trait,
    Self: 'async_trait,
    'life0: 'async_trait,

Grab the next batch from an open cursor

impl Database for Connection

fn current<'life0, 'async_trait>(
    &'life0 self
) -> Pin<Box<dyn Future<Output = ArangoResult<Response<Current>>> + Send + 'async_trait>>where
    Self: 'async_trait,
    'life0: 'async_trait,

Retrieves the properties of the current database

fn user<'life0, 'async_trait>(
    &'life0 self
) -> Pin<Box<dyn Future<Output = ArangoResult<Response<Vec<String>>>> + Send + 'async_trait>>where
    Self: 'async_trait,
    'life0: 'async_trait,

Retrieves the list of all databases the current user can access without specifying a different username or password.

fn list<'life0, 'async_trait>(
    &'life0 self
) -> Pin<Box<dyn Future<Output = ArangoResult<Response<Vec<String>>>> + Send + 'async_trait>>where
    Self: 'async_trait,
    'life0: 'async_trait,

Retrieves the list of all existing databases Note: retrieving the list of databases is only possible from within the _system database. Note: You should use the GET user API to fetch the list of the available databases now.

fn create<'life0, 'life1, 'async_trait>(
    &'life0 self,
    create: &'life1 Create
) -> Pin<Box<dyn Future<Output = ArangoResult<Response<bool>>> + Send + 'async_trait>>where
    Self: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,

Creates a new database Note: creating a new database is only possible from within the _system database.

fn drop<'life0, 'life1, 'async_trait>(
    &'life0 self,
    name: &'life1 str
) -> Pin<Box<dyn Future<Output = ArangoResult<Response<bool>>> + Send + 'async_trait>>where
    Self: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,

Drops the database along with all data stored in it. Note: dropping a database is only possible from within the _system database. The _system database itself cannot be dropped.

impl Debug for Connection

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

Formats the value using the given formatter.

impl Document for Connection

fn create<'life0, 'async_trait, T, U, V>(
    &'life0 self,
    config: CreateConfig<T>
) -> Pin<Box<dyn Future<Output = DocMetaResult<U, V>> + Send + 'async_trait>>where
    T: Serialize + Send + Sync + 'async_trait,
    U: Serialize + DeserializeOwned + Send + Sync + 'async_trait,
    V: Serialize + DeserializeOwned + Send + Sync + 'async_trait,
    Self: 'async_trait,
    'life0: 'async_trait,

Create a document

fn creates<'life0, 'async_trait, T, U, V>(
    &'life0 self,
    config: CreatesConfig<T>
) -> Pin<Box<dyn Future<Output = DocMetaVecResult<U, V>> + Send + 'async_trait>>where
    T: Serialize + Send + Sync + 'async_trait,
    U: Serialize + DeserializeOwned + Send + Sync + 'async_trait,
    V: Serialize + DeserializeOwned + Send + Sync + 'async_trait,
    Self: 'async_trait,
    'life0: 'async_trait,

Create multiple documents

fn read<'life0, 'async_trait, T>(
    &'life0 self,
    config: ReadConfig
) -> Pin<Box<dyn Future<Output = ArangoResult<T>> + Send + 'async_trait>>where
    T: DeserializeOwned + Send + Sync + 'async_trait,
    Self: 'async_trait,
    'life0: 'async_trait,

Read a document

fn reads<'life0, 'async_trait, T, U>(
    &'life0 self,
    config: ReadsConfig<T>
) -> Pin<Box<dyn Future<Output = ArangoVecResult<U>> + Send + 'async_trait>>where
    T: Serialize + Send + Sync + 'async_trait,
    U: Serialize + DeserializeOwned + Send + Sync + 'async_trait,
    Self: 'async_trait,
    'life0: 'async_trait,

Read multiple documents

fn replace<'life0, 'async_trait, T, U, V>(
    &'life0 self,
    config: ReplaceConfig<T>
) -> Pin<Box<dyn Future<Output = DocMetaResult<U, V>> + Send + 'async_trait>>where
    T: Serialize + Send + Sync + 'async_trait,
    U: Serialize + DeserializeOwned + Send + Sync + 'async_trait,
    V: Serialize + DeserializeOwned + Send + Sync + 'async_trait,
    Self: 'async_trait,
    'life0: 'async_trait,

Replace a docment with the given document

fn replaces<'life0, 'async_trait, T, U, V>(
    &'life0 self,
    config: ReplacesConfig<T>
) -> Pin<Box<dyn Future<Output = DocMetaVecResult<U, V>> + Send + 'async_trait>>where
    T: Serialize + Send + Sync + 'async_trait,
    U: Serialize + DeserializeOwned + Send + Sync + 'async_trait,
    V: Serialize + DeserializeOwned + Send + Sync + 'async_trait,
    Self: 'async_trait,
    'life0: 'async_trait,

Replace multiple documents

fn update<'life0, 'async_trait, T, U, V>(
    &'life0 self,
    config: UpdateConfig<T>
) -> Pin<Box<dyn Future<Output = DocMetaResult<U, V>> + Send + 'async_trait>>where
    T: Serialize + Send + Sync + 'async_trait,
    U: Serialize + DeserializeOwned + Send + Sync + 'async_trait,
    V: Serialize + DeserializeOwned + Send + Sync + 'async_trait,
    Self: 'async_trait,
    'life0: 'async_trait,

Update the given data in the given document

fn updates<'life0, 'async_trait, T, U, V>(
    &'life0 self,
    config: UpdatesConfig<T>
) -> Pin<Box<dyn Future<Output = DocMetaVecResult<U, V>> + Send + 'async_trait>>where
    T: Serialize + Send + Sync + 'async_trait,
    U: Serialize + DeserializeOwned + Send + Sync + 'async_trait,
    V: Serialize + DeserializeOwned + Send + Sync + 'async_trait,
    Self: 'async_trait,
    'life0: 'async_trait,

Update the given data in the given documents

fn delete<'life0, 'async_trait, U, V>(
    &'life0 self,
    config: DeleteConfig
) -> Pin<Box<dyn Future<Output = DocMetaResult<U, V>> + Send + 'async_trait>>where
    U: Serialize + DeserializeOwned + Send + Sync + 'async_trait,
    V: Serialize + DeserializeOwned + Send + Sync + 'async_trait,
    Self: 'async_trait,
    'life0: 'async_trait,

Delete the given docment

fn deletes<'life0, 'async_trait, T, U, V>(
    &'life0 self,
    config: DeletesConfig<T>
) -> Pin<Box<dyn Future<Output = DocMetaVecResult<U, V>> + Send + 'async_trait>>where
    T: Serialize + Send + Sync + 'async_trait,
    U: Serialize + DeserializeOwned + Send + Sync + 'async_trait,
    V: Serialize + DeserializeOwned + Send + Sync + 'async_trait,
    Self: 'async_trait,
    'life0: 'async_trait,

Deletes the given docments

impl Graph for Connection

fn list<'life0, 'async_trait>(
    &'life0 self
) -> Pin<Box<dyn Future<Output = ArangoResult<List>> + Send + 'async_trait>>where
    Self: 'async_trait,
    'life0: 'async_trait,

List all graphs

fn create<'life0, 'async_trait>(
    &'life0 self,
    config: CreateConfig
) -> Pin<Box<dyn Future<Output = ArangoResult<GraphMeta>> + Send + 'async_trait>>where
    Self: 'async_trait,
    'life0: 'async_trait,

Create a graph

fn read<'life0, 'async_trait>(
    &'life0 self,
    config: ReadConfig
) -> Pin<Box<dyn Future<Output = ArangoResult<GraphMeta>> + Send + 'async_trait>>where
    Self: 'async_trait,
    'life0: 'async_trait,

Read a graph

fn delete<'life0, 'async_trait>(
    &'life0 self,
    config: DeleteConfig
) -> Pin<Box<dyn Future<Output = ArangoResult<()>> + Send + 'async_trait>>where
    Self: 'async_trait,
    'life0: 'async_trait,

Delete a graph

fn create_edge_def<'life0, 'async_trait>(
    &'life0 self,
    config: CreateEdgeDefConfig
) -> Pin<Box<dyn Future<Output = ArangoResult<GraphMeta>> + Send + 'async_trait>>where
    Self: 'async_trait,
    'life0: 'async_trait,

Create an edge definition

fn read_edge_defs<'life0, 'async_trait>(
    &'life0 self,
    config: ReadEdgeDefsConfig
) -> Pin<Box<dyn Future<Output = ArangoResult<EdgesMeta>> + Send + 'async_trait>>where
    Self: 'async_trait,
    'life0: 'async_trait,

Read the edge definitions for the given graph

fn delete_edge_def<'life0, 'async_trait>(
    &'life0 self,
    config: DeleteEdgeDefConfig
) -> Pin<Box<dyn Future<Output = ArangoResult<GraphMeta>> + Send + 'async_trait>>where
    Self: 'async_trait,
    'life0: 'async_trait,

Delete an edge definition

fn replace_edge_def<'life0, 'async_trait>(
    &'life0 self,
    config: ReplaceEdgeDefConfig
) -> Pin<Box<dyn Future<Output = ArangoResult<GraphMeta>> + Send + 'async_trait>>where
    Self: 'async_trait,
    'life0: 'async_trait,

Replace an edge definition

fn create_edge<'life0, 'async_trait>(
    &'life0 self,
    config: EdgeCreateConfig
) -> Pin<Box<dyn Future<Output = ArangoResult<CreateEdge>> + Send + 'async_trait>>where
    Self: 'async_trait,
    'life0: 'async_trait,

Create an edge for a graph

fn delete_edge<'life0, 'async_trait>(
    &'life0 self,
    config: EdgeDeleteConfig
) -> Pin<Box<dyn Future<Output = ArangoResult<DeleteEdge>> + Send + 'async_trait>>where
    Self: 'async_trait,
    'life0: 'async_trait,

Delete an edge from a graph

fn read_edge<'life0, 'async_trait>(
    &'life0 self,
    config: EdgeReadConfig
) -> Pin<Box<dyn Future<Output = ArangoResult<ReadEdge>> + Send + 'async_trait>>where
    Self: 'async_trait,
    'life0: 'async_trait,

Read an edge from a graph

fn update_edge<'life0, 'async_trait, T>(
    &'life0 self,
    config: EdgeUpdateConfig<T>
) -> Pin<Box<dyn Future<Output = ArangoResult<UpdateEdge>> + Send + 'async_trait>>where
    T: Serialize + Send + Sync + 'async_trait,
    Self: 'async_trait,
    'life0: 'async_trait,

Update an edge from a graph

fn replace_edge<'life0, 'async_trait, T>(
    &'life0 self,
    config: EdgeReplaceConfig<T>
) -> Pin<Box<dyn Future<Output = ArangoResult<ReplaceEdge>> + Send + 'async_trait>>where
    T: Serialize + Send + Sync + 'async_trait,
    Self: 'async_trait,
    'life0: 'async_trait,

Replace an edge from a graph

fn read_vertex_colls<'life0, 'async_trait>(
    &'life0 self,
    config: ReadVertexCollsConfig
) -> Pin<Box<dyn Future<Output = ArangoResult<VertexColls>> + Send + 'async_trait>>where
    Self: 'async_trait,
    'life0: 'async_trait,

Read the vertex collections from a graph

fn create_vertex_coll<'life0, 'async_trait>(
    &'life0 self,
    config: CreateVertexCollConfig
) -> Pin<Box<dyn Future<Output = ArangoResult<GraphMeta>> + Send + 'async_trait>>where
    Self: 'async_trait,
    'life0: 'async_trait,

Create vertex collection

fn delete_vertex_coll<'life0, 'async_trait>(
    &'life0 self,
    config: DeleteVertexCollConfig
) -> Pin<Box<dyn Future<Output = ArangoResult<GraphMeta>> + Send + 'async_trait>>where
    Self: 'async_trait,
    'life0: 'async_trait,

Delete vertex collection

fn create_vertex<'life0, 'async_trait, T>(
    &'life0 self,
    config: CreateVertexConfig<T>
) -> Pin<Box<dyn Future<Output = ArangoResult<VertexMeta>> + Send + 'async_trait>>where
    T: Serialize + Send + Sync + 'async_trait,
    Self: 'async_trait,
    'life0: 'async_trait,

Create vertex

fn delete_vertex<'life0, 'async_trait>(
    &'life0 self,
    config: DeleteVertexConfig
) -> Pin<Box<dyn Future<Output = ArangoResult<DeleteVertexMeta>> + Send + 'async_trait>>where
    Self: 'async_trait,
    'life0: 'async_trait,

Delete a vertex

fn read_vertex<'life0, 'async_trait>(
    &'life0 self,
    config: ReadVertexConfig
) -> Pin<Box<dyn Future<Output = ArangoResult<ReadVertexMeta>> + Send + 'async_trait>>where
    Self: 'async_trait,
    'life0: 'async_trait,

Read a vertex

fn update_vertex<'life0, 'async_trait, T>(
    &'life0 self,
    config: UpdateVertexConfig<T>
) -> Pin<Box<dyn Future<Output = ArangoResult<UpdateVertexMeta>> + Send + 'async_trait>>where
    T: Serialize + Send + Sync + 'async_trait,
    Self: 'async_trait,
    'life0: 'async_trait,

Update vertex

fn replace_vertex<'life0, 'async_trait, T>(
    &'life0 self,
    config: UpdateVertexConfig<T>
) -> Pin<Box<dyn Future<Output = ArangoResult<UpdateVertexMeta>> + Send + 'async_trait>>where
    T: Serialize + Send + Sync + 'async_trait,
    Self: 'async_trait,
    'life0: 'async_trait,

Replace vertex

impl Job for Connection

fn status<'life0, 'life1, 'async_trait>(
    &'life0 self,
    id: &'life1 str
) -> Pin<Box<dyn Future<Output = Result<u16>> + Send + 'async_trait>>where
    Self: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,

Returns the processing status of the specified job. The processing status can be determined by checking the HTTP response code.

fn fetch<'life0, 'life1, 'async_trait, T>(
    &'life0 self,
    id: &'life1 str
) -> Pin<Box<dyn Future<Output = Result<T>> + Send + 'async_trait>>where
    T: Serialize + DeserializeOwned + Send + Sync + 'async_trait,
    Self: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,

Docs

fn fetch_doc_job<'life0, 'life1, 'async_trait, T>(
    &'life0 self,
    id: &'life1 str
) -> Pin<Box<dyn Future<Output = Result<T>> + Send + 'async_trait>>where
    T: Serialize + DeserializeOwned + Send + Sync + 'async_trait,
    Self: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,

Docs

fn jobs<'life0, 'life1, 'async_trait>(
    &'life0 self,
    _kind: &'life1 str
) -> Pin<Box<dyn Future<Output = Result<Vec<String>>> + Send + 'async_trait>>where
    Self: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,

Docs