added methods loadOneLatest and loadOneOldest

Alexmg86 · Alexmg86 · commit ac281a16bbb1 · 2020-08-20T14:40:43.000+03:00
diff --git a/README.md b/README.md
@@ -9,7 +9,7 @@
 With standard use of Laravel, if you want the sum or find the maximum column value in the related model, you will have two database queries.  
 With this methods, it all turns into one query to the database and there is no need to load extra data.  
 It is also possible to sort by related models. And this sorting works with all types of relations.  
-Added ability to load relations with a limit for each model without multiple queries.  
+Added ability to load only one latest or oldest related model for each model without multiple queries.  
 I often use this in my work and I hope it will be useful to you!
 
 ## Say thank you
@@ -110,6 +110,23 @@ By default, sorting is by `max` and `desc`, you can choose one of the options `m
 $invoices = Invoice::orderByRelation('items:price', 'asc', 'sum')->get();
 ```
 
+### Load latest or oldest relation
+
+Imagine you want to get a list of 50 accounts, each with 100 items. By default, you will get 5000 positions and select the first ones for each account. PHP smokes nervously on the sidelines.  
+Wow! Now you can load only one latest or oldest related model:
+```php
+$invoices = Invoice::all();
+$invoices->loadOneLatest('items');
+$invoices->loadOneOldest('items');
+```
+or with conditions
+```php
+$invoices->loadOneLatest(['items' => function ($query) {
+    $query->orderBy('id', 'desc')->where('price', '<', 6);
+}]);
+```
+You can use this with relation types hasMany, belongsToMany and hasManyThrough.
+
 ### Limit relations
 
 If you want to load related model with limit, simply use the following method:
diff --git a/src/Collection/LaravelSubQueryCollection.php b/src/Collection/LaravelSubQueryCollection.php
@@ -2,6 +2,7 @@
 
 namespace Alexmg86\LaravelSubQuery\Collection;
 
+use Closure;
 use Illuminate\Database\Eloquent\Collection;
 use Illuminate\Support\Arr;
 
@@ -192,4 +193,41 @@ private function getLimits($relations)
         }
         return ['relations' => $relationsList, 'limits' => $limits];
     }
+
+    /**
+     * Load a set of relationship with limit one latest item onto the collection.
+     *
+     * @param  array|string  $relations
+     * @return $this
+     */
+    public function loadOneLatest($relations)
+    {
+        return $this->loadOne($relations);
+    }
+
+    /**
+     * Load a set of relationship with limit one oldest item onto the collection.
+     *
+     * @param  array|string  $relations
+     * @return $this
+     */
+    public function loadOneOldest($relations)
+    {
+        return $this->loadOne($relations, 'MIN');
+    }
+
+    private function loadOne($relations, $type = 'MAX')
+    {
+        if ($this->isNotEmpty()) {
+            if (is_string($relations)) {
+                $relations = func_get_args()[0];
+            }
+
+            $query = $this->first()->newQueryWithoutRelationships()->with($relations);
+
+            $this->items = $query->eagerLoadRelationsOne($this->items, $type);
+        }
+
+        return $this;
+    }
 }
diff --git a/src/LaravelSubQuery.php b/src/LaravelSubQuery.php
@@ -2,8 +2,12 @@
 
 namespace Alexmg86\LaravelSubQuery;
 
+use Closure;
 use Illuminate\Database\Eloquent\Builder;
 use Illuminate\Database\Eloquent\Concerns\QueriesRelationships;
+use Illuminate\Database\Eloquent\Relations\BelongsToMany;
+use Illuminate\Database\Eloquent\Relations\HasMany;
+use Illuminate\Database\Eloquent\Relations\HasManyThrough;
 use Illuminate\Database\Query\Expression;
 use Illuminate\Support\Str;
 
@@ -208,4 +212,80 @@ public function setWithAvg($withAvg)
     {
         return $this->withAvg($withAvg);
     }
