Add BundleCache

Author: schmidt-sebastian

firebase-firestore/src/main/java/com/google/firebase/firestore/local/BundleCache.java

@@ -0,0 +1,42 @@
+// Copyright 2021 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package com.google.firebase.firestore.local;
+
+import androidx.annotation.Nullable;
+
+/** Provides methods to save and read Firestore bundles. */
+public interface BundleCache {
+  /**
+   * Gets the saved BundleMetadata for a given bundle id. Returns {@code null} if no bundles are
+   * found under the given id.
+   */
+  @Nullable
+  BundleMetadata getBundleMetadata(String bundleId);
+
+  /**
+   * Saves the BundleMetadata from a bundle into local storage, using its id as the persistent key.
+   */
+  void saveBundleMetadata(BundleMetadata metadata);
+
+  /**
+   * Gets a saved NamedQuery for the given query name. Returns {@code null} if no queries are found
+   * under the given name.
+   */
+  @Nullable
+  NamedQuery getNamedQuery(String queryName);
+
+  /** Saves a NamedQuery from a bundle, using its name as the persistent key. */
+  void saveNamedQuery(NamedQuery query);
+}

firebase-firestore/src/main/java/com/google/firebase/firestore/local/BundleMetadata.java

@@ -0,0 +1,71 @@
+// Copyright 2021 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package com.google.firebase.firestore.local;
+
+import com.google.firebase.firestore.model.SnapshotVersion;
+
+/** Represents a Firestore bundle saved by the SDK in its local storage. */
+/* package */ class BundleMetadata {
+  private final String bundleId;
+  private final int schemaVersion;
+  private final SnapshotVersion createTime;
+
+  public BundleMetadata(String bundleId, int schemaVersion, SnapshotVersion createTime) {
+    this.bundleId = bundleId;
+    this.schemaVersion = schemaVersion;
+    this.createTime = createTime;
+  }
+
+  /**
+   * @return Id of the bundle. It is used together with `createTime` to determine if a bundle has
+   *     been loaded by the SDK.
+   */
+  public String getBundleId() {
+    return bundleId;
+  }
+
+  /** @return Schema version of the bundle. */
+  public int getSchemaVersion() {
+    return schemaVersion;
+  }
+
+  /**
+   * @return Snapshot version of the bundle if created by the Server SDKs, or else
+   *     SnapshotVersion.MIN.
+   */
+  public SnapshotVersion getCreateTime() {
+    return createTime;
+  }
+
+  @Override
+  public boolean equals(Object o) {
+    if (this == o) return true;
+    if (o == null || getClass() != o.getClass()) return false;
+
+    BundleMetadata that = (BundleMetadata) o;
+
+    if (schemaVersion != that.schemaVersion) return false;
+    if (!bundleId.equals(that.bundleId)) return false;
+    return createTime.equals(that.createTime);
+  }
+
+  @Override
+  public int hashCode() {
+    int result = bundleId.hashCode();
+    result = 31 * result + schemaVersion;
+    result = 31 * result + createTime.hashCode();
+    return result;
+  }
+}

firebase-firestore/src/main/java/com/google/firebase/firestore/local/LocalSerializer.java

@@ -18,6 +18,8 @@
 import static com.google.firebase.firestore.util.Assert.hardAssert;
 
 import com.google.firebase.Timestamp;
+import com.google.firebase.firestore.core.Query;
+import com.google.firebase.firestore.core.Query.LimitType;
 import com.google.firebase.firestore.core.Target;
 import com.google.firebase.firestore.model.Document;
 import com.google.firebase.firestore.model.DocumentKey;
@@ -29,6 +31,7 @@
 import com.google.firebase.firestore.model.mutation.Mutation;
 import com.google.firebase.firestore.model.mutation.MutationBatch;
 import com.google.firebase.firestore.remote.RemoteSerializer;
+import com.google.firestore.proto.BundledQuery;
 import com.google.firestore.v1.DocumentTransform.FieldTransform;
 import com.google.firestore.v1.Write;
 import com.google.firestore.v1.Write.Builder;
@@ -266,4 +269,32 @@ TargetData decodeTargetData(com.google.firebase.firestore.proto.Target targetPro
         lastLimboFreeSnapshotVersion,
         resumeToken);
   }
+
+  public com.google.firestore.proto.BundledQuery encodeQuery(Query query) {
+    // We store LimitToLast as metadata information below. We remove it from the query itself as
+    // `toTarget()` flips the order by constraints otherwise.
+    Query queryWithoutLimitToLast =
+        query.hasLimitToLast() ? query.limitToFirst(query.getLimitToLast()) : query;
+    com.google.firestore.v1.Target.QueryTarget queryTarget =
+        rpcSerializer.encodeQueryTarget(queryWithoutLimitToLast.toTarget());
+
+    com.google.firestore.proto.BundledQuery.Builder result =
+        com.google.firestore.proto.BundledQuery.newBuilder();
+    result.setLimitType(
+        query.hasLimitToLast() ? BundledQuery.LimitType.LAST : BundledQuery.LimitType.FIRST);
+    result.setParent(queryTarget.getParent());
+    result.setStructuredQuery(queryTarget.getStructuredQuery());
+
+    return result.build();
+  }
+
+  public Query decodeQuery(com.google.firestore.proto.BundledQuery bundledQuery) {
+    LimitType limitType =
+        bundledQuery.getLimitType().equals(BundledQuery.LimitType.FIRST)
+            ? LimitType.LIMIT_TO_FIRST
+            : LimitType.LIMIT_TO_LAST;
+
+    return rpcSerializer.decodeQuery(
+        bundledQuery.getParent(), bundledQuery.getStructuredQuery(), limitType);
+  }
 }

