PHPORM-238 Add support for withCount and other aggregations

src/Eloquent/Builder.php

@@ -7,6 +7,9 @@
 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;
@@ -15,15 +18,20 @@
 use MongoDB\Laravel\Connection;
 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 function array_key_exists;
 use function array_merge;
 use function collect;
+use function count;
+use function explode;
 use function is_array;
 use function is_object;
 use function iterator_to_array;
 use function property_exists;
+use function sprintf;
 
 /**
  * @method \MongoDB\Laravel\Query\Builder toBase()
@@ -34,6 +42,9 @@
     private const DUPLICATE_KEY_ERROR = 11000;
     use QueriesRelationships;
 
+    /** @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 +305,85 @@
         }
     }
 
+    public function withAggregate($relations, $column, $function = null)
+    {
+        if (empty($relations)) {
+            return $this;
+        }
+
+        $relations = is_array($relations) ? $relations : [$relations];
+
+        foreach ($this->parseWithRelations($relations) as $name => $constraints) {
+            // For "count" and "exist" we can use the embedded list of ids
+            // for embedded relations, everything can be computed directly using a projection.
+            $segments = explode(' ', $name);
+
+            $name = $segments[0];
+            $alias = (count($segments) === 3 && Str::lower($segments[1]) === 'as' ? $segments[2] : Str::snake($name) . '_count');
+
+            $relation = $this->getRelationWithoutConstraints($name);
+
+            if ($relation instanceof EmbedsOneOrMany) {
+                switch ($function) {
+                    case 'count':
+                        $this->project([$alias => ['$size' => ['$ifNull' => ['$' . $relation->getQualifiedForeignKeyName(), []]]]]);
+                        break;
+                    case 'exists':
+                        $this->project([$alias => ['$exists' => '$' . $relation->getQualifiedForeignKeyName()]]);
+                        break;
+                    default:
+                        throw new InvalidArgumentException(sprintf('Invalid aggregate function "%s"', $function));
+                }
+            } else {
+                $this->withAggregate[$alias] = [
+                    'relation' => $relation,
+                    'function' => $function,
+                    'constraints' => $constraints,
+                    'column' => $column,
+                    'alias' => $alias,
+                ];
+            }
+
+            // @todo HasMany ?
+
+            // Otherwise, we need to store the aggregate request to run during "eagerLoadRelation"
+            // after the root results are retrieved.
+        }
+
+        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);
+                    }
+                }
+            }
+        }
+
+        return parent::eagerLoadRelations($models);
+    }
+
     /**
      * Add the "updated at" column to an array of values.
      * TODO Remove if https://github.com/laravel/framework/commit/6484744326531829341e1ff886cc9b628b20d73e

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()
     {

tests/Eloquent/EloquentWithCountTest.php

@@ -0,0 +1,176 @@
+<?php
+
+namespace MongoDB\Laravel\Tests\Eloquent;
+
+use Illuminate\Support\Facades\DB;
+use MongoDB\Laravel\Eloquent\Model;
+use MongoDB\Laravel\Tests\TestCase;
+
+use function count;
+
+/** Copied from {@see \Illuminate\Tests\Integration\Database\EloquentWithCountTest\EloquentWithCountTest} */
+class EloquentWithCountTest extends TestCase
+{
+    protected function tearDown(): void
+    {
+        EloquentWithCountModel1::truncate();
+        EloquentWithCountModel2::truncate();
+        EloquentWithCountModel3::truncate();
+        EloquentWithCountModel4::truncate();
+
+        parent::tearDown();
+    }
+
+    public function testItBasic()
+    {
+        $one = EloquentWithCountModel1::create(['id' => 123]);
+        $two = $one->twos()->create(['value' => 456]);
+        $two->threes()->create();
+
+        $results = EloquentWithCountModel1::withCount([
+            'twos' => function ($query) {
+                $query->where('value', '>=', 456);
+            },
+        ]);
+
+        $this->assertEquals([
+            ['id' => 123, 'twos_count' => 1],
+        ], $results->get()->toArray());
+    }
+
+    public function testWithMultipleResults()
+    {
+        $connection = DB::connection('mongodb');
+        $ones = [
+            EloquentWithCountModel1::create(['id' => 1]),
+            EloquentWithCountModel1::create(['id' => 2]),
+            EloquentWithCountModel1::create(['id' => 3]),
+        ];
+
+        $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();
+        $results = EloquentWithCountModel1::withCount([
+            'twos' => function ($query) {
+                $query->where('value', '>=', 2);
+            },
+        ]);
+
+        $this->assertEquals([
+            ['id' => 1, 'twos_count' => 2],
+            ['id' => 2, 'twos_count' => 0],
+            ['id' => 3, 'twos_count' => 1],
+        ], $results->get()->toArray());
+
+        $connection->disableQueryLog();
+        $this->assertEquals(2, count($connection->getQueryLog()));
+    }
+
+    public function testGlobalScopes()
+    {
+        $one = EloquentWithCountModel1::create();
+        $one->fours()->create();
+
+        $result = EloquentWithCountModel1::withCount('fours')->first();
+        $this->assertEquals(0, $result->fours_count);
+
+        $result = EloquentWithCountModel1::withCount('allFours')->first();
+        $this->assertEquals(1, $result->all_fours_count);
+    }
+
+    public function testSortingScopes()
+    {
+        $one = EloquentWithCountModel1::create();
+        $one->twos()->create();
+
+        $query = EloquentWithCountModel1::withCount('twos')->getQuery();
+
+        $this->assertNull($query->orders);
+        $this->assertSame([], $query->getRawBindings()['order']);
+    }
+}
+
+class EloquentWithCountModel1 extends Model
+{
+    protected $connection = 'mongodb';
+    public $table = 'one';
+    public $timestamps = false;
+    protected $guarded = [];
+
+    public function twos()
+    {
+        return $this->hasMany(EloquentWithCountModel2::class, 'one_id');
+    }
+
+    public function fours()
+    {
+        return $this->hasMany(EloquentWithCountModel4::class, 'one_id');
+    }
+
+    public function allFours()
+    {
+        return $this->fours()->withoutGlobalScopes();
+    }
+}
+
+class EloquentWithCountModel2 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(EloquentWithCountModel3::class, 'two_id');
+    }
+}
+
+class EloquentWithCountModel3 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);
+        });
+    }
+}
+
+class EloquentWithCountModel4 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);
+        });
+    }
+}

tests/HybridRelationsTest.php

@@ -157,6 +157,7 @@ public function testHybridWhereHas()
 
     public function testHybridWith()
     {
+        DB::connection('mongodb')->enableQueryLog();
         $user      = new SqlUser();
         $otherUser = new SqlUser();
         $this->assertInstanceOf(SqlUser::class, $user);
@@ -206,6 +207,10 @@ public function testHybridWith()
             ->each(function ($user) {
                 $this->assertEquals($user->id, $user->books->count());
             });
+        //SqlUser::withCount('books')->get()
+        //    ->each(function ($user) {
+        //        $this->assertEquals($user->id, $user->books_count);
+        //    });
 
         SqlUser::whereHas('sqlBooks', function ($query) {
             return $query->where('title', 'LIKE', 'Harry%');