Add api for auto cache index creation

cherylEnkidu · cherylEnkidu · commit 3f248b85909e · 2023-07-26T15:40:55.000-04:00
diff --git a/Firestore/Source/API/FIRFirestore+Internal.h b/Firestore/Source/API/FIRFirestore+Internal.h
@@ -25,6 +25,7 @@
 
 @class FIRApp;
 @class FSTUserDataReader;
+@class FIRPersistentCacheIndexManager;
 
 namespace firebase {
 namespace firestore {
@@ -78,6 +79,9 @@ NS_ASSUME_NONNULL_BEGIN
 
 - (const std::shared_ptr<firebase::firestore::util::AsyncQueue> &)workerQueue;
 
+// TODO(csi): make this function public
+@property(nonatomic, readonly) FIRPersistentCacheIndexManager *persistentCacheIndexManager;
+
 @property(nonatomic, assign, readonly) std::shared_ptr<api::Firestore> wrapped;
 
 @property(nonatomic, assign, readonly) const model::DatabaseId &databaseID;
diff --git a/Firestore/Source/API/FIRFirestore.mm b/Firestore/Source/API/FIRFirestore.mm
@@ -21,6 +21,7 @@
 #include <utility>
 
 #import "FIRFirestoreSettings+Internal.h"
+#import "FIRPersistentCacheSettings+Internal.h"
 #import "FIRTransactionOptions+Internal.h"
 #import "FIRTransactionOptions.h"
 
@@ -106,6 +107,7 @@ @implementation FIRFirestore {
   std::shared_ptr<Firestore> _firestore;
   FIRFirestoreSettings *_settings;
   __weak id<FSTFirestoreInstanceRegistry> _registry;
+  FIRPersistentCacheIndexManager *_indexManager;
 }
 
 + (void)initialize {
@@ -533,6 +535,17 @@ @implementation FIRFirestore (Internal)
   return _firestore->worker_queue();
 }
 
+- (FIRPersistentCacheIndexManager *)persistentCacheIndexManager {
+  if (!_indexManager) {
+    auto index_manager = _firestore->persistent_cache_index_manager();
+    if (index_manager) {
+      _indexManager = [[FIRPersistentCacheIndexManager alloc]
+          initWithPersistentCacheIndexManager:index_manager];
+    }
+  }
+  return _indexManager;
+}
+
 - (const DatabaseId &)databaseID {
   return _firestore->database_id();
 }
diff --git a/Firestore/Source/API/FIRPersistentCacheSettings+Internal.h b/Firestore/Source/API/FIRPersistentCacheSettings+Internal.h
@@ -0,0 +1,68 @@
+/*
+ * Copyright 2023 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.
+ */
+
+#import <Foundation/Foundation.h>
+
+#include <memory>
+
+#include "Firestore/core/src/api/persistent_cache_index_manager.h"
+
+NS_ASSUME_NONNULL_BEGIN
+
+// TODO(sum/avg) move the contents of this category to
+// ../Public/FirebaseFirestore/FIRPersistentCacheIndexManager.h
+/**
+ * A PersistentCacheIndexManager which you can config persistent cache indexes used for
+ * local query execution.
+ */
+NS_SWIFT_NAME(PersistentCacheIndexManager)
+@interface FIRPersistentCacheIndexManager : NSObject
+
+/** :nodoc: */
+- (instancetype)init
+    __attribute__((unavailable("FIRPersistentCacheIndexManager cannot be created directly.")));
+
+/**
+ * Enables SDK to create persistent cache indexes automatically for local query execution when SDK
+ * believes cache indexes can help improves performance.
+ *
+ * This feature is disabled by default.
+ */
+- (void)enableIndexAutoCreation NS_SWIFT_NAME(enableIndexAutoCreation());
+
+/**
+ * Stops creating persistent cache indexes automatically for local query execution. The indexes
+ * which have been created by calling `enableIndexAutoCreation` still take effect.
+ */
+- (void)disableIndexAutoCreation NS_SWIFT_NAME(disableIndexAutoCreation());
+
+/**
+ * Removes all persistent cache indexes. Please note this function will also deletes indexes
+ * generated by `setIndexConfigurationFromJSON` and `setIndexConfigurationFromStream`.
+ */
+- (void)deleteAllIndexes NS_SWIFT_NAME(deleteAllIndexes());
+
+@end
+
+@interface FIRPersistentCacheIndexManager (/* Init */)
+
+- (instancetype)initWithPersistentCacheIndexManager:
+    (std::shared_ptr<const firebase::firestore::api::PersistentCacheIndexManager>)indexManager
+    NS_DESIGNATED_INITIALIZER;
+
+@end
+
+NS_ASSUME_NONNULL_END
diff --git a/Firestore/Source/API/FIRPersistentCacheSettings.mm b/Firestore/Source/API/FIRPersistentCacheSettings.mm
@@ -0,0 +1,50 @@
+/*
+ * Copyright 2023 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.
+ */
+
+#import "Firestore/Source/API/FIRFirestore+Internal.h"
+#import "Firestore/Source/API/FIRPersistentCacheSettings+Internal.h"
+
+using firebase::firestore::api::Firestore;
+using firebase::firestore::api::PersistentCacheIndexManager;
+
+NS_ASSUME_NONNULL_BEGIN
+
+@implementation FIRPersistentCacheIndexManager {
+  /** The `Firestore` instance that created this index manager. */
+  std::shared_ptr<const PersistentCacheIndexManager> _indexManager;
+}
+
+- (instancetype)initWithPersistentCacheIndexManager:
+    (std::shared_ptr<const PersistentCacheIndexManager>)indexManager {
+  if (self = [super init]) {
+    _indexManager = indexManager;
+  }
+  return self;
+}
+
+- (void)enableIndexAutoCreation {
+  _indexManager->EnableIndexAutoCreation();
+}
+
+- (void)disableIndexAutoCreation {
+  _indexManager->DisableIndexAutoCreation();
+}
+
+- (void)deleteAllIndexes {
+  _indexManager->DeleteAllFieldIndexes();
+}
+
+@end
diff --git a/Firestore/core/src/api/firestore.cc b/Firestore/core/src/api/firestore.cc
@@ -22,6 +22,7 @@
 #include "Firestore/core/src/api/collection_reference.h"
 #include "Firestore/core/src/api/document_reference.h"
 #include "Firestore/core/src/api/listener_registration.h"
+#include "Firestore/core/src/api/persistent_cache_index_manager.h"
 #include "Firestore/core/src/api/settings.h"
 #include "Firestore/core/src/api/snapshots_in_sync_listener_registration.h"
 #include "Firestore/core/src/api/write_batch.h"
@@ -317,6 +318,17 @@ void Firestore::SetIndexConfiguration(const std::string& config,
   return;
 }
 
+std::shared_ptr<const PersistentCacheIndexManager>
+Firestore::persistent_cache_index_manager() {
+  EnsureClientConfigured();
+  if (settings_.persistence_enabled() && !persistent_cache_index_manager_) {
+    persistent_cache_index_manager_ =
+        std::make_shared<const PersistentCacheIndexManager>(client_);
+  }
+
+  return persistent_cache_index_manager_;
+}
+
 std::shared_ptr<LoadBundleTask> Firestore::LoadBundle(
     std::unique_ptr<util::ByteStream> bundle_data) {
   EnsureClientConfigured();
diff --git a/Firestore/core/src/api/firestore.h b/Firestore/core/src/api/firestore.h
@@ -46,6 +46,8 @@ struct Empty;
 
 namespace api {
 
+class PersistentCacheIndexManager;
+
 extern const int kDefaultTransactionMaxAttempts;
 
 class Firestore : public std::enable_shared_from_this<Firestore> {
@@ -88,6 +90,9 @@ class Firestore : public std::enable_shared_from_this<Firestore> {
 
   void set_user_executor(std::unique_ptr<util::Executor> user_executor);
 
+  std::shared_ptr<const PersistentCacheIndexManager>
+  persistent_cache_index_manager();
+
   CollectionReference GetCollection(const std::string& collection_path);
   DocumentReference GetDocument(const std::string& document_path);
   WriteBatch GetBatch();
@@ -131,6 +136,9 @@ class Firestore : public std::enable_shared_from_this<Firestore> {
       auth_credentials_provider_;
   std::string persistence_key_;
 
+  std::shared_ptr<const PersistentCacheIndexManager>
+      persistent_cache_index_manager_;
+
   std::shared_ptr<util::Executor> user_executor_;
   std::shared_ptr<util::AsyncQueue> worker_queue_;
 
diff --git a/Firestore/core/src/api/persistent_cache_index_manager.cc b/Firestore/core/src/api/persistent_cache_index_manager.cc
@@ -0,0 +1,46 @@
+/*
+ * Copyright 2023 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.
+ */
+
+#include "Firestore/core/src/api/persistent_cache_index_manager.h"
+
+#include <utility>
+
+#include "Firestore/core/src/core/firestore_client.h"
+
+namespace firebase {
+namespace firestore {
+namespace api {
+
+PersistentCacheIndexManager::PersistentCacheIndexManager(
+    std::shared_ptr<core::FirestoreClient> client)
+    : client_(std::move(client)) {
+}
+
+void PersistentCacheIndexManager::EnableIndexAutoCreation() const {
+  client_->EnableIndexAutoCreation();
+}
+
+void PersistentCacheIndexManager::DisableIndexAutoCreation() const {
+  client_->DisableIndexAutoCreation();
+}
+
+void PersistentCacheIndexManager::DeleteAllFieldIndexes() const {
+  client_->DeleteAllFieldIndexes();
+}
+
+}  // namespace api
+}  // namespace firestore
+}  // namespace firebase
diff --git a/Firestore/core/src/api/persistent_cache_index_manager.h b/Firestore/core/src/api/persistent_cache_index_manager.h
@@ -0,0 +1,68 @@
+/*
+ * Copyright 2023 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.
+ */
+
+#ifndef FIRESTORE_CORE_SRC_API_PERSISTENT_CACHE_INDEX_MANAGER_H_
+#define FIRESTORE_CORE_SRC_API_PERSISTENT_CACHE_INDEX_MANAGER_H_
+
+#include <memory>
+
+namespace firebase {
+namespace firestore {
+
+namespace core {
+class FirestoreClient;
+}  // namespace core
+
+namespace api {
+
+/**
+ * A PersistentCacheIndexManager which you can config persistent cache indexes
+ * used for local query execution.
+ *
+ * To use, call Firestore::persistent_cache_index_manager() to get an instance.
+ */
+class PersistentCacheIndexManager {
+ public:
+  explicit PersistentCacheIndexManager(
+      std::shared_ptr<core::FirestoreClient> client);
+
+  /**
+   * Enables SDK to create persistent cache indexes automatically for local
+   * query execution when SDK believes cache indexes can help improves
+   * performance.
+   *
+   * This feature is disabled by default.
+   */
+  void EnableIndexAutoCreation() const;
+
+  /**
+   * Stops creating persistent cache indexes automatically for local query
+   * execution. The indexes which have been created by calling
+   * EnableIndexAutoCreation() still take effect.
+   */
+  void DisableIndexAutoCreation() const;
+
+  void DeleteAllFieldIndexes() const;
+
+ private:
+  const std::shared_ptr<core::FirestoreClient> client_;
+};
+
+}  // namespace api
+}  // namespace firestore
+}  // namespace firebase
+
+#endif  // FIRESTORE_CORE_SRC_API_PERSISTENT_CACHE_INDEX_MANAGER_H_
diff --git a/Firestore/core/src/core/firestore_client.cc b/Firestore/core/src/core/firestore_client.cc
@@ -597,6 +597,21 @@ void FirestoreClient::ConfigureFieldIndexes(
   });
 }
 
+void FirestoreClient::EnableIndexAutoCreation() {
+  VerifyNotTerminated();
+  // worker_queue_->Enqueue([this] {
+  // local_store_->EnableIndexAutoCreation();
+  //});
+}
+
+void FirestoreClient::DisableIndexAutoCreation() {
+  VerifyNotTerminated();
+}
+
+void FirestoreClient::DeleteAllFieldIndexes() {
+  VerifyNotTerminated();
+}
+
 void FirestoreClient::LoadBundle(
     std::unique_ptr<util::ByteStream> bundle_data,
     std::shared_ptr<api::LoadBundleTask> result_task) {
diff --git a/Firestore/core/src/core/firestore_client.h b/Firestore/core/src/core/firestore_client.h
@@ -187,6 +187,24 @@ class FirestoreClient : public std::enable_shared_from_this<FirestoreClient> {
 
   void ConfigureFieldIndexes(std::vector<model::FieldIndex> parsed_indexes);
 
+  /**
+   * Enables SDK to create persistent cache indexes automatically for local
+   * query execution when SDK believes cache indexes can help improves
+   * performance.
+   *
+   * This feature is disabled by default.
+   */
+  void EnableIndexAutoCreation();
+
+  /**
+   * Stops creating persistent cache indexes automatically for local query
+   * execution. The indexes which have been created by calling
+   * EnableIndexAutoCreation() still take effect.
+   */
+  void DisableIndexAutoCreation();
+
+  void DeleteAllFieldIndexes();
+
   void LoadBundle(std::unique_ptr<util::ByteStream> bundle_data,
                   std::shared_ptr<api::LoadBundleTask> result_task);
 