firebase-firestore/src/main/java/com/google/firebase/firestore/local/MemoryBundleCache.java

@@ -0,0 +1,47 @@
+// Copyright 2021 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package com.google.firebase.firestore.local;
+
+import androidx.annotation.Nullable;
+import java.util.HashMap;
+import java.util.Map;
+
+/** A memory-backed implementation of the bundle cache. */
+/* package */ class MemoryBundleCache implements BundleCache {
+  private final Map<String, BundleMetadata> bundles = new HashMap<>();
+  private final Map<String, NamedQuery> namedQueries = new HashMap<>();
+
+  @Nullable
+  @Override
+  public BundleMetadata getBundleMetadata(String bundleId) {
+    return bundles.get(bundleId);
+  }
+
+  @Override
+  public void saveBundleMetadata(BundleMetadata metadata) {
+    bundles.put(metadata.getBundleId(), metadata);
+  }
+
+  @Override
+  @Nullable
+  public NamedQuery getNamedQuery(String queryName) {
+    return namedQueries.get(queryName);
+  }
+
+  @Override
+  public void saveNamedQuery(NamedQuery query) {
+    namedQueries.put(query.getName(), query);
+  }
+}

firebase-firestore/src/main/java/com/google/firebase/firestore/local/MemoryPersistence.java

@@ -34,6 +34,7 @@ public final class MemoryPersistence extends Persistence {
   private final Map<User, MemoryMutationQueue> mutationQueues;
   private final MemoryIndexManager indexManager;
   private final MemoryTargetCache targetCache;
+  private final MemoryBundleCache bundleCache;
   private final MemoryRemoteDocumentCache remoteDocumentCache;
   private ReferenceDelegate referenceDelegate;
 
@@ -58,6 +59,7 @@ private MemoryPersistence() {
     mutationQueues = new HashMap<>();
     indexManager = new MemoryIndexManager();
     targetCache = new MemoryTargetCache(this);
+    bundleCache = new MemoryBundleCache();
     remoteDocumentCache = new MemoryRemoteDocumentCache(this);
   }
 
@@ -118,6 +120,11 @@ IndexManager getIndexManager() {
     return indexManager;
   }
 
+  @Override
+  BundleCache getBundleCache() {
+    return bundleCache;
+  }
+
   @Override
   void runTransaction(String action, Runnable operation) {
     referenceDelegate.onTransactionStarted();

firebase-firestore/src/main/java/com/google/firebase/firestore/local/NamedQuery.java

@@ -0,0 +1,58 @@
+// Copyright 2021 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package com.google.firebase.firestore.local;
+
+import com.google.firebase.firestore.core.Query;
+import com.google.firebase.firestore.model.SnapshotVersion;
+
+/** Represents a named query saved by the SDK in its local storage. */
+/* package */ class NamedQuery {
+  private final String name;
+  private final Query query;
+  private final SnapshotVersion readTime;
+
+  public NamedQuery(String name, Query query, SnapshotVersion readTime) {
+    this.name = name;
+    this.query = query;
+    this.readTime = readTime;
+  }
+
+  /** @return The name of the query. */
+  public String getName() {
+    return name;
+  }
+
+  /** @return The underlying query associated with the given name. */
+  public Query getQuery() {
+    return query;
+  }
+
+  /** @return The time at which the results for this query were read. */
+  public SnapshotVersion getReadTime() {
+    return readTime;
+  }
+
+  @Override
+  public boolean equals(Object o) {
+    if (this == o) return true;
+    if (o == null || getClass() != o.getClass()) return false;
+
+    NamedQuery that = (NamedQuery) o;
+
+    if (!name.equals(that.name)) return false;
+    if (!query.equals(that.query)) return false;
+    return readTime.equals(that.readTime);
+  }
+}

firebase-firestore/src/main/java/com/google/firebase/firestore/local/Persistence.java

@@ -89,6 +89,9 @@ public abstract class Persistence {
   /** Creates an IndexManager that manages our persisted query indexes. */
   abstract IndexManager getIndexManager();
 
+  /** Returns a BundleCache representing the persisted cache of loaded bundles. */
+  abstract BundleCache getBundleCache();
+
   /**
    * Performs an operation inside a persistence transaction. Any reads or writes against persistence
    * must be performed within a transaction. Writes will be committed atomically once the