Struct g1_sqlite_connection::SqliteConnection

pub struct SqliteConnection { /* fields omitted */ }

A G1 connection based on an SQLite database, using the FS for blobs.

TODO: Make this not use g1_common::naive_solve...

Methods

impl SqliteConnection

pub async fn open(path: PathBuf) -> Result<SqliteConnection, SqliteError>

Opens a connection to the database, given a directory to store the database and blobs in.

Trait Implementations

impl Debug for SqliteConnection

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

Formats the value using the given formatter.

impl Connection for SqliteConnection

type Error = SqliteError

The error returned by operations on this connection.

fn create_atom<'life0, 'async_trait>(
    &'life0 self
) -> Pin<Box<dyn Future<Output = Result<Atom, Self::Error>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

Creates a new atom in the database, returning it.

fn delete_atom<'life0, 'async_trait>(
    &'life0 self,
    atom: Atom
) -> Pin<Box<dyn Future<Output = Result<(), Self::Error>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

Deletes any names referring to an atom, all edges going to or from it, any tags attached to it, and any blobs attached to it.

fn create_name<'life0, 'life1, 'life2, 'async_trait>(
    &'life0 self,
    atom: Atom,
    ns: &'life1 str,
    title: &'life2 str,
    upsert: bool
) -> Pin<Box<dyn Future<Output = Result<(), Self::Error>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    'life2: 'async_trait,
    Self: 'async_trait, 

Creates a new name for an atom.

fn delete_name<'life0, 'life1, 'life2, 'async_trait>(
    &'life0 self,
    ns: &'life1 str,
    title: &'life2 str
) -> Pin<Box<dyn Future<Output = Result<bool, Self::Error>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    'life2: 'async_trait,
    Self: 'async_trait, 

Deletes a name.

fn create_edge<'life0, 'life1, 'async_trait>(
    &'life0 self,
    from: Atom,
    to: Atom,
    label: &'life1 str
) -> Pin<Box<dyn Future<Output = Result<bool, Self::Error>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait, 

Creates a new edge between two atoms.

fn delete_edge<'life0, 'life1, 'async_trait>(
    &'life0 self,
    from: Atom,
    to: Atom,
    label: &'life1 str
) -> Pin<Box<dyn Future<Output = Result<bool, Self::Error>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait, 

Deletes the edge with the given endpoints and label.

fn create_tag<'life0, 'life1, 'life2, 'async_trait>(
    &'life0 self,
    atom: Atom,
    key: &'life1 str,
    value: &'life2 str,
    upsert: bool
) -> Pin<Box<dyn Future<Output = Result<(), Self::Error>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    'life2: 'async_trait,
    Self: 'async_trait, 

Creates a tag attached to an atom with the given key and value.

fn delete_tag<'life0, 'life1, 'async_trait>(
    &'life0 self,
    atom: Atom,
    key: &'life1 str
) -> Pin<Box<dyn Future<Output = Result<bool, Self::Error>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait, 

Deletes the tag with the given key from the given atom.

fn create_blob<'life0, 'life1, 'async_trait>(
    &'life0 self,
    atom: Atom,
    kind: &'life1 str,
    mime: Mime,
    hash: Hash,
    upsert: bool
) -> Pin<Box<dyn Future<Output = Result<(), Self::Error>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait, 

Creates a blob attached to an atom with the given kind, MIME type, and hash.

fn delete_blob<'life0, 'life1, 'async_trait>(
    &'life0 self,
    atom: Atom,
    kind: &'life1 str,
    mime: Mime
) -> Pin<Box<dyn Future<Output = Result<bool, Self::Error>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait, 

Deletes the blob with the given kind and MIME type from the given atom.

fn fetch_blob<'life0, 'async_trait>(
    &'life0 self,
    hash: Hash
) -> Pin<Box<dyn Future<Output = Result<Pin<Box<dyn Stream<Item = Result<Bytes, Self::Error>> + Send>>, Self::Error>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

Fetches a blob from the server by its hash.

fn store_blob<'life0, 'async_trait>(
    &'life0 self,
    data: Pin<Box<dyn Stream<Item = Result<Bytes, Self::Error>> + Send + 'static>>
) -> Pin<Box<dyn Future<Output = Result<Hash, Self::Error>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

Stores a blob on the server, returning its hash.

fn query<'life0, 'life1, 'async_trait>(
    &'life0 self,
    limit: Option<usize>,
    query: &'life1 NamelessQuery
) -> Pin<Box<dyn Future<Output = Result<Vec<Vec<Arc<str>>>, Self::Error>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait, 

Performs a query, returning multiple results (at most limit).

fn query_all<'life0, 'life1, 'async_trait>(
    &'life0 self,
    query: &'life1 NamelessQuery
) -> Pin<Box<dyn Future<Output = Result<Vec<Vec<Arc<str>>>, Self::Error>> + 'async_trait + Send>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait, 

Performs a query, returning all results.

fn query_first<'life0, 'life1, 'async_trait>(
    &'life0 self,
    query: &'life1 NamelessQuery
) -> Pin<Box<dyn Future<Output = Result<Option<Vec<Arc<str>>>, Self::Error>> + 'async_trait + Send>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait, 

Performs a query, returning at most one result.

fn query_has_results<'life0, 'life1, 'async_trait>(
    &'life0 self,
    query: &'life1 NamelessQuery
) -> Pin<Box<dyn Future<Output = Result<bool, Self::Error>> + 'async_trait + Send>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait, 

Performs a query, returning whether it had results.