diff --git a/src/Eloquent/Builder.php b/src/Eloquent/Builder.php
index afe968e4b..dce0d8274 100644
--- a/src/Eloquent/Builder.php
+++ b/src/Eloquent/Builder.php
@@ -7,23 +7,37 @@
use Illuminate\Database\Eloquent\Builder as EloquentBuilder;
use Illuminate\Database\Eloquent\Collection;
use Illuminate\Database\Eloquent\Model;
+use Illuminate\Database\Eloquent\Relations\Relation;
+use Illuminate\Support\Str;
+use InvalidArgumentException;
use MongoDB\BSON\Document;
use MongoDB\Builder\Type\QueryInterface;
use MongoDB\Builder\Type\SearchOperatorInterface;
use MongoDB\Driver\CursorInterface;
use MongoDB\Driver\Exception\WriteException;
use MongoDB\Laravel\Connection;
+use MongoDB\Laravel\Eloquent\Model as DocumentModel;
use MongoDB\Laravel\Helpers\QueriesRelationships;
use MongoDB\Laravel\Query\AggregationBuilder;
+use MongoDB\Laravel\Relations\EmbedsOneOrMany;
+use MongoDB\Laravel\Relations\HasMany;
use MongoDB\Model\BSONDocument;
+use RuntimeException;
+use TypeError;
use function array_key_exists;
use function array_merge;
+use function assert;
use function collect;
+use function count;
+use function explode;
+use function get_debug_type;
use function is_array;
use function is_object;
+use function is_string;
use function iterator_to_array;
use function property_exists;
+use function sprintf;
/**
* @method \MongoDB\Laravel\Query\Builder toBase()
@@ -34,6 +48,13 @@ class Builder extends EloquentBuilder
private const DUPLICATE_KEY_ERROR = 11000;
use QueriesRelationships;
+ /**
+ * List of aggregations on the related models after the main query.
+ *
+ * @var array{relation: Relation, function: string, constraints: array, column: string, alias: string}[]
+ */
+ private array $withAggregate = [];
+
/**
* The methods that should be returned from query builder.
*
@@ -294,6 +315,112 @@ public function createOrFirst(array $attributes = [], array $values = [])
}
}
+ /**
+ * Add subsequent queries to include an aggregate value for a relationship.
+ * For embedded relations, a projection is used to calculate the aggregate.
+ *
+ * @see \Illuminate\Database\Eloquent\Concerns\QueriesRelationships::withAggregate()
+ *
+ * @param mixed $relations Name of the relationship or an array of relationships to closure for constraint
+ * @param string $column Name of the field to aggregate
+ * @param string $function Required aggregation function name (count, min, max, avg)
+ *
+ * @return $this
+ */
+ public function withAggregate($relations, $column, $function = null)
+ {
+ if (empty($relations)) {
+ return $this;
+ }
+
+ assert(is_string($function), new TypeError('Argument 3 ($function) passed to withAggregate must be of the type string, ' . get_debug_type($function) . ' given'));
+
+ $relations = is_array($relations) ? $relations : [$relations];
+
+ foreach ($this->parseWithRelations($relations) as $name => $constraints) {
+ $segments = explode(' ', $name);
+
+ $alias = match (true) {
+ count($segments) === 1 => Str::snake($segments[0]) . '_' . $function,
+ count($segments) === 3 && Str::lower($segments[1]) === 'as' => $segments[2],
+ default => throw new InvalidArgumentException(sprintf('Invalid relation name format. Expected "relation as alias" or "relation", got "%s"', $name)),
+ };
+ $name = $segments[0];
+
+ $relation = $this->getRelationWithoutConstraints($name);
+
+ if (! DocumentModel::isDocumentModel($relation->getRelated())) {
+ throw new InvalidArgumentException('WithAggregate does not support hybrid relations');
+ }
+
+ if ($relation instanceof EmbedsOneOrMany) {
+ $subQuery = $this->newQuery();
+ $constraints($subQuery);
+ if ($subQuery->getQuery()->wheres) {
+ // @see https://jira.mongodb.org/browse/PHPORM-292
+ throw new InvalidArgumentException('Constraints are not supported for embedded relations');
+ }
+
+ switch ($function) {
+ case 'count':
+ $this->getQuery()->project([$alias => ['$size' => ['$ifNull' => ['$' . $name, []]]]]);
+ break;
+ case 'min':
+ case 'max':
+ case 'avg':
+ $this->getQuery()->project([$alias => ['$' . $function => '$' . $name . '.' . $column]]);
+ break;
+ default:
+ throw new InvalidArgumentException(sprintf('Invalid aggregate function "%s"', $function));
+ }
+ } else {
+ // The aggregation will be performed after the main query, during eager loading.
+ $this->withAggregate[$alias] = [
+ 'relation' => $relation,
+ 'function' => $function,
+ 'constraints' => $constraints,
+ 'column' => $column,
+ 'alias' => $alias,
+ ];
+ }
+ }
+
+ return $this;
+ }
+
+ public function eagerLoadRelations(array $models)
+ {
+ if ($this->withAggregate) {
+ $modelIds = collect($models)->pluck($this->model->getKeyName())->all();
+
+ foreach ($this->withAggregate as $withAggregate) {
+ if ($withAggregate['relation'] instanceof HasMany) {
+ $results = $withAggregate['relation']->newQuery()
+ ->where($withAggregate['constraints'])
+ ->whereIn($withAggregate['relation']->getForeignKeyName(), $modelIds)
+ ->groupBy($withAggregate['relation']->getForeignKeyName())
+ ->aggregate($withAggregate['function'], [$withAggregate['column']]);
+
+ foreach ($models as $model) {
+ $value = $withAggregate['function'] === 'count' ? 0 : null;
+ foreach ($results as $result) {
+ if ($model->getKey() === $result->{$withAggregate['relation']->getForeignKeyName()}) {
+ $value = $result->aggregate;
+ break;
+ }
+ }
+
+ $model->setAttribute($withAggregate['alias'], $value);
+ }
+ } else {
+ throw new RuntimeException(sprintf('Unsupported relation type for aggregation: %s', $withAggregate['relation']::class));
+ }
+ }
+ }
+
+ return parent::eagerLoadRelations($models);
+ }
+
/**
* Add the "updated at" column to an array of values.
* TODO Remove if https://github.com/laravel/framework/commit/6484744326531829341e1ff886cc9b628b20d73e
diff --git a/src/Query/Builder.php b/src/Query/Builder.php
index 4c7c8513f..190d22671 100644
--- a/src/Query/Builder.php
+++ b/src/Query/Builder.php
@@ -357,7 +357,7 @@ public function toMql(): array
$aggregations = blank($this->aggregate['columns']) ? [] : $this->aggregate['columns'];
- if ($column === '*' && $function === 'count' && ! $this->groups) {
+ if (in_array('*', $aggregations) && $function === 'count' && empty($group['_id'])) {
$options = $this->inheritConnectionOptions($this->options);
return ['countDocuments' => [$wheres, $options]];
@@ -611,7 +611,7 @@ public function aggregate($function = null, $columns = ['*'])
$this->bindings['select'] = [];
- $results = $this->get($columns);
+ $results = $this->get();
// Once we have executed the query, we will reset the aggregate property so
// that more select queries can be executed against the database without
@@ -650,6 +650,14 @@ public function aggregateByGroup(string $function, array $columns = ['*'])
return $this->aggregate($function, $columns);
}
+ public function count($columns = '*')
+ {
+ // Can be removed when available in Laravel: https://github.com/laravel/framework/pull/53209
+ $results = $this->aggregate(__FUNCTION__, Arr::wrap($columns));
+
+ return $results instanceof Collection ? $results : (int) $results;
+ }
+
/** @inheritdoc */
public function exists()
{
diff --git a/tests/Eloquent/EloquentWithAggregateTest.php b/tests/Eloquent/EloquentWithAggregateTest.php
new file mode 100644
index 000000000..749b68f05
--- /dev/null
+++ b/tests/Eloquent/EloquentWithAggregateTest.php
@@ -0,0 +1,298 @@
+<?php
+
+namespace MongoDB\Laravel\Tests\Eloquent;
+
+use Illuminate\Database\Eloquent\Builder;
+use Illuminate\Support\Collection;
+use Illuminate\Support\Facades\DB;
+use InvalidArgumentException;
+use MongoDB\Laravel\Tests\Eloquent\Models\EloquentWithAggregateModel1;
+use MongoDB\Laravel\Tests\Eloquent\Models\EloquentWithAggregateModel2;
+use MongoDB\Laravel\Tests\Eloquent\Models\EloquentWithAggregateModel3;
+use MongoDB\Laravel\Tests\Eloquent\Models\EloquentWithAggregateModel4;
+use MongoDB\Laravel\Tests\TestCase;
+use PHPUnit\Framework\Attributes\TestWith;
+
+use function count;
+use function ksort;
+
+class EloquentWithAggregateTest extends TestCase
+{
+ protected function tearDown(): void
+ {
+ EloquentWithAggregateModel1::truncate();
+ EloquentWithAggregateModel2::truncate();
+ EloquentWithAggregateModel3::truncate();
+ EloquentWithAggregateModel4::truncate();
+
+ parent::tearDown();
+ }
+
+ public function testWithAggregate()
+ {
+ EloquentWithAggregateModel1::create(['id' => 1]);
+ $one = EloquentWithAggregateModel1::create(['id' => 2]);
+ $one->twos()->create(['value' => 4]);
+ $one->twos()->create(['value' => 6]);
+
+ $results = EloquentWithAggregateModel1::withCount('twos')->where('id', 2);
+ self::assertSameResults([
+ ['id' => 2, 'twos_count' => 2],
+ ], $results->get());
+
+ $results = EloquentWithAggregateModel1::withMax('twos', 'value')->where('id', 2);
+ self::assertSameResults([
+ ['id' => 2, 'twos_max' => 6],
+ ], $results->get());
+
+ $results = EloquentWithAggregateModel1::withMin('twos', 'value')->where('id', 2);
+ self::assertSameResults([
+ ['id' => 2, 'twos_min' => 4],
+ ], $results->get());
+
+ $results = EloquentWithAggregateModel1::withAvg('twos', 'value')->where('id', 2);
+ self::assertSameResults([
+ ['id' => 2, 'twos_avg' => 5.0],
+ ], $results->get());
+ }
+
+ public function testWithAggregateAlias()
+ {
+ EloquentWithAggregateModel1::create(['id' => 1]);
+ $one = EloquentWithAggregateModel1::create(['id' => 2]);
+ $one->twos()->create(['value' => 4]);
+ $one->twos()->create(['value' => 6]);
+
+ $results = EloquentWithAggregateModel1::withCount('twos as result')->where('id', 2);
+ self::assertSameResults([
+ ['id' => 2, 'result' => 2],
+ ], $results->get());
+
+ $results = EloquentWithAggregateModel1::withMax('twos as result', 'value')->where('id', 2);
+ self::assertSameResults([
+ ['id' => 2, 'result' => 6],
+ ], $results->get());
+
+ $results = EloquentWithAggregateModel1::withMin('twos as result', 'value')->where('id', 2);
+ self::assertSameResults([
+ ['id' => 2, 'result' => 4],
+ ], $results->get());
+
+ $results = EloquentWithAggregateModel1::withAvg('twos as result', 'value')->where('id', 2);
+ self::assertSameResults([
+ ['id' => 2, 'result' => 5.0],
+ ], $results->get());
+ }
+
+ #[TestWith(['withCount'])]
+ #[TestWith(['withMax'])]
+ #[TestWith(['withMin'])]
+ #[TestWith(['withAvg'])]
+ public function testWithAggregateInvalidAlias(string $method)
+ {
+ self::expectException(InvalidArgumentException::class);
+ self::expectExceptionMessage('Expected "relation as alias" or "relation", got "twos foo result"');
+ EloquentWithAggregateModel1::{$method}('twos foo result', 'value')->get();
+ }
+
+ public function testWithAggregateEmbed()
+ {
+ EloquentWithAggregateModel1::create(['id' => 1]);
+ $one = EloquentWithAggregateModel1::create(['id' => 2]);
+ $one->embeddeds()->create(['value' => 4]);
+ $one->embeddeds()->create(['value' => 6]);
+
+ $results = EloquentWithAggregateModel1::withCount('embeddeds')->select('id')->where('id', 2);
+ self::assertSameResults([
+ ['id' => 2, 'embeddeds_count' => 2],
+ ], $results->get());
+
+ $results = EloquentWithAggregateModel1::withMax('embeddeds', 'value')->select('id')->where('id', 2);
+ self::assertSameResults([
+ ['id' => 2, 'embeddeds_max' => 6],
+ ], $results->get());
+
+ $results = EloquentWithAggregateModel1::withMin('embeddeds', 'value')->select('id')->where('id', 2);
+ self::assertSameResults([
+ ['id' => 2, 'embeddeds_min' => 4],
+ ], $results->get());
+
+ $results = EloquentWithAggregateModel1::withAvg('embeddeds', 'value')->select('id')->where('id', 2);
+ self::assertSameResults([
+ ['id' => 2, 'embeddeds_avg' => 5.0],
+ ], $results->get());
+ }
+
+ public function testWithAggregateFiltered()
+ {
+ EloquentWithAggregateModel1::create(['id' => 1]);
+ $one = EloquentWithAggregateModel1::create(['id' => 2]);
+ $one->twos()->create(['value' => 4]);
+ $one->twos()->create(['value' => 6]);
+ $one->twos()->create(['value' => 8]);
+ $filter = static function (Builder $query) {
+ $query->where('value', '<=', 6);
+ };
+
+ $results = EloquentWithAggregateModel1::withCount(['twos' => $filter])->where('id', 2);
+ self::assertSameResults([
+ ['id' => 2, 'twos_count' => 2],
+ ], $results->get());
+
+ $results = EloquentWithAggregateModel1::withMax(['twos' => $filter], 'value')->where('id', 2);
+ self::assertSameResults([
+ ['id' => 2, 'twos_max' => 6],
+ ], $results->get());
+
+ $results = EloquentWithAggregateModel1::withMin(['twos' => $filter], 'value')->where('id', 2);
+ self::assertSameResults([
+ ['id' => 2, 'twos_min' => 4],
+ ], $results->get());
+
+ $results = EloquentWithAggregateModel1::withAvg(['twos' => $filter], 'value')->where('id', 2);
+ self::assertSameResults([
+ ['id' => 2, 'twos_avg' => 5.0],
+ ], $results->get());
+ }
+
+ public function testWithAggregateEmbedFiltered()
+ {
+ EloquentWithAggregateModel1::create(['id' => 2]);
+ $filter = static function (Builder $query) {
+ $query->where('value', '<=', 6);
+ };
+
+ // @see https://jira.mongodb.org/browse/PHPORM-292
+ self::expectException(InvalidArgumentException::class);
+ self::expectExceptionMessage('Constraints are not supported for embedded relations');
+
+ EloquentWithAggregateModel1::withCount(['embeddeds' => $filter])->where('id', 2)->get();
+ }
+
+ public function testWithAggregateMultipleResults()
+ {
+ $connection = DB::connection('mongodb');
+ $ones = [
+ EloquentWithAggregateModel1::create(['id' => 1]),
+ EloquentWithAggregateModel1::create(['id' => 2]),
+ EloquentWithAggregateModel1::create(['id' => 3]),
+ EloquentWithAggregateModel1::create(['id' => 4]),
+ ];
+
+ $ones[0]->twos()->create(['value' => 1]);
+ $ones[0]->twos()->create(['value' => 2]);
+ $ones[0]->twos()->create(['value' => 3]);
+ $ones[0]->twos()->create(['value' => 1]);
+ $ones[2]->twos()->create(['value' => 1]);
+ $ones[2]->twos()->create(['value' => 2]);
+
+ $connection->enableQueryLog();
+
+ // Count
+ $results = EloquentWithAggregateModel1::withCount([
+ 'twos' => function ($query) {
+ $query->where('value', '>=', 2);
+ },
+ ]);
+
+ self::assertSameResults([
+ ['id' => 1, 'twos_count' => 2],
+ ['id' => 2, 'twos_count' => 0],
+ ['id' => 3, 'twos_count' => 1],
+ ['id' => 4, 'twos_count' => 0],
+ ], $results->get());
+
+ // Only 2 queries should be executed: the main query and the aggregate grouped by foreign id
+ self::assertSame(2, count($connection->getQueryLog()));
+ $connection->flushQueryLog();
+
+ // Max
+ $results = EloquentWithAggregateModel1::withMax([
+ 'twos' => function ($query) {
+ $query->where('value', '>=', 2);
+ },
+ ], 'value');
+
+ self::assertSameResults([
+ ['id' => 1, 'twos_max' => 3],
+ ['id' => 2, 'twos_max' => null],
+ ['id' => 3, 'twos_max' => 2],
+ ['id' => 4, 'twos_max' => null],
+ ], $results->get());
+
+ self::assertSame(2, count($connection->getQueryLog()));
+ $connection->flushQueryLog();
+
+ // Min
+ $results = EloquentWithAggregateModel1::withMin([
+ 'twos' => function ($query) {
+ $query->where('value', '>=', 2);
+ },
+ ], 'value');
+
+ self::assertSameResults([
+ ['id' => 1, 'twos_min' => 2],
+ ['id' => 2, 'twos_min' => null],
+ ['id' => 3, 'twos_min' => 2],
+ ['id' => 4, 'twos_min' => null],
+ ], $results->get());
+
+ self::assertSame(2, count($connection->getQueryLog()));
+ $connection->flushQueryLog();
+
+ // Avg
+ $results = EloquentWithAggregateModel1::withAvg([
+ 'twos' => function ($query) {
+ $query->where('value', '>=', 2);
+ },
+ ], 'value');
+
+ self::assertSameResults([
+ ['id' => 1, 'twos_avg' => 2.5],
+ ['id' => 2, 'twos_avg' => null],
+ ['id' => 3, 'twos_avg' => 2.0],
+ ['id' => 4, 'twos_avg' => null],
+ ], $results->get());
+
+ self::assertSame(2, count($connection->getQueryLog()));
+ $connection->flushQueryLog();
+ }
+
+ public function testGlobalScopes()
+ {
+ $one = EloquentWithAggregateModel1::create();
+ $one->fours()->create();
+
+ $result = EloquentWithAggregateModel1::withCount('fours')->first();
+ self::assertSame(0, $result->fours_count);
+
+ $result = EloquentWithAggregateModel1::withCount('allFours')->first();
+ self::assertSame(1, $result->all_fours_count);
+ }
+
+ public function testHybridNotSupported()
+ {
+ EloquentWithAggregateModel1::create(['id' => 2]);
+
+ // @see https://jira.mongodb.org/browse/PHPORM-292
+ self::expectException(InvalidArgumentException::class);
+ self::expectExceptionMessage('WithAggregate does not support hybrid relations');
+
+ EloquentWithAggregateModel1::withCount('hybrids')->where('id', 2)->get();
+ }
+
+ private static function assertSameResults(array $expected, Collection $collection)
+ {
+ $actual = $collection->toArray();
+
+ foreach ($actual as &$item) {
+ ksort($item);
+ }
+
+ foreach ($expected as &$item) {
+ ksort($item);
+ }
+
+ self::assertSame($expected, $actual);
+ }
+}
diff --git a/tests/Eloquent/Models/EloquentWithAggregateEmbeddedModel.php b/tests/Eloquent/Models/EloquentWithAggregateEmbeddedModel.php
new file mode 100644
index 000000000..609c078b2
--- /dev/null
+++ b/tests/Eloquent/Models/EloquentWithAggregateEmbeddedModel.php
@@ -0,0 +1,12 @@
+<?php
+
+namespace MongoDB\Laravel\Tests\Eloquent\Models;
+
+use MongoDB\Laravel\Eloquent\Model;
+
+class EloquentWithAggregateEmbeddedModel extends Model
+{
+ protected $connection = 'mongodb';
+ public $timestamps = false;
+ protected $guarded = [];
+}
diff --git a/tests/Eloquent/Models/EloquentWithAggregateHybridModel.php b/tests/Eloquent/Models/EloquentWithAggregateHybridModel.php
new file mode 100644
index 000000000..a8b31fe0b
--- /dev/null
+++ b/tests/Eloquent/Models/EloquentWithAggregateHybridModel.php
@@ -0,0 +1,13 @@
+<?php
+
+namespace MongoDB\Laravel\Tests\Eloquent\Models;
+
+use Illuminate\Database\Eloquent\Model;
+
+class EloquentWithAggregateHybridModel extends Model
+{
+ protected $connection = 'sqlite';
+ public $table = 'hybrid';
+ public $timestamps = false;
+ protected $guarded = [];
+}
diff --git a/tests/Eloquent/Models/EloquentWithAggregateModel1.php b/tests/Eloquent/Models/EloquentWithAggregateModel1.php
new file mode 100644
index 000000000..a028eebe2
--- /dev/null
+++ b/tests/Eloquent/Models/EloquentWithAggregateModel1.php
@@ -0,0 +1,38 @@
+<?php
+
+namespace MongoDB\Laravel\Tests\Eloquent\Models;
+
+use MongoDB\Laravel\Eloquent\Model;
+
+class EloquentWithAggregateModel1 extends Model
+{
+ protected $connection = 'mongodb';
+ public $table = 'one';
+ public $timestamps = false;
+ protected $guarded = [];
+
+ public function twos()
+ {
+ return $this->hasMany(EloquentWithAggregateModel2::class, 'one_id');
+ }
+
+ public function fours()
+ {
+ return $this->hasMany(EloquentWithAggregateModel4::class, 'one_id');
+ }
+
+ public function allFours()
+ {
+ return $this->fours()->withoutGlobalScopes();
+ }
+
+ public function embeddeds()
+ {
+ return $this->embedsMany(EloquentWithAggregateEmbeddedModel::class);
+ }
+
+ public function hybrids()
+ {
+ return $this->hasMany(EloquentWithAggregateHybridModel::class, 'one_id');
+ }
+}
diff --git a/tests/Eloquent/Models/EloquentWithAggregateModel2.php b/tests/Eloquent/Models/EloquentWithAggregateModel2.php
new file mode 100644
index 000000000..3d72fd922
--- /dev/null
+++ b/tests/Eloquent/Models/EloquentWithAggregateModel2.php
@@ -0,0 +1,28 @@
+<?php
+
+namespace MongoDB\Laravel\Tests\Eloquent\Models;
+
+use MongoDB\Laravel\Eloquent\Model;
+
+class EloquentWithAggregateModel2 extends Model
+{
+ protected $connection = 'mongodb';
+ public $table = 'two';
+ public $timestamps = false;
+ protected $guarded = [];
+ protected $withCount = ['threes'];
+
+ protected static function boot()
+ {
+ parent::boot();
+
+ static::addGlobalScope('app', function ($builder) {
+ $builder->latest();
+ });
+ }
+
+ public function threes()
+ {
+ return $this->hasMany(EloquentWithAggregateModel3::class, 'two_id');
+ }
+}
diff --git a/tests/Eloquent/Models/EloquentWithAggregateModel3.php b/tests/Eloquent/Models/EloquentWithAggregateModel3.php
new file mode 100644
index 000000000..da649065f
--- /dev/null
+++ b/tests/Eloquent/Models/EloquentWithAggregateModel3.php
@@ -0,0 +1,22 @@
+<?php
+
+namespace MongoDB\Laravel\Tests\Eloquent\Models;
+
+use MongoDB\Laravel\Eloquent\Model;
+
+class EloquentWithAggregateModel3 extends Model
+{
+ protected $connection = 'mongodb';
+ public $table = 'three';
+ public $timestamps = false;
+ protected $guarded = [];
+
+ protected static function boot()
+ {
+ parent::boot();
+
+ static::addGlobalScope('app', function ($builder) {
+ $builder->where('id', '>', 0);
+ });
+ }
+}
diff --git a/tests/Eloquent/Models/EloquentWithAggregateModel4.php b/tests/Eloquent/Models/EloquentWithAggregateModel4.php
new file mode 100644
index 000000000..75ae296a4
--- /dev/null
+++ b/tests/Eloquent/Models/EloquentWithAggregateModel4.php
@@ -0,0 +1,22 @@
+<?php
+
+namespace MongoDB\Laravel\Tests\Eloquent\Models;
+
+use MongoDB\Laravel\Eloquent\Model;
+
+class EloquentWithAggregateModel4 extends Model
+{
+ protected $connection = 'mongodb';
+ public $table = 'four';
+ public $timestamps = false;
+ protected $guarded = [];
+
+ protected static function boot()
+ {
+ parent::boot();
+
+ static::addGlobalScope('app', function ($builder) {
+ $builder->where('id', '>', 1);
+ });
+ }
+}
diff --git a/tests/QueryBuilderTest.php b/tests/QueryBuilderTest.php
index 01f937915..b4f4f2d16 100644
--- a/tests/QueryBuilderTest.php
+++ b/tests/QueryBuilderTest.php
@@ -41,6 +41,7 @@ class QueryBuilderTest extends TestCase
{
public function tearDown(): void
{
+ DB::table('books')->truncate();
DB::table('users')->truncate();
DB::table('items')->truncate();
}
@@ -1155,4 +1156,37 @@ public function testIdAlias($insertId, $queryId): void
$result = DB::table('items')->where($queryId, '=', 'abc')->delete();
$this->assertSame(1, $result);
}
+
+ public function testAggregateFunctionsWithGroupBy()
+ {
+ DB::table('users')->insert([
+ ['name' => 'John Doe', 'role' => 'admin', 'score' => 1],
+ ['name' => 'Jane Doe', 'role' => 'admin', 'score' => 2],
+ ['name' => 'Robert Roe', 'role' => 'user', 'score' => 4],
+ ]);
+
+ $results = DB::table('users')->groupBy('role')->orderBy('role')->count();
+ $this->assertInstanceOf(LaravelCollection::class, $results);
+ $this->assertEquals([(object) ['role' => 'admin', 'aggregate' => 2], (object) ['role' => 'user', 'aggregate' => 1]], $results->toArray());
+
+ $results = DB::table('users')->groupBy('role')->orderBy('role')->max('score');
+ $this->assertInstanceOf(LaravelCollection::class, $results);
+ $this->assertEquals([(object) ['role' => 'admin', 'aggregate' => 2], (object) ['role' => 'user', 'aggregate' => 4]], $results->toArray());
+
+ $results = DB::table('users')->groupBy('role')->orderBy('role')->min('score');
+ $this->assertInstanceOf(LaravelCollection::class, $results);
+ $this->assertEquals([(object) ['role' => 'admin', 'aggregate' => 1], (object) ['role' => 'user', 'aggregate' => 4]], $results->toArray());
+
+ $results = DB::table('users')->groupBy('role')->orderBy('role')->sum('score');
+ $this->assertInstanceOf(LaravelCollection::class, $results);
+ $this->assertEquals([(object) ['role' => 'admin', 'aggregate' => 3], (object) ['role' => 'user', 'aggregate' => 4]], $results->toArray());
+
+ $results = DB::table('users')->groupBy('role')->orderBy('role')->avg('score');
+ $this->assertInstanceOf(LaravelCollection::class, $results);
+ $this->assertEquals([(object) ['role' => 'admin', 'aggregate' => 1.5], (object) ['role' => 'user', 'aggregate' => 4]], $results->toArray());
+
+ $results = DB::table('users')->groupBy('role')->orderBy('role')->average('score');
+ $this->assertInstanceOf(LaravelCollection::class, $results);
+ $this->assertEquals([(object) ['role' => 'admin', 'aggregate' => 1.5], (object) ['role' => 'user', 'aggregate' => 4]], $results->toArray());
+ }
}