store: Abstract execute_query over FromEntityData

Author: leoyvens

store/postgres/src/entities.rs

@@ -452,15 +452,15 @@ impl Connection<'_> {
         }
     }
 
-    pub(crate) fn query(
+    pub(crate) fn query<T: crate::relational_queries::FromEntityData>(
         &self,
         logger: &Logger,
         collection: EntityCollection,
         filter: Option<EntityFilter>,
         order: EntityOrder,
         range: EntityRange,
         block: BlockNumber,
-    ) -> Result<Vec<Entity>, QueryExecutionError> {
+    ) -> Result<Vec<T>, QueryExecutionError> {
         match &*self.storage {
             Storage::Json(json) => {
                 // JSON storage can only query at the latest block
@@ -983,14 +983,14 @@ impl JsonStorage {
     }
 
     /// order is a tuple (attribute, value_type, direction)
-    fn query(
+    fn query<T: From<Entity>>(
         &self,
         conn: &PgConnection,
         collection: EntityCollection,
         filter: Option<EntityFilter>,
         order: Option<(String, ValueType, &'static str)>,
         range: EntityRange,
-    ) -> Result<Vec<Entity>, QueryExecutionError> {
+    ) -> Result<Vec<T>, QueryExecutionError> {
         let query = FilterQuery::new(&self.table, collection, filter, order, range)?;
 
         let query_debug_info = debug_query(&query).to_string();
@@ -1006,7 +1006,9 @@ impl JsonStorage {
         values
             .into_iter()
             .map(|(_, value, entity_type)| {
-                entity_from_json(value, &entity_type).map_err(QueryExecutionError::from)
+                entity_from_json(value, &entity_type)
+                    .map(T::from)
+                    .map_err(QueryExecutionError::from)
             })
             .collect()
     }

store/postgres/src/relational.rs

@@ -564,7 +564,7 @@ impl Layout {
     }
 
     /// order is a tuple (attribute, value_type, direction)
-    pub fn query(
+    pub fn query<T: crate::relational_queries::FromEntityData>(
         &self,
         logger: &Logger,
         conn: &PgConnection,
@@ -573,7 +573,7 @@ impl Layout {
         order: EntityOrder,
         range: EntityRange,
         block: BlockNumber,
-    ) -> Result<Vec<Entity>, QueryExecutionError> {
+    ) -> Result<Vec<T>, QueryExecutionError> {
         fn log_query_timing(
             logger: &Logger,
             query: &FilterQuery,

store/postgres/src/relational_queries.rs

@@ -171,7 +171,7 @@ impl ForeignKeyClauses for Column {
     }
 }
 
-pub trait FromEntityData: Default {
+pub trait FromEntityData: Default + From<Entity> {
     type Value: FromColumnValue;
 
     fn insert_entity_data(&mut self, key: String, v: Self::Value);

store/postgres/src/store.rs

@@ -41,6 +41,7 @@ use crate::entities as e;
 use crate::functions::{attempt_chain_head_update, lookup_ancestor_block};
 use crate::history_event::HistoryEvent;
 use crate::metadata;
+use crate::relational_queries::FromEntityData;
 use crate::store_events::SubscriptionManager;
 
 // TODO: Integrate with https://github.com/graphprotocol/graph-node/pull/1522/files
@@ -314,11 +315,11 @@ impl Store {
         })
     }
 
-    fn execute_query(
+    fn execute_query<T: FromEntityData>(
         &self,
         conn: &e::Connection,
         query: EntityQuery,
-    ) -> Result<Vec<Entity>, QueryExecutionError> {
+    ) -> Result<Vec<T>, QueryExecutionError> {
         // Process results; deserialize JSON data
         let logger = query.logger.unwrap_or(self.logger.clone());
         conn.query(
@@ -464,7 +465,7 @@ impl Store {
                 entity_ids: mut expected_entity_ids,
             } => {
                 // Execute query
-                let actual_entities = self.execute_query(conn, query.clone()).map_err(|e| {
+                    self.execute_query::<Entity>(conn, query.clone())
                     format_err!(
                         "AbortUnless ({}): query execution error: {:?}, {}",
                         description,
@@ -934,7 +935,7 @@ impl StoreTrait for Store {
                         }
 
                         let entities = conn
-                            .query(
+                            .query::<Entity>(
                                 &logger,
                                 EntityCollection::All(vec![POI_OBJECT.to_owned()]),
                                 None,