1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189
use crate::errors::{Error, Result}; use crate::models; use crate::models::{EdgeQueryExt, VertexQueryExt}; use serde_json::value::Value as JsonValue; use std::vec::Vec; use uuid::Uuid; /// Specifies a datastore implementation. /// /// # Errors /// All methods may return an error if something unexpected happens - e.g. /// if there was a problem connecting to the underlying database. pub trait Datastore { type Trans: Transaction; /// Syncs persisted content. Depending on the datastore implementation, /// this has different meanings - including potentially being a no-op. fn sync(&self) -> Result<()>; /// Creates a new transaction. fn transaction(&self) -> Result<Self::Trans>; /// Bulk inserts many vertices, edges, and/or properties. /// /// Note that datastores have discretion on how to approach safeguard vs /// performance tradeoffs. In particular: /// * If the datastore is disk-backed, it may or may not flush before /// returning. /// * The datastore might not verify for correctness; e.g., it might not /// ensure that the relevant vertices exist before inserting an edge. /// If you want maximum protection, use the equivalent functions in /// transactions, which will provide more safeguards. /// /// # Arguments /// * `items`: The items to insert. fn bulk_insert<I>(&self, items: I) -> Result<()> where I: Iterator<Item = models::BulkInsertItem>, { let trans = self.transaction()?; for item in items { match item { models::BulkInsertItem::Vertex(vertex) => { trans.create_vertex(&vertex)?; } models::BulkInsertItem::Edge(edge_key) => { trans.create_edge(&edge_key)?; } models::BulkInsertItem::VertexProperty(id, name, value) => { let query = models::SpecificVertexQuery::single(id).property(name); trans.set_vertex_properties(query, &value)?; } models::BulkInsertItem::EdgeProperty(edge_key, name, value) => { let query = models::SpecificEdgeQuery::single(edge_key).property(name); trans.set_edge_properties(query, &value)?; } } } Ok(()) } } /// Specifies a transaction implementation, which are provided by datastores. /// /// All datastore manipulations are done through transactions. Datastore /// implementations carry different guarantees. Depending on the /// implementation, it may not be possible to rollback the changes on error. /// See the documentation of individual implementations for details. pub trait Transaction { /// Creates a new vertex. Returns whether the vertex was successfully /// created - if this is false, it's because a vertex with the same UUID /// already exists. /// /// # Arguments /// * `vertex`: The vertex to create. fn create_vertex(&self, vertex: &models::Vertex) -> Result<bool>; /// Creates a new vertex with just a type specification. As opposed to /// `create_vertex`, this is used when you do not want to manually specify /// the vertex's UUID. Returns the new vertex's UUID. /// /// # Arguments /// * `t`: The type of the vertex to create. fn create_vertex_from_type(&self, t: models::Type) -> Result<Uuid> { let v = models::Vertex::new(t); if !self.create_vertex(&v)? { Err(Error::UuidTaken) } else { Ok(v.id) } } /// Gets a range of vertices specified by a query. /// /// # Arguments /// * `q`: The query to run. fn get_vertices<Q: Into<models::VertexQuery>>(&self, q: Q) -> Result<Vec<models::Vertex>>; /// Deletes existing vertices specified by a query. /// /// # Arguments /// * `q`: The query to run. fn delete_vertices<Q: Into<models::VertexQuery>>(&self, q: Q) -> Result<()>; /// Gets the number of vertices in the datastore. fn get_vertex_count(&self) -> Result<u64>; /// Creates a new edge. If the edge already exists, this will update it /// with a new update datetime. Returns whether the edge was successfully /// created - if this is false, it's because one of the specified vertices /// is missing. /// /// # Arguments /// * `key`: The edge to create. fn create_edge(&self, key: &models::EdgeKey) -> Result<bool>; /// Gets a range of edges specified by a query. /// /// # Arguments /// * `q`: The query to run. fn get_edges<Q: Into<models::EdgeQuery>>(&self, q: Q) -> Result<Vec<models::Edge>>; /// Deletes a set of edges specified by a query. /// /// # Arguments /// * `q`: The query to run. fn delete_edges<Q: Into<models::EdgeQuery>>(&self, q: Q) -> Result<()>; /// Gets the number of edges associated with a vertex. /// /// # Arguments /// * `id`: The id of the vertex. /// * `t`: Only get the count for a specified edge type. /// * `direction`: The direction of edges to get. fn get_edge_count(&self, id: Uuid, t: Option<&models::Type>, direction: models::EdgeDirection) -> Result<u64>; /// Gets vertex properties. /// /// # Arguments /// * `q`: The query to run. fn get_vertex_properties(&self, q: models::VertexPropertyQuery) -> Result<Vec<models::VertexProperty>>; /// Gets all vertex properties. /// /// # Arguments /// * `q`: The query to run. fn get_all_vertex_properties<Q: Into<models::VertexQuery>>(&self, q: Q) -> Result<Vec<models::VertexProperties>>; /// Sets a vertex properties. /// /// # Arguments /// * `q`: The query to run. /// * `value`: The property value. fn set_vertex_properties(&self, q: models::VertexPropertyQuery, value: &JsonValue) -> Result<()>; /// Deletes vertex properties. /// /// # Arguments /// * `q`: The query to run. fn delete_vertex_properties(&self, q: models::VertexPropertyQuery) -> Result<()>; /// Gets edge properties. /// /// # Arguments /// * `q`: The query to run. fn get_edge_properties(&self, q: models::EdgePropertyQuery) -> Result<Vec<models::EdgeProperty>>; /// Gets all edge properties. /// /// # Arguments /// * `q`: The query to run. fn get_all_edge_properties<Q: Into<models::EdgeQuery>>(&self, q: Q) -> Result<Vec<models::EdgeProperties>>; /// Sets edge properties. /// /// # Arguments /// * `q`: The query to run. /// * `value`: The property value. fn set_edge_properties(&self, q: models::EdgePropertyQuery, value: &JsonValue) -> Result<()>; /// Deletes edge properties. /// /// # Arguments /// * `q`: The query to run. fn delete_edge_properties(&self, q: models::EdgePropertyQuery) -> Result<()>; }