graphql: Refactor handling of multiple block constraints

Author: leoyvens

graphql/src/runner.rs

@@ -137,36 +137,32 @@ where
                 },
             )
         };
-        let by_block_constraint = query.block_constraint()?;
-
-        // We want to optimize for the common case of a single block constraint,
-        // where we can avoid cloning the result.
-        match by_block_constraint.len() {
-            0 => Ok(Arc::new(QueryResult::empty())),
-            1 => {
-                let (bc, selection_set) = by_block_constraint.into_iter().next().unwrap();
+
+        // Unwrap: There is always at least one block constraint, even if it
+        // is an implicit 'BlockContraint::Latest'.
+        let mut by_block_constraint = query.block_constraint()?.into_iter();
+        let (bc, selection_set) = by_block_constraint.next().unwrap();
+        let (resolver, block_ptr) =
+            StoreResolver::at_block(&self.logger, self.store.clone(), bc, &query.schema.id)?;
+        let mut result = execute(selection_set, block_ptr, resolver);
+
+        // We want to optimize for the common case of a single block constraint, where we can avoid
+        // cloning the result. If there are multiple constraints we have to clone.
+        if by_block_constraint.len() > 0 {
+            let mut partial_res = result.as_ref().clone();
+            for (bc, selection_set) in by_block_constraint {
                 let (resolver, block_ptr) = StoreResolver::at_block(
                     &self.logger,
                     self.store.clone(),
                     bc,
                     &query.schema.id,
                 )?;
-                Ok(execute(selection_set, block_ptr, resolver))
-            }
-            _ => {
-                let mut result = QueryResult::empty();
-                for (bc, selection_set) in query.block_constraint()? {
-                    let (resolver, block_ptr) = StoreResolver::at_block(
-                        &self.logger,
-                        self.store.clone(),
-                        bc,
-                        &query.schema.id,
-                    )?;
-                    result.append(execute(selection_set, block_ptr, resolver).as_ref().clone());
-                }
-                Ok(Arc::new(result))
+                partial_res.append(execute(selection_set, block_ptr, resolver).as_ref().clone());
             }
+            result = Arc::new(partial_res);
         }
+
+        Ok(result)
     }
 }
 

tests/integration-tests/value-roundtrip/test/test.js

@@ -76,13 +76,18 @@ contract("Contract", (accounts) => {
     await waitForSubgraphToBeSynced();
   });
 
-  it("all overloads of the contract function are called", async () => {
+  it("test query", async () => {
+    // Also test that multiple block constraints do not result in a graphql error.
     let result = await fetchSubgraph({
-      query: `{ foos(orderBy: id) { id value } }`,
+      query: `{
+        foos_0: foos(orderBy: id, block: { number: 0 }) { id }
+        foos(orderBy: id) { id value }
+      }`,
     });
 
     expect(result.errors).to.be.undefined;
     expect(result.data).to.deep.equal({
+      foos_0: [],
       foos: [
         {
           id: "0",