Firestore COUNT API

app/CMakeLists.txt

@@ -522,6 +522,9 @@ if (IOS)
     ${FIREBASE_SOURCE_DIR}/dynamic_links/src/include/firebase/dynamic_links/components.h)
   set(firestore_HDRS
     ${FIREBASE_SOURCE_DIR}/firestore/src/include/firebase/firestore.h
+    ${FIREBASE_SOURCE_DIR}/firestore/src/include/firebase/firestore/aggregate_query.h
+    ${FIREBASE_SOURCE_DIR}/firestore/src/include/firebase/firestore/aggregate_query_snapshot.h
+    ${FIREBASE_SOURCE_DIR}/firestore/src/include/firebase/firestore/aggregate_source.h
     ${FIREBASE_SOURCE_DIR}/firestore/src/include/firebase/firestore/collection_reference.h
     ${FIREBASE_SOURCE_DIR}/firestore/src/include/firebase/firestore/document_change.h
     ${FIREBASE_SOURCE_DIR}/firestore/src/include/firebase/firestore/document_reference.h

firestore/CMakeLists.txt

@@ -20,6 +20,8 @@ else()
 endif()
 
 set(common_SRCS
+    src/common/aggregate_query.cc
+    src/common/aggregate_query_snapshot.cc
     src/common/cleanup.h
     src/common/collection_reference.cc
     src/common/compiler_info.cc
@@ -185,6 +187,10 @@ set(android_SRCS
 
 # Sources that apply to all non-Android platforms.
 set(main_SRCS
+    src/main/aggregate_query_main.cc
+    src/main/aggregate_query_main.h
+    src/main/aggregate_query_snapshot_main.cc
+    src/main/aggregate_query_snapshot_main.h
     src/main/collection_reference_main.cc
     src/main/collection_reference_main.h
     src/main/converter_main.h

firestore/CONTRIBUTING.md

@@ -19,7 +19,7 @@ a Python3 installation.
 
 # Architecture
 
-It is easier to work this Firestore CPP SDK by keeping a high level archetecture in mind:
+It is easier to work this Firestore CPP SDK by keeping a high level architecture in mind:
 
 ![architecture.png](architecture.png)
 

firestore/src/common/aggregate_query.cc

@@ -0,0 +1,112 @@
+/*
+ * 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/src/include/firebase/firestore/aggregate_query.h"
+#include "firestore/src/common/cleanup.h"
+#include "firestore/src/common/futures.h"
+#include "firestore/src/common/util.h"
+#include "firestore/src/include/firebase/firestore/aggregate_query_snapshot.h"
+
+#if defined(__ANDROID__)
+// TODO(tomandersen) #include "firestore/src/android/aggregate_query_android.h"
+#else
+#include "firestore/src/main/aggregate_query_main.h"
+#endif  // defined(__ANDROID__)
+
+namespace firebase {
+namespace firestore {
+
+using CleanupFnAggregateQuery = CleanupFn<AggregateQuery>;
+
+AggregateQuery::AggregateQuery() {}
+
+AggregateQuery::AggregateQuery(const AggregateQuery& other) {
+  if (other.internal_) {
+    internal_ = new AggregateQueryInternal(*other.internal_);
+  }
+  CleanupFnAggregateQuery::Register(this, internal_);
+}
+
+AggregateQuery::AggregateQuery(AggregateQuery&& other) {
+  CleanupFnAggregateQuery::Unregister(&other, other.internal_);
+  std::swap(internal_, other.internal_);
+  CleanupFnAggregateQuery::Register(this, internal_);
+}
+
+AggregateQuery::AggregateQuery(AggregateQueryInternal* internal)
+    : internal_(internal) {
+  SIMPLE_HARD_ASSERT(internal != nullptr);
+  CleanupFnAggregateQuery::Register(this, internal_);
+}
+
+AggregateQuery::~AggregateQuery() {
+  CleanupFnAggregateQuery::Unregister(this, internal_);
+  delete internal_;
+  internal_ = nullptr;
+}
+
+AggregateQuery& AggregateQuery::operator=(const AggregateQuery& other) {
+  if (this == &other) {
+    return *this;
+  }
+
+  CleanupFnAggregateQuery::Unregister(this, internal_);
+  delete internal_;
+  if (other.internal_) {
+    internal_ = new AggregateQueryInternal(*other.internal_);
+  } else {
+    internal_ = nullptr;
+  }
+  CleanupFnAggregateQuery::Register(this, internal_);
+  return *this;
+}
+
+AggregateQuery& AggregateQuery::operator=(AggregateQuery&& other) {
+  if (this == &other) {
+    return *this;
+  }
+
+  CleanupFnAggregateQuery::Unregister(&other, other.internal_);
+  CleanupFnAggregateQuery::Unregister(this, internal_);
+  delete internal_;
+  internal_ = other.internal_;
+  other.internal_ = nullptr;
+  CleanupFnAggregateQuery::Register(this, internal_);
+  return *this;
+}
+
+Query AggregateQuery::query() const {
+  if (!internal_) return {};
+  return internal_->query();
+}
+
+Future<AggregateQuerySnapshot> AggregateQuery::Get(
+    AggregateSource aggregate_source) const {
+  if (!internal_) return FailedFuture<AggregateQuerySnapshot>();
+  return internal_->Get(aggregate_source);
+}
+
+size_t AggregateQuery::Hash() const {
+  if (!internal_) return {};
+  return internal_->Hash();
+}
+
+bool operator==(const AggregateQuery& lhs, const AggregateQuery& rhs) {
+  return EqualityCompare(lhs.internal_, rhs.internal_);
+}
+
+}  // namespace firestore
+}  // namespace firebase

firestore/src/common/aggregate_query_snapshot.cc

@@ -0,0 +1,117 @@
+/*
+ * 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/src/include/firebase/firestore/aggregate_query_snapshot.h"
+
+#include "firestore/src/common/cleanup.h"
+#include "firestore/src/common/util.h"
+#include "firestore/src/include/firebase/firestore/aggregate_query.h"
+
+#if defined(__ANDROID__)
+// TODO(tomandersen) #include
+// "firestore/src/android/aggregate_query_snapshot_android.h"
+#else
+#include "firestore/src/main/aggregate_query_snapshot_main.h"
+#endif  // defined(__ANDROID__)
+
+namespace firebase {
+namespace firestore {
+
+using CleanupFnAggregateQuerySnapshot = CleanupFn<AggregateQuerySnapshot>;
+
+AggregateQuerySnapshot::AggregateQuerySnapshot() {}
+
+AggregateQuerySnapshot::AggregateQuerySnapshot(
+    const AggregateQuerySnapshot& other) {
+  if (other.internal_) {
+    internal_ = new AggregateQuerySnapshotInternal(*other.internal_);
+  }
+  CleanupFnAggregateQuerySnapshot::Register(this, internal_);
+}
+
+AggregateQuerySnapshot::AggregateQuerySnapshot(AggregateQuerySnapshot&& other) {
+  CleanupFnAggregateQuerySnapshot::Unregister(&other, other.internal_);
+  std::swap(internal_, other.internal_);
+  CleanupFnAggregateQuerySnapshot::Register(this, internal_);
+}
+
+AggregateQuerySnapshot::AggregateQuerySnapshot(
+    AggregateQuerySnapshotInternal* internal)
+    : internal_(internal) {
+  SIMPLE_HARD_ASSERT(internal != nullptr);
+  CleanupFnAggregateQuerySnapshot::Register(this, internal_);
+}
+
+AggregateQuerySnapshot::~AggregateQuerySnapshot() {
+  CleanupFnAggregateQuerySnapshot::Unregister(this, internal_);
+  delete internal_;
+  internal_ = nullptr;
+}
+
+AggregateQuerySnapshot& AggregateQuerySnapshot::operator=(
+    const AggregateQuerySnapshot& other) {
+  if (this == &other) {
+    return *this;
+  }
+
+  CleanupFnAggregateQuerySnapshot::Unregister(this, internal_);
+  delete internal_;
+  if (other.internal_) {
+    internal_ = new AggregateQuerySnapshotInternal(*other.internal_);
+  } else {
+    internal_ = nullptr;
+  }
+  CleanupFnAggregateQuerySnapshot::Register(this, internal_);
+  return *this;
+}
+
+AggregateQuerySnapshot& AggregateQuerySnapshot::operator=(
+    AggregateQuerySnapshot&& other) {
+  if (this == &other) {
+    return *this;
+  }
+
+  CleanupFnAggregateQuerySnapshot::Unregister(&other, other.internal_);
+  CleanupFnAggregateQuerySnapshot::Unregister(this, internal_);
+  delete internal_;
+  internal_ = other.internal_;
+  other.internal_ = nullptr;
+  CleanupFnAggregateQuerySnapshot::Register(this, internal_);
+  return *this;
+}
+
+AggregateQuery AggregateQuerySnapshot::query() const {
+  if (!internal_) return {};
+  return internal_->query();
+}
+
+int64_t AggregateQuerySnapshot::count() const {
+  if (!internal_) return 0;
+  return internal_->count();
+}
+
+bool operator==(const AggregateQuerySnapshot& lhs,
+                const AggregateQuerySnapshot& rhs) {
+  return EqualityCompare(lhs.internal_, rhs.internal_);
+}
+
+size_t AggregateQuerySnapshot::Hash() const {
+  if (!internal_) return {};
+  return internal_->Hash();
+}
+
+}  // namespace firestore
+}  // namespace firebase

firestore/src/common/query.cc

@@ -23,6 +23,7 @@
 #include "firestore/src/common/futures.h"
 #include "firestore/src/common/hard_assert_common.h"
 #include "firestore/src/common/util.h"
+#include "firestore/src/include/firebase/firestore/aggregate_query.h"
 #include "firestore/src/include/firebase/firestore/document_snapshot.h"
 #include "firestore/src/include/firebase/firestore/field_path.h"
 #include "firestore/src/include/firebase/firestore/field_value.h"
@@ -106,6 +107,11 @@ Firestore* Query::firestore() {
   return internal_->firestore();
 }
 
+AggregateQuery Query::Count() const {
+  if (!internal_) return {};
+  return internal_->Count();
+}
+
 Query Query::WhereEqualTo(const std::string& field,
                           const FieldValue& value) const {
   return WhereEqualTo(FieldPath::FromDotSeparatedString(field), value);

firestore/src/common/type_mapping.h

@@ -22,6 +22,10 @@
 namespace firebase {
 namespace firestore {
 
+class AggregateQuery;
+class AggregateQueryInternal;
+class AggregateQuerySnapshot;
+class AggregateQuerySnapshotInternal;
 class CollectionReference;
 class CollectionReferenceInternal;
 class DocumentChange;
@@ -54,6 +58,14 @@ class WriteBatchInternal;
 template <typename T>
 struct InternalTypeMap {};
 
+template <>
+struct InternalTypeMap<AggregateQuery> {
+  using type = AggregateQueryInternal;
+};
+template <>
+struct InternalTypeMap<AggregateQuerySnapshot> {
+  using type = AggregateQuerySnapshotInternal;
+};
 template <>
 struct InternalTypeMap<CollectionReference> {
   using type = CollectionReferenceInternal;

firestore/src/include/firebase/firestore.h

@@ -27,6 +27,9 @@
 #include "firebase/log.h"
 // Include *all* the public headers to make sure including just "firestore.h" is
 // sufficient for users.
+#include "firebase/firestore/aggregate_query.h"
+#include "firebase/firestore/aggregate_query_snapshot.h"
+#include "firebase/firestore/aggregate_source.h"
 #include "firebase/firestore/collection_reference.h"
 #include "firebase/firestore/document_change.h"
 #include "firebase/firestore/document_reference.h"