Add long alias support on SDK side for SUM/AVG (firebase#4961)

* Add long alias

* Address comments

Author: cherylEnkidu

firebase-firestore/src/androidTest/java/com/google/firebase/firestore/AggregationTest.java

@@ -1228,4 +1228,30 @@ public void testAggregateFailWithGoodMessageIfMissingIndex() {
     Truth.assertThat(cause).hasMessageThat().ignoringCase().contains("index");
     Truth.assertThat(cause).hasMessageThat().contains("https://console.firebase.google.com");
   }
+
+  @Test
+  public void allowsAliasesLongerThan1500Bytes() {
+    assumeTrue(
+        "Skip this test if running against production because sum/avg is only support "
+            + "in emulator currently.",
+        isRunningAgainstEmulator());
+    // The longest field name allowed is 1500. The alias chosen by the client is <op>_<fieldName>.
+    // If the field name is
+    // 1500 bytes, the alias will be longer than 1500, which is the limit for aliases. This is to
+    // make sure the client
+    // can handle this corner case correctly.
+
+    StringBuilder builder = new StringBuilder(1500);
+    for (int i = 0; i < 1500; i++) {
+      builder.append("a");
+    }
+    String longField = builder.toString();
+    Map<String, Map<String, Object>> testDocs = map("a", map(longField, 1), "b", map(longField, 2));
+    CollectionReference collection = testCollectionWithDocs(testDocs);
+
+    AggregateQuerySnapshot snapshot =
+        waitFor(collection.aggregate(sum(longField)).get(AggregateSource.SERVER));
+
+    assertEquals(snapshot.get(sum(longField)), 3L);
+  }
 }

firebase-firestore/src/main/java/com/google/firebase/firestore/remote/Datastore.java

@@ -14,6 +14,7 @@
 
 package com.google.firebase.firestore.remote;
 
+import static com.google.firebase.firestore.util.Assert.hardAssert;
 import static com.google.firebase.firestore.util.Util.exceptionFromStatus;
 
 import android.content.Context;
@@ -225,8 +226,9 @@ public Task<Map<String, Value>> runAggregateQuery(
       Query query, List<AggregateField> aggregateFields) {
     com.google.firestore.v1.Target.QueryTarget encodedQueryTarget =
         serializer.encodeQueryTarget(query.toTarget());
+    HashMap<String, String> aliasMap = new HashMap<>();
     StructuredAggregationQuery structuredAggregationQuery =
-        serializer.encodeStructuredAggregationQuery(encodedQueryTarget, aggregateFields);
+        serializer.encodeStructuredAggregationQuery(encodedQueryTarget, aggregateFields, aliasMap);
 
     RunAggregationQueryRequest.Builder request = RunAggregationQueryRequest.newBuilder();
     request.setParent(encodedQueryTarget.getParent());
@@ -246,8 +248,20 @@ public Task<Map<String, Value>> runAggregateQuery(
                 throw task.getException();
               }
 
+              Map<String, Value> result = new HashMap<>();
               RunAggregationQueryResponse response = task.getResult();
-              return response.getResult().getAggregateFieldsMap();
+
+              // Remap the short-form aliases that were sent to the server to the client-side
+              // aliases. Users will access the results using the client-side alias.
+              for (Map.Entry<String, Value> entry :
+                  response.getResult().getAggregateFieldsMap().entrySet()) {
+                hardAssert(
+                    aliasMap.containsKey(entry.getKey()),
+                    "%s not present in aliasMap",
+                    entry.getKey());
+                result.put(aliasMap.get(entry.getKey()), entry.getValue());
+              }
+              return result;
             });
   }
 

firebase-firestore/src/main/java/com/google/firebase/firestore/remote/RemoteSerializer.java

@@ -633,14 +633,30 @@ public com.google.firebase.firestore.core.Target decodeQueryTarget(QueryTarget t
   }
 
   StructuredAggregationQuery encodeStructuredAggregationQuery(
-      QueryTarget encodedQueryTarget, List<AggregateField> aggregateFields) {
+      QueryTarget encodedQueryTarget,
+      List<AggregateField> aggregateFields,
+      HashMap<String, String> aliasMap) {
     StructuredAggregationQuery.Builder structuredAggregationQuery =
         StructuredAggregationQuery.newBuilder();
     structuredAggregationQuery.setStructuredQuery(encodedQueryTarget.getStructuredQuery());
 
-    // We use a Set here to automatically remove duplicates.
-    Set<StructuredAggregationQuery.Aggregation> aggregations = new HashSet<>();
+    List<StructuredAggregationQuery.Aggregation> aggregations = new ArrayList<>();
+
+    HashSet<String> uniqueFields = new HashSet<>();
+    int aliasID = 1;
     for (AggregateField aggregateField : aggregateFields) {
+      // The code block below is used to deduplicate the same aggregate fields.
+      // If two aggregateFields are identical, their aliases would be the same.
+      // Therefore, when adding duplicated alias into uniqueFields, the size of uniqueFields
+      // won't increase, and we can skip this aggregateField processing.
+      final int count = uniqueFields.size();
+      uniqueFields.add(aggregateField.getAlias());
+      if (count == uniqueFields.size()) {
+        continue;
+      }
+      String serverAlias = "aggregate_" + aliasID++;
+      aliasMap.put(serverAlias, aggregateField.getAlias());
+
       StructuredAggregationQuery.Aggregation.Builder aggregation =
           StructuredAggregationQuery.Aggregation.newBuilder();
       StructuredQuery.FieldReference fieldPath =
@@ -660,7 +676,7 @@ StructuredAggregationQuery encodeStructuredAggregationQuery(
         throw new RuntimeException("Unsupported aggregation");
       }
 
-      aggregation.setAlias(aggregateField.getAlias());
+      aggregation.setAlias(serverAlias);
       aggregations.add(aggregation.build());
     }
     structuredAggregationQuery.addAllAggregations(aggregations);