+
+    /**
+     * Eager load the relationships for the models.
+     * Overwriting Illuminate\Database\Eloquent\Builder@eagerLoadRelations
+     *
+     * @param  array  $models
+     * @return array
+     */
+    public function eagerLoadRelationsOne(array $models, string $type)
+    {
+        foreach ($this->eagerLoad as $name => $constraints) {
+            if (strpos($name, '.') === false) {
+                $models = $this->eagerLoadRelationOne($models, $name, $constraints, $type);
+            }
+        }
+
+        return $models;
+    }
+
+    /**
+     * Eagerly load the relationship on a set of models.
+     * Overwriting Illuminate\Database\Eloquent\Builder@eagerLoadRelation
+     *
+     * @param  array  $models
+     * @param  string  $name
+     * @param  \Closure  $constraints
+     * @return array
+     */
+    protected function eagerLoadRelationOne(array $models, $name, Closure $constraints, string $type)
+    {
+        $relation = $this->getRelation($name);
+
+        $relation->addEagerConstraints($models);
+
+        $constraints($relation);
+
+        $parseData = $this->parseRelationToKeys($relation, $type);
+
+        return $relation->match(
+            $relation->initRelation($models, $name),
+            $relation
+            ->whereIn($parseData[0], $parseData[1])
+            ->getEager(),
+            $name
+        );
+    }
+
+    /**
+     * Getting only need ids
+     * @param  object $relation
+     * @param  string $type
+     * @return array
+     */
+    private function parseRelationToKeys(object $relation, string $type)
+    {
+        $relationCopy = clone $relation;
+
+        $typeRelation = get_class($relationCopy);
+        switch (get_class($relationCopy)) {
+            case HasMany::class:
+                $maxKey = $asKey = $relation->getLocalKeyName();
+                $groupby = $relation->getForeignKeyName();
+                break;
+            case BelongsToMany::class:
+                $maxKey = $asKey = $relation->getRelatedKeyName();
+                $groupby = $relation->getRelated()->getTable() . '.' . $relation->getForeignPivotKeyName();
+                break;
+            case HasManyThrough::class:
+                $asKey = $relation->getSecondLocalKeyName();
+                $maxKey = $relation->getRelated()->getTable() . '.' . $asKey;
+                $groupby = $relation->getParent()->getTable() . '.' . $relation->getFirstKeyName();
+                break;
+        }
+
+        return [$maxKey, $relationCopy->selectRaw("$type($maxKey) as $asKey")->groupby($groupby)->pluck($asKey)];
+    }
 }
diff --git a/src/Traits/LaravelSubQueryTrait.php b/src/Traits/LaravelSubQueryTrait.php
@@ -67,6 +67,28 @@ public function loadAvg($relations)
         return $this;
     }
 
+    /**
+     * Eager load latest relation on the model.
+     *
+     * @param  array|string  $relations
+     * @return $this
+     */
+    public function loadOneLatest($relations)
+    {
+        return $this->newCollection([$this])->loadOneLatest($relations);
+    }
+
+    /**
+     * Eager load oldest relation on the model.
+     *
+     * @param  array|string  $relations
+     * @return $this
+     */
+    public function loadOneOldest($relations)
+    {
+        return $this->newCollection([$this])->loadOneOldest($relations);
+    }
+
     public function newEloquentBuilder($builder)
     {
         $newEloquentBuilder = new LaravelSubQuery($builder);
diff --git a/tests/DatabaseTestCase.php b/tests/DatabaseTestCase.php
@@ -14,6 +14,9 @@ protected function setUp(): void
         $this->createInvoicesTable();
         $this->createItemsTable();
         $this->createGoodsTable();
+        $this->createCountriesTable();
+        $this->createCustomersTable();
+        $this->createPostsTable();
     }
 
     protected function getEnvironmentSetUp($app)
@@ -56,4 +59,30 @@ protected function createGoodsTable(): void
             $table->integer('price2');
         });
     }
+
+    protected function createCountriesTable(): void
+    {
+        Schema::create('countries', function (Blueprint $table) {
+            $table->id();
+            $table->string('name');
+        });
+    }
+
+    protected function createCustomersTable(): void
+    {
+        Schema::create('customers', function (Blueprint $table) {
+            $table->id();
+            $table->integer('country_id');
+            $table->string('name');
+        });
+    }
+
+    protected function createPostsTable(): void
+    {
+        Schema::create('posts', function (Blueprint $table) {
+            $table->id();
+            $table->integer('user_id');
+            $table->string('title');
+        });
+    }
 }
