Implement Count Queries

src/Database/Adapter.php

@@ -901,11 +901,11 @@ abstract public function getSupportForCastIndexArray(): bool;
     abstract public function getSupportForUpserts(): bool;
 
     /**
-     * Are sum queries supported?
+     * Are aggregate queries supported?
      *
      * @return bool
      */
-    abstract public function getSupportForSum(): bool;
+    abstract public function getSupportForAggregateQueries(): bool;
 
     /**
      * Get current attribute count from collection document
@@ -996,17 +996,18 @@ protected function getAttributeSelections(array $queries): array
     }
 
     /**
-     * Get all sum attributes from queries
+     * Get all attributes from an aggregate query
      *
-     * @param Query[] $queries
+     * @param array<Query> $queries
+     * @param string $queryType
      * @return array<string|array<string>>
      */
-    protected function getAttributeSums(array $queries): array
+    protected function getAttributeSums(array $queries, string $queryType): array
     {
         $selections = [];
 
         foreach ($queries as $query) {
-            if ($query->getMethod() === Query::TYPE_SUM) {
+            if ($query->getMethod() === $queryType) {
                 $selections[] = $query->getValues();
             }
         }

src/Database/Adapter/MariaDB.php

@@ -2139,7 +2139,6 @@ public function find(string $collection, array $queries = [], ?int $limit = 25,
         $sqlLimit .= \is_null($offset) ? '' : ' OFFSET :offset';
 
         $selections = $this->getAttributeSelections($queries);
-        $sumSelections = $this->getAttributeSums($queries);
 
         $sql = "
             SELECT {$this->getAttributeProjection($selections, 'table_main')}
@@ -2149,8 +2148,10 @@ public function find(string $collection, array $queries = [], ?int $limit = 25,
             {$sqlLimit}
         ";
 
-        if (!empty($sumSelections)) {
-            $sql = "SELECT {$this->getSumQueries($sumSelections)} FROM ({$sql}) table_sum;";
+        $aggregateQueries = array_filter($queries, fn ($query) => in_array($query->getMethod(), Query::AGGREGATE_TYPES));
+
+        if (!empty($aggregateQueries)) {
+            $sql = $this->handleAggregateQueries($sql, $aggregateQueries);
         } else {
             $sql .= ';';
         }
@@ -2645,16 +2646,6 @@ public function getSupportForUpserts(): bool
         return true;
     }
 
-    /**
-     * Are sum queries supported?
-     *
-     * @return bool
-     */
-    public function getSupportForSum(): bool
-    {
-        return true;
-    }
-
     /**
      * Set max execution time
      * @param int $milliseconds
@@ -2779,6 +2770,35 @@ public function getSchemaAttributes(string $collection): array
         }
     }
 
+    /**
+     * Handle Aggregate Queries
+     *
+     * @param string $sql
+     * @param array<Query> $aggregateQueries
+     * @return string
+     */
+    public function handleAggregateQueries(string $sql, array $aggregateQueries): string
+    {
+        // There should not be multiple types of aggregate queries
+        // Multiple of the same type should be allowed
+        $aggregateType = $aggregateQueries[0]->getMethod();
+
+        switch ($aggregateType) {
+            case Query::TYPE_COUNT:
+                $countSelections = [];
+                foreach ($aggregateQueries as $query) {
+                    $attribute = $query->getAttribute();
+                    $countSelections[] = "COUNT(`{$attribute}`) as `{$attribute}`";
+                }
+                return "SELECT " . implode(', ', $countSelections) . " FROM ({$sql}) table_count;";
+            case Query::TYPE_SUM:
+                $selections = $this->getAttributeSums($aggregateQueries, $aggregateType);
+                return "SELECT {$this->getSumQueries($selections)} FROM ({$sql}) table_sum;";
+            default:
+                throw new DatabaseException('Unknown aggregate type: ' . $aggregateType);
+        }
+    }
+
     public function getSupportForSchemaAttributes(): bool
     {
         return true;

src/Database/Adapter/Mongo.php

@@ -1820,7 +1820,7 @@ public function getSupportForUpserts(): bool
         return false;
     }
 
-    public function getSupportForSum(): bool
+    public function getSupportForAggregateQueries(): bool
     {
         return false;
     }

src/Database/Adapter/Postgres.php

@@ -1917,7 +1917,6 @@ public function find(string $collection, array $queries = [], ?int $limit = 25,
         $sqlLimit = \is_null($limit) ? '' : 'LIMIT :limit';
         $sqlLimit .= \is_null($offset) ? '' : ' OFFSET :offset';
         $selections = $this->getAttributeSelections($queries);
-        $sumSelections = $this->getAttributeSums($queries);
 
         $sql = "
             SELECT {$this->getAttributeProjection($selections, 'table_main')}
@@ -1927,8 +1926,10 @@ public function find(string $collection, array $queries = [], ?int $limit = 25,
             {$sqlLimit}
         ";
 
-        if (!empty($sumSelections)) {
-            $sql = "SELECT {$this->getSumQueries($sumSelections)} FROM ({$sql}) table_sum;";
+        $aggregateQueries = array_filter($queries, fn ($query) => in_array($query->getMethod(), Query::AGGREGATE_TYPES));
+
+        if (!empty($aggregateQueries)) {
+            $sql = $this->handleAggregateQueries($sql, $aggregateQueries);
         } else {
             $sql .= ';';
         }
@@ -2480,16 +2481,6 @@ public function getSupportForUpserts(): bool
         return false;
     }
 
-    /**
-     * Are sum queries supported?
-     *
-     * @return bool
-     */
-    public function getSupportForSum(): bool
-    {
-        return true;
-    }
-
     /**
      * @return string
      */
@@ -2530,6 +2521,37 @@ protected function processException(PDOException $e): \Exception
         return $e;
     }
 
+    /**
+     * Handle Aggregate Queries
+     *
+     * @param string $sql
+     * @param array<Query> $aggregateQueries
+     * @return string
+     */
+    public function handleAggregateQueries(string $sql, array $aggregateQueries): string
+    {
+        if (empty($aggregateQueries)) {
+            return $sql;
+        }
+
+        $aggregateType = $aggregateQueries[0]->getMethod();
+
+        switch ($aggregateType) {
+            case Query::TYPE_COUNT:
+                $countSelections = [];
+                foreach ($aggregateQueries as $query) {
+                    $attribute = $query->getAttribute();
+                    $countSelections[] = "COUNT(\"{$attribute}\") as \"{$attribute}\"";
+                }
+                return "SELECT " . implode(', ', $countSelections) . " FROM ({$sql}) table_count;";
+            case Query::TYPE_SUM:
+                $selections = $this->getAttributeSums($aggregateQueries, $aggregateType);
+                return "SELECT {$this->getSumQueries($selections)} FROM ({$sql}) table_sum;";
+            default:
+                throw new DatabaseException('Unknown aggregate type: ' . $aggregateType);
+        }
+    }
+
     /**
      * @return string
      */

src/Database/Adapter/SQL.php

@@ -402,6 +402,16 @@ public function getSupportForGetConnectionId(): bool
         return true;
     }
 
+    /**
+     * Are aggregate queries supported?
+     *
+     * @return bool
+     */
+    public function getSupportForAggregateQueries(): bool
+    {
+        return true;
+    }
+
     /**
      * Get current attribute count from collection document
      *
@@ -1134,7 +1144,7 @@ public function getSQLConditions(array $queries = [], string $separator = 'AND')
         $conditions = [];
         foreach ($queries as $query) {
 
-            if ($query->getMethod() === Query::TYPE_SELECT || $query->getMethod() === Query::TYPE_SUM) {
+            if ($query->getMethod() === Query::TYPE_SELECT || in_array($query->getMethod(), Query::AGGREGATE_TYPES)) {
                 continue;
             }
 

src/Database/Query.php

@@ -25,6 +25,9 @@ class Query
     public const TYPE_SELECT = 'select';
     public const TYPE_SUM = 'sum';
 
+    // Aggregate methods
+    public const TYPE_COUNT = 'count';
+
     // Order methods
     public const TYPE_ORDER_DESC = 'orderDesc';
     public const TYPE_ORDER_ASC = 'orderAsc';
@@ -63,13 +66,19 @@ class Query
         self::TYPE_CURSOR_BEFORE,
         self::TYPE_AND,
         self::TYPE_OR,
+        self::TYPE_COUNT,
     ];
 
     protected const LOGICAL_TYPES = [
         self::TYPE_AND,
         self::TYPE_OR,
     ];
 
+    public const AGGREGATE_TYPES = [
+        self::TYPE_COUNT,
+        self::TYPE_SUM,
+    ];
+
     protected string $method = '';
     protected string $attribute = '';
     protected bool $onArray = false;
@@ -217,6 +226,7 @@ public static function isMethod(string $value): bool
             self::TYPE_OR,
             self::TYPE_AND,
             self::TYPE_SUM,
+            self::TYPE_COUNT,
             self::TYPE_SELECT => true,
             default => false,
         };
@@ -571,6 +581,17 @@ public static function endsWith(string $attribute, string $value): self
         return new self(self::TYPE_ENDS_WITH, $attribute, [$value]);
     }
 
+    /**
+     * Helper method to create Query with sum method
+     *
+     * @param string $attribute
+     * @return Query
+     */
+    public static function count(string $attribute): self
+    {
+        return new self(self::TYPE_COUNT, $attribute);
+    }
+
     /**
      * @param array<Query> $queries
      * @return Query

src/Database/Validator/Queries.php

@@ -83,6 +83,20 @@ public function isValid($value): bool
                 }
             }
 
+            $methodsUsed = array_map(
+                fn (Query|string $query) => $query instanceof Query ? $query->getMethod() : $query,
+                $value
+            );
+
+            $methodsUsed = array_unique($methodsUsed);
+            $aggregateMethods = array_intersect($methodsUsed, Query::AGGREGATE_TYPES);
+
+            // Check if multiple aggregate methods are used
+            if (count($aggregateMethods) > 1) {
+                $this->message = 'Invalid query: Multiple types of aggregate methods are not supported';
+                return false;
+            }
+
             if ($query->isNested()) {
                 if (!self::isValid($query->getValues())) {
                     return false;
@@ -95,6 +109,7 @@ public function isValid($value): bool
                 Query::TYPE_SUM => Base::METHOD_TYPE_SUM,
                 Query::TYPE_LIMIT => Base::METHOD_TYPE_LIMIT,
                 Query::TYPE_OFFSET => Base::METHOD_TYPE_OFFSET,
+                Query::TYPE_COUNT => Base::METHOD_TYPE_COUNT,
                 Query::TYPE_CURSOR_AFTER,
                 Query::TYPE_CURSOR_BEFORE => Base::METHOD_TYPE_CURSOR,
                 Query::TYPE_ORDER_ASC,

src/Database/Validator/Queries/Documents.php

@@ -6,6 +6,7 @@
 use Utopia\Database\Database;
 use Utopia\Database\Document;
 use Utopia\Database\Validator\IndexedQueries;
+use Utopia\Database\Validator\Query\Count;
 use Utopia\Database\Validator\Query\Cursor;
 use Utopia\Database\Validator\Query\Filter;
 use Utopia\Database\Validator\Query\Limit;
@@ -68,6 +69,7 @@ public function __construct(
             new Order($attributes),
             new Select($attributes),
             new Sum($attributes),
+            new Count($attributes),
         ];
 
         parent::__construct($attributes, $indexes, $validators);

src/Database/Validator/Query/Base.php

@@ -13,6 +13,8 @@ abstract class Base extends Validator
     public const METHOD_TYPE_FILTER = 'filter';
     public const METHOD_TYPE_SELECT = 'select';
     public const METHOD_TYPE_SUM = 'sum';
+    public const METHOD_TYPE_COUNT = 'count';
+
 
     protected string $message = 'Invalid query';