Merge pull request #11 from kirschbaum-development/feature/relation-alias

Feature: Table aliases

Author: luisdalmolin

README.md

@@ -118,6 +118,24 @@ User::joinRelationship('posts', function ($join) {
 
 When using model scopes inside a join clause, you **can't** type hint the `$query` parameter in your scope. Also, keep in mind you are inside a join, so you are limited to use only conditions supported by joins.
 
+**Using aliases**
+
+Sometimes, you are going to need to use table aliases on your joins because you are joining the same table more than once. One option to accomplish this is to use the `joinRelationshipUsingAlias` method.
+
+```php
+Post::joinRelationshipUsingAlias('category.parent')->get();
+```
+
+Or, you can also call the `as` function inside the join callback.
+
+```php
+Post::joinRelationship('category.parent', [
+    'parent' => function ($join) {
+        $join->as('category_parent');
+    },
+])->get()
+```
+
 **Select * from table**
 
 When making joins, using `select * from ...` can be dangerous as fields with the same name between the parent and the joined tables could conflict. Thinking on that, if you call the `joinRelationship` method without previously selecting any specific columns, Eloquent Power Joins will automatically include that for you. For instance, take a look at the following examples:

src/Mixins/JoinRelationship.php

@@ -4,6 +4,8 @@
 
 use Closure;
 use Illuminate\Database\Eloquent\Model;
+use Illuminate\Database\Eloquent\Relations\BelongsToMany;
+use Illuminate\Database\Eloquent\Relations\HasManyThrough;
 use Illuminate\Database\Query\Builder as QueryBuilder;
 use Illuminate\Support\Str;
 use KirschbaumDevelopment\EloquentJoins\PowerJoinClause;
@@ -17,6 +19,13 @@ class JoinRelationship
      */
     public static $joinRelationshipCache = [];
 
+    /**
+     * Cache to not join the same relationship twice.
+     *
+     * @var array
+     */
+    public static $powerJoinAliasesCache = [];
+
     /**
      * Join method map.
      */
@@ -31,30 +40,62 @@ class JoinRelationship
      */
     public function joinRelationship()
     {
-        return function ($relationName, $callback = null, $joinType = 'join') {
+        return function ($relationName, $callback = null, $joinType = 'join', $useAlias = false) {
             $joinType = JoinRelationship::$joinMethodsMap[$joinType] ?? $joinType;
 
             if (is_null($this->getSelect())) {
                 $this->select(sprintf('%s.*', $this->getModel()->getTable()));
             }
 
             if (Str::contains($relationName, '.')) {
-                return $this->joinNestedRelationship($relationName, $callback, $joinType);
+                return $this->joinNestedRelationship($relationName, $callback, $joinType, $useAlias);
             }
 
             if ($this->relationshipAlreadyJoined($relationName)) {
                 return $this;
             }
 
             $relation = $this->getModel()->{$relationName}();
-            $relation->performJoinForEloquentPowerJoins($this, $joinType, $callback);
+            $alias = $useAlias ? $this->generateAliasForRelationship($relation, $relationName) : null;
+            $relation->performJoinForEloquentPowerJoins($this, $joinType, $callback, $alias);
 
             $this->markRelationshipAsAlreadyJoined($relationName);
+            $this->clearPowerJoinCaches();
 
             return $this;
         };
     }
 
+    /**
+     * Join the relationship(s) using table aliases.
+     */
+    public function joinRelationshipUsingAlias()
+    {
+        return function ($relationName, $callback = null) {
+            return $this->joinRelationship($relationName, $callback, 'join', true);
+        };
+    }
+
+    /**
+     * Left join the relationship(s) using table aliases.
+     */
+    public function leftJoinRelationshipUsingAlias()
+    {
+        return function ($relationName, $callback = null) {
+            return $this->joinRelationship($relationName, $callback, 'leftJoin', true);
+        };
+    }
+
+    /**
+     * Right join the relationship(s) using table aliases.
+     */
+    public function rightJoinRelationshipUsingAlias()
+    {
+        return function ($relationName, $callback = null) {
+            return $this->joinRelationship($relationName, $callback, 'rightJoin', true);
+        };
+    }
+
     public function joinRelation()
     {
         return function ($relationName, $callback = null, $joinType = 'join') {
@@ -64,29 +105,29 @@ public function joinRelation()
 
     public function leftJoinRelationship()
     {
-        return function ($relation, $callback = null) {
-            return $this->joinRelationship($relation, $callback, 'leftJoin');
+        return function ($relation, $callback = null, $useAlias = false) {
+            return $this->joinRelationship($relation, $callback, 'leftJoin', $useAlias);
         };
     }
 
     public function leftJoinRelation()
     {
-        return function ($relation, $callback = null) {
-            return $this->joinRelationship($relation, $callback, 'leftJoin');
+        return function ($relation, $callback = null, $useAlias = false) {
+            return $this->joinRelationship($relation, $callback, 'leftJoin', $useAlias);
         };
     }
 
     public function rightJoinRelationship()
     {
-        return function ($relation, $callback = null) {
-            return $this->joinRelationship($relation, $callback, 'rightJoin');
+        return function ($relation, $callback = null, $useAlias = false) {
+            return $this->joinRelationship($relation, $callback, 'rightJoin', $useAlias);
         };
     }
 
     public function rightJoinRelation()
     {
-        return function ($relation, $callback = null) {
-            return $this->joinRelationship($relation, $callback, 'rightJoin');
+        return function ($relation, $callback = null, $useAlias = false) {
+            return $this->joinRelationship($relation, $callback, 'rightJoin', $useAlias);
         };
     }
 
@@ -95,15 +136,20 @@ public function rightJoinRelation()
      */
     public function joinNestedRelationship()
     {
-        return function ($relations, $callback = null, $joinType = 'join') {
+        return function ($relations, $callback = null, $joinType = 'join', $useAlias = false) {
             $relations = explode('.', $relations);
             $latestRelation = null;
 
             foreach ($relations as $index => $relationName) {
                 $currentModel = $latestRelation ? $latestRelation->getModel() : $this->getModel();
                 $relation = $currentModel->{$relationName}();
+                $alias = $useAlias ? $this->generateAliasForRelationship($relation, $relationName) : null;
                 $relationCallback = null;
 
+                if ($useAlias) {
+                    $this->cachePowerJoinAlias($relation->getModel(), $alias);
+                }
+
                 if ($callback && is_array($callback) && isset($callback[$relationName])) {
                     $relationCallback = $callback[$relationName];
                 }
@@ -116,13 +162,16 @@ public function joinNestedRelationship()
                 $relation->performJoinForEloquentPowerJoins(
                     $this,
                     $joinType,
-                    $relationCallback
+                    $relationCallback,
+                    $alias
                 );
 
                 $latestRelation = $relation;
                 $this->markRelationshipAsAlreadyJoined($relationName);
             }
 
+            $this->clearPowerJoinCaches();
+
             return $this;
         };
     }
@@ -217,7 +266,7 @@ public function orderByMaxUsingJoins()
     public function relationshipAlreadyJoined()
     {
         return function ($relation) {
-            return isset(JoinRelationship::$joinRelationshipCache[spl_object_hash($this)][$relation]);
+            return isset(JoinRelationship::$joinRelationshipCache[spl_object_id($this)][$relation]);
         };
     }
 
@@ -227,7 +276,7 @@ public function relationshipAlreadyJoined()
     public function markRelationshipAsAlreadyJoined()
     {
         return function ($relation) {
-            JoinRelationship::$joinRelationshipCache[spl_object_hash($this)][$relation] = true;
+            JoinRelationship::$joinRelationshipCache[spl_object_id($this)][$relation] = true;
         };
     }
 
@@ -292,4 +341,40 @@ public function newPowerJoinClause()
             return new PowerJoinClause($parentQuery, $type, $table, $model);
         };
     }
+
+    public function generateAliasForRelationship()
+    {
+        return function ($relation, $relationName) {
+            if ($relation instanceof BelongsToMany || $relation instanceof HasManyThrough) {
+                return [
+                    md5($relationName.'table1'.time()),
+                    md5($relationName.'table2'.time()),
+                ];
+            }
+
+            return md5($relationName.time());
+        };
+    }
+
+    /**
+     * Cache the power join table alias used for the power join.
+     */
+    public function cachePowerJoinAlias()
+    {
+        return function ($model, $alias) {
+            JoinRelationship::$powerJoinAliasesCache[spl_object_id($model)] = $alias;
+        };
+    }
+
+    /**
+     * Clear the power join caches.
+     */
+    public function clearPowerJoinCaches()
+    {
+        return function () {
+            JoinRelationship::$powerJoinAliasesCache = [];
+
+            return $this;
+        };
+    }
 }