diff --git a/tests/LaravelSubQueryLoadOneTest.php b/tests/LaravelSubQueryLoadOneTest.php
@@ -0,0 +1,76 @@
+<?php
+
+namespace Alexmg86\LaravelSubQuery\Tests;
+
+use Alexmg86\LaravelSubQuery\Facades\LaravelSubQuery;
+use Alexmg86\LaravelSubQuery\ServiceProvider;
+use Alexmg86\LaravelSubQuery\Tests\Models\Country;
+use Alexmg86\LaravelSubQuery\Tests\Models\Customer;
+use Alexmg86\LaravelSubQuery\Tests\Models\Post;
+
+class LaravelSubQueryLoadOneTest extends DatabaseTestCase
+{
+    protected function getPackageProviders($app)
+    {
+        return [ServiceProvider::class];
+    }
+
+    protected function getPackageAliases($app)
+    {
+        return [
+            'laravel-sub-query' => LaravelSubQuery::class,
+        ];
+    }
+
+    private function createBasic()
+    {
+        $countriesNames = ['Russia', 'Spain', 'Mexico'];
+        foreach ($countriesNames as $countriesName) {
+            $country = Country::create(['name' => $countriesName]);
+
+            $customersNames = ['Ivan', 'Juan', 'Julio'];
+            foreach ($customersNames as $customersName) {
+                $customer = Customer::create([
+                    'country_id' => $country->id,
+                    'name' => $customersName
+                ]);
+
+                $titles = ['title_1', 'title_2', 'title_3'];
+                foreach ($titles as $title) {
+                    Post::create([
+                        'user_id' => $customer->id,
+                        'title' => $title
+                    ]);
+                }
+            }
+        }
+    }
+
+    public function testLoadOneLatest()
+    {
+        $this->createBasic();
+
+        $countries = Country::all();
+        $countries->loadOneLatest('posts');
+
+        foreach ($countries as $country) {
+            $this->assertEquals(count($country->posts), 1);
+            $this->assertTrue(in_array($country->posts->first()->id, [9, 18, 27]));
+            $this->assertEquals($country->posts->first()->title, 'title_3');
+        }
+    }
+
+    public function testLoadOneOldest()
+    {
+        $this->createBasic();
+
+        $countries = Country::all();
+        $countries->loadOneOldest('posts');
+
+        foreach ($countries as $country) {
+            $this->assertEquals(count($country->posts), 1);
+            $this->assertTrue(in_array($country->posts->first()->id, [1, 10, 19]));
+            $this->assertEquals($country->posts->first()->title, 'title_1');
+        }
+    }
+}
diff --git a/tests/Models/Country.php b/tests/Models/Country.php
@@ -0,0 +1,25 @@
+<?php
+
+namespace Alexmg86\LaravelSubQuery\Tests\Models;
+
+use Alexmg86\LaravelSubQuery\Traits\LaravelSubQueryTrait;
+use Illuminate\Database\Eloquent\Model;
+
+class Country extends Model
+{
+    use LaravelSubQueryTrait;
+
+    public $table = 'countries';
+    public $timestamps = false;
+    protected $fillable = ['name'];
+
+    public function customers()
+    {
+        return $this->hasMany(Customer::class);
+    }
+
+    public function posts()
+    {
+        return $this->hasManyThrough(Post::class, Customer::class, 'country_id', 'user_id', 'id', 'id');
+    }
+}
diff --git a/tests/Models/Customer.php b/tests/Models/Customer.php
@@ -0,0 +1,12 @@
+<?php
+
+namespace Alexmg86\LaravelSubQuery\Tests\Models;
+
+use Illuminate\Database\Eloquent\Model;
+
+class Customer extends Model
+{
+    public $table = 'customers';
+    public $timestamps = false;
+    protected $fillable = ['country_id', 'name'];
+}
diff --git a/tests/Models/Post.php b/tests/Models/Post.php
@@ -0,0 +1,12 @@
+<?php
+
+namespace Alexmg86\LaravelSubQuery\Tests\Models;
+
+use Illuminate\Database\Eloquent\Model;
+
+class Post extends Model
+{
+    public $table = 'posts';
+    public $timestamps = false;
+    protected $fillable = ['user_id', 'title'];
+}
