Adds support for counting DISTINCT

Author: erikaraujo

src/Tempest/Database/src/Builder/QueryBuilders/CountQueryBuilder.php

@@ -6,6 +6,7 @@
 
 use Tempest\Database\Builder\ModelDefinition;
 use Tempest\Database\Builder\TableDefinition;
+use Tempest\Database\Exceptions\CannotCountDistinctWithoutSpecifyingAColumn;
 use Tempest\Database\Query;
 use Tempest\Database\QueryStatements\CountStatement;
 use Tempest\Database\QueryStatements\WhereStatement;
@@ -47,6 +48,18 @@ public function as(string $alias): self
         return $this;
     }
 
+    /** @return self<TModelClass> */
+    public function distinct(): self
+    {
+        if ($this->count->column === null || $this->count->column === '*') {
+            throw new CannotCountDistinctWithoutSpecifyingAColumn();
+        }
+
+        $this->count->distinct = true;
+
+        return $this;
+    }
+
     /** @return self<TModelClass> */
     public function where(string $where, mixed ...$bindings): self
     {

src/Tempest/Database/src/Exceptions/CannotCountDistinctWithoutSpecifyingAColumn.php

@@ -0,0 +1,13 @@
+<?php
+
+namespace Tempest\Database\Exceptions;
+
+use LogicException;
+
+final class CannotCountDistinctWithoutSpecifyingAColumn extends LogicException
+{
+    public function __construct()
+    {
+        parent::__construct('Cannot count distinct without specifying a column');
+    }
+}

src/Tempest/Database/src/QueryStatements/CountStatement.php

@@ -11,26 +11,22 @@
 
 final class CountStatement implements QueryStatement
 {
-    public readonly string $countArgument;
-
     public ?string $alias = null;
 
+    public bool $distinct = false;
+
     public function __construct(
         public readonly TableDefinition $table,
         public ?string $column = null,
         public ImmutableArray $where = new ImmutableArray(),
-    ) {
-        $this->countArgument = $this->column === null
-            ? '*'
-            : "`{$this->column}`";
-    }
+    ) {}
 
     public function compile(DatabaseDialect $dialect): string
     {
         $query = arr([
             sprintf(
                 'SELECT COUNT(%s)%s',
-                $this->countArgument,
+                $this->getCountArgument(),
                 $this->alias ? " AS `{$this->alias}`" : '',
             ),
             sprintf('FROM `%s`', $this->table->name),
@@ -45,12 +41,23 @@ public function compile(DatabaseDialect $dialect): string
         return $query->implode(PHP_EOL);
     }
 
+    public function getCountArgument(): string
+    {
+        return $this->column === null || $this->column === '*'
+            ? '*'
+            : sprintf(
+                '%s`%s`',
+                $this->distinct ? 'DISTINCT ' : '',
+                $this->column,
+            );
+    }
+
     public function getKey(): string
     {
         if ($this->alias !== null) {
             return $this->alias;
         }
 
-        return "COUNT({$this->countArgument})";
+        return "COUNT({$this->getCountArgument()})";
     }
 }

tests/Integration/Database/Builder/CountQueryBuilderTest.php

@@ -5,6 +5,7 @@
 namespace Tests\Tempest\Integration\Database\Builder;
 
 use Tempest\Database\Builder\QueryBuilders\CountQueryBuilder;
+use Tempest\Database\Exceptions\CannotCountDistinctWithoutSpecifyingAColumn;
 use Tests\Tempest\Fixtures\Modules\Books\Models\Author;
 use Tests\Tempest\Integration\FrameworkIntegrationTestCase;
 
@@ -64,6 +65,22 @@ public function test_count_query_with_alias(): void
         $this->assertSame(['Timeline Taxi', '1', '2025-01-01'], $bindings);
     }
 
+    public function test_count_query_with_specified_asterisk(): void
+    {
+        $query = query('chapters')
+            ->count('*')
+            ->build();
+
+        $sql = $query->getSql();
+
+        $expected = <<<SQL
+        SELECT COUNT(*)
+        FROM `chapters`
+        SQL;
+
+        $this->assertSame($expected, $sql);
+    }
+
     public function test_count_query_with_specified_field(): void
     {
         $query = query('chapters')->count('title')->build();
@@ -78,6 +95,78 @@ public function test_count_query_with_specified_field(): void
         $this->assertSame($expected, $sql);
     }
 
+    public function test_count_query_with_specified_field_and_alias(): void
+    {
+        $query = query('chapters')
+            ->count('title')
+            ->as('total')
+            ->build();
+
+        $sql = $query->getSql();
+
+        $expected = <<<SQL
+        SELECT COUNT(`title`) AS `total`
+        FROM `chapters`
+        SQL;
+
+        $this->assertSame($expected, $sql);
+    }
+
+    public function test_count_query_without_specifying_column_cannot_be_distinct(): void
+    {
+        $this->expectException(CannotCountDistinctWithoutSpecifyingAColumn::class);
+
+        query('chapters')
+            ->count()
+            ->distinct()
+            ->build();
+    }
+
+    public function test_count_query_with_specified_asterisk_cannot_be_distinct(): void
+    {
+        $this->expectException(CannotCountDistinctWithoutSpecifyingAColumn::class);
+
+        query('chapters')
+            ->count('*')
+            ->distinct()
+            ->build();
+    }
+
+    public function test_count_query_with_distinct_specified_field(): void
+    {
+        $query = query('chapters')
+            ->count('title')
+            ->distinct()
+            ->build();
+
+        $sql = $query->getSql();
+
+        $expected = <<<SQL
+        SELECT COUNT(DISTINCT `title`)
+        FROM `chapters`
+        SQL;
+
+        $this->assertSame($expected, $sql);
+    }
+
+    public function test_count_query_with_distinct_specified_field_and_alias(): void
+    {
+        $query = query('chapters')
+            ->count('title')
+            ->as('total')
+            ->distinct()
+            ->build();
+
+        $sql = $query->getSql();
+
+        $expected = <<<SQL
+        SELECT COUNT(DISTINCT `title`) AS `total`
+        FROM `chapters`
+        SQL;
+
+        $this->assertSame($expected, $sql);
+    }
+
     public function test_count_from_model(): void
     {
         $query = query(Author::class)->count()->build();