[db] Openapi does not handle type alias DbKey correctly #929 (#930)

* remove DbKey type

* update docs

agdb/src/db.rs

@@ -38,7 +38,6 @@ use crate::storage::StorageIndex;
 use crate::utilities::serialize::Serialize;
 use crate::utilities::serialize::SerializeStatic;
 use crate::DbId;
-use crate::DbKey;
 use crate::DbKeyValue;
 use crate::DbValue;
 use crate::QueryError;
@@ -762,7 +761,7 @@ impl<Store: StorageData> DbImpl<Store> {
     pub(crate) fn values_by_keys(
         &self,
         db_id: DbId,
-        keys: &[DbKey],
+        keys: &[DbValue],
     ) -> Result<Vec<DbKeyValue>, DbError> {
         Ok(self
             .values
@@ -857,7 +856,7 @@ impl<Store: StorageData> DbImpl<Store> {
         Ok(())
     }
 
-    pub(crate) fn remove_keys(&mut self, db_id: DbId, keys: &[DbKey]) -> Result<i64, QueryError> {
+    pub(crate) fn remove_keys(&mut self, db_id: DbId, keys: &[DbValue]) -> Result<i64, QueryError> {
         let mut result = 0;
 
         for key_value in self.values.values(&self.storage, &db_id)? {
@@ -987,7 +986,7 @@ impl<Store: StorageData> DbImpl<Store> {
                     .values
                     .iter_key(&self.storage, &DbId(index.0))
                     .map(|(_, kv)| kv.key)
-                    .collect::<Vec<DbKey>>();
+                    .collect::<Vec<DbValue>>();
                 Ok(SearchControl::Continue(
                     values.iter().all(|k| keys.contains(k)),
                 ))

agdb/src/db/db_key.rs

@@ -1,18 +1,15 @@
 use crate::DbValue;
 
-/// Alias to [`DbValue`]
-pub type DbKey = DbValue;
-
 /// Ordering for search queries
 #[derive(Debug, Clone, PartialEq)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 #[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
 pub enum DbKeyOrder {
     /// Ascending order (from smallest)
-    Asc(DbKey),
+    Asc(DbValue),
 
     /// Descending order (from largest)
-    Desc(DbKey),
+    Desc(DbValue),
 }
 
 #[cfg(test)]
@@ -21,7 +18,7 @@ mod tests {
 
     #[test]
     fn derived_from_debug() {
-        format!("{:?}", DbKeyOrder::Asc(DbKey::default()));
+        format!("{:?}", DbKeyOrder::Asc(DbValue::default()));
     }
 
     #[test]
@@ -36,8 +33,8 @@ mod tests {
     #[test]
     fn derived_from_partial_eq() {
         assert_eq!(
-            DbKeyOrder::Asc(DbKey::default()),
-            DbKeyOrder::Asc(DbKey::default())
+            DbKeyOrder::Asc(DbValue::default()),
+            DbKeyOrder::Asc(DbValue::default())
         );
     }
 }

agdb/src/db/db_key_value.rs

@@ -5,7 +5,6 @@ use crate::storage::StorageIndex;
 use crate::utilities::serialize::Serialize;
 use crate::utilities::serialize::SerializeStatic;
 use crate::DbError;
-use crate::DbKey;
 use crate::DbValue;
 use crate::StorageData;
 
@@ -17,15 +16,15 @@ use crate::StorageData;
 #[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
 pub struct DbKeyValue {
     /// Key of the property
-    pub key: DbKey,
+    pub key: DbValue,
 
     /// Value of the property
     pub value: DbValue,
 }
 
 impl<K, T> From<(K, T)> for DbKeyValue
 where
-    K: Into<DbKey>,
+    K: Into<DbValue>,
     T: Into<DbValue>,
 {
     fn from(value: (K, T)) -> Self {
@@ -81,21 +80,21 @@ mod tests {
         format!(
             "{:?}",
             DbKeyValue {
-                key: DbKey::I64(0),
-                value: DbKey::I64(0)
+                key: DbValue::I64(0),
+                value: DbValue::I64(0)
             }
         );
     }
     #[test]
     fn derived_from_partial_eq() {
         assert_eq!(
             DbKeyValue {
-                key: DbKey::I64(0),
-                value: DbKey::I64(0)
+                key: DbValue::I64(0),
+                value: DbValue::I64(0)
             },
             DbKeyValue {
-                key: DbKey::I64(0),
-                value: DbKey::I64(0)
+                key: DbValue::I64(0),
+                value: DbValue::I64(0)
             }
         );
     }

agdb/src/db/db_user_value.rs

@@ -1,8 +1,8 @@
 use crate::DbElement;
 use crate::DbError;
 use crate::DbId;
-use crate::DbKey;
 use crate::DbKeyValue;
+use crate::DbValue;
 
 /// Trait that allows use of user defined values
 /// directly by facilitating translation from/to
@@ -40,7 +40,7 @@ pub trait DbUserValue: Sized {
 
     /// Returns the list of database keys of
     /// this type.
-    fn db_keys() -> Vec<DbKey>;
+    fn db_keys() -> Vec<DbValue>;
 
     /// Constructs the user value from the `element`
     /// extracting the values from element `values`

agdb/src/lib.rs

@@ -43,7 +43,6 @@ pub use db::db_element::DbElement;
 pub use db::db_error::DbError;
 pub use db::db_f64::DbF64;
 pub use db::db_id::DbId;
-pub use db::db_key::DbKey;
 pub use db::db_key::DbKeyOrder;
 pub use db::db_key_value::DbKeyValue;
 pub use db::db_user_value::DbUserValue;

agdb/src/query/query_condition.rs

@@ -1,5 +1,4 @@
 use crate::graph_search::SearchControl;
-use crate::DbKey;
 use crate::DbValue;
 use crate::QueryId;
 
@@ -70,14 +69,14 @@ pub enum QueryConditionData {
     /// with a value that evaluates true against `comparison`.
     KeyValue {
         /// Property key
-        key: DbKey,
+        key: DbValue,
 
         /// Comparison operator (e.g. Equal, GreaterThan etc.)
         value: Comparison,
     },
 
     /// Test if the current element has **all** of the keys listed.
-    Keys(Vec<DbKey>),
+    Keys(Vec<DbValue>),
 
     /// Is the current element a node? I.e. `0 < id`.
     Node,

agdb/src/query/query_values.rs

@@ -1,6 +1,6 @@
-use crate::DbKey;
 use crate::DbKeyValue;
 use crate::DbUserValue;
+use crate::DbValue;
 
 /// Helper type distinguishing uniform (`Single`) values
 /// and multiple (`Multi`) values in database queries.
@@ -29,7 +29,7 @@ pub struct MultiValues(pub Vec<Vec<DbKeyValue>>);
 /// Convenient wrapper for the [`QueryBuilder`] to
 /// allow properties conversions. Represents list
 /// of property keys.
-pub struct QueryKeys(pub Vec<DbKey>);
+pub struct QueryKeys(pub Vec<DbValue>);
 
 impl From<Vec<DbKeyValue>> for SingleValues {
     fn from(values: Vec<DbKeyValue>) -> Self {
@@ -43,8 +43,8 @@ impl From<Vec<Vec<DbKeyValue>>> for MultiValues {
     }
 }
 
-impl From<Vec<DbKey>> for QueryKeys {
-    fn from(value: Vec<DbKey>) -> Self {
+impl From<Vec<DbValue>> for QueryKeys {
+    fn from(value: Vec<DbValue>) -> Self {
         QueryKeys(value)
     }
 }

agdb/src/query/search_query.rs

@@ -2,7 +2,7 @@ use crate::db::db_key::DbKeyOrder;
 use crate::DbElement;
 use crate::DbId;
 use crate::DbImpl;
-use crate::DbKey;
+use crate::DbValue;
 use crate::Query;
 use crate::QueryCondition;
 use crate::QueryError;
@@ -136,7 +136,7 @@ impl SearchQuery {
             .map(|key_order| match key_order {
                 DbKeyOrder::Asc(key) | DbKeyOrder::Desc(key) => key.clone(),
             })
-            .collect::<Vec<DbKey>>();
+            .collect::<Vec<DbValue>>();
 
         ids.sort_by(|left, right| {
             let left_values = db.values_by_keys(*left, &keys).unwrap_or_default();

agdb/src/query/select_values_query.rs

@@ -1,6 +1,6 @@
 use crate::DbElement;
 use crate::DbImpl;
-use crate::DbKey;
+use crate::DbValue;
 use crate::Query;
 use crate::QueryError;
 use crate::QueryIds;
@@ -16,7 +16,7 @@ use crate::StorageData;
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 #[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
 pub struct SelectValuesQuery {
-    pub keys: Vec<DbKey>,
+    pub keys: Vec<DbValue>,
     pub ids: QueryIds,
 }
 

agdb/src/query_builder/where_.rs

@@ -6,7 +6,7 @@ use crate::query::query_condition::QueryConditionModifier;
 use crate::query::query_values::QueryKeys;
 use crate::query::search_query::SearchQuery;
 use crate::Comparison;
-use crate::DbKey;
+use crate::DbValue;
 use crate::QueryIds;
 
 /// Condition builder
@@ -19,7 +19,7 @@ pub struct Where {
 
 /// Condition builder for `key` condition.
 pub struct WhereKey {
-    key: DbKey,
+    key: DbValue,
     where_: Where,
 }
 
@@ -196,7 +196,7 @@ impl Where {
     /// // Includes only elements with property `String("k") == 1_i64`
     /// QueryBuilder::search().from(1).where_().key("k").value(Comparison::Equal(1.into())).query();
     /// ```
-    pub fn key<T: Into<DbKey>>(self, key: T) -> WhereKey {
+    pub fn key<T: Into<DbValue>>(self, key: T) -> WhereKey {
         WhereKey {
             key: key.into(),
             where_: self,

agdb/tests/db_test.rs

@@ -28,7 +28,6 @@ fn public_types() {
     use agdb::DbFileTransaction;
     use agdb::DbFileTransactionMut;
     use agdb::DbId;
-    use agdb::DbKey;
     use agdb::DbKeyOrder;
     use agdb::DbKeyValue;
     use agdb::DbTransaction;

agdb/tests/db_user_value_test.rs

@@ -3,7 +3,6 @@ mod test_db;
 use agdb::DbElement;
 use agdb::DbError;
 use agdb::DbId;
-use agdb::DbKey;
 use agdb::DbUserValue;
 use agdb::DbValue;
 use agdb::QueryBuilder;
@@ -85,7 +84,7 @@ fn db_user_value() {
         vec_string: vec!["world".to_string()],
         custom_enum: Status::Active,
     };
-    let keys: Vec<DbKey> = vec![
+    let keys: Vec<DbValue> = vec![
         "bytes".into(),
         "u64".into(),
         "u32".into(),

agdb_derive/src/lib.rs

@@ -91,7 +91,7 @@ pub fn db_user_value_derive(item: TokenStream) -> TokenStream {
                 #db_id
             }
 
-            fn db_keys() -> Vec<agdb::DbKey> {
+            fn db_keys() -> Vec<agdb::DbValue> {
                 vec![#(#db_keys.into()),*]
             }
 

docs/queries.md

@@ -68,7 +68,7 @@ The `DbUserValue` trait is an interface that can be implemented for user defined
 ```Rust
 pub trait DbUserValue: Sized {
     fn db_id(&self) -> Option<DbId>;
-    fn db_keys() -> Vec<DbKey>;
+    fn db_keys() -> Vec<DbValue>;
     fn from_db_element(element: &DbElement) -> Result<Self, DbError>;
     fn to_db_values(&self) -> Vec<DbKeyValue>;
 }
@@ -131,12 +131,12 @@ The values are `key-value` pairs (properties) associated with the given element:
 
 ```Rust
 pub struct DbKeyValue {
-    pub key: DbKey,
+    pub key: DbValue,
     pub value: DbValue,
 }
 ```
 
-The `DbKey` is an alias of `DbValue` and the value itself is an enum of valid types:
+Where `DbValue` is:
 
 ```Rust
 pub enum DbValue {
@@ -485,7 +485,7 @@ The result will contain:
 
 ```Rust
 pub struct SelectValuesQuery {
-    pub keys: Vec<DbKey>,
+    pub keys: Vec<DbValue>,
     pub ids: QueryIds,
 }
 ```
@@ -607,8 +607,8 @@ pub enum SearchQueryAlgorithm {
 }
 
 pub enum DbKeyOrder {
-    Asc(DbKey),
-    Desc(DbKey),
+    Asc(DbValue),
+    Desc(DbValue),
 }
 ```
 
@@ -691,8 +691,8 @@ pub enum QueryConditionData {
     EdgeCountFrom(CountComparison),
     EdgeCountTo(CountComparison),
     Ids(Vec<QueryId>),
-    KeyValue { key: DbKey, value: Comparison },
-    Keys(Vec<DbKey>),
+    KeyValue { key: DbValue, value: Comparison },
+    Keys(Vec<DbValue>),
     Node,
     Where(Vec<QueryCondition>),
 }