Eloquent eager load Order by

后端 未结 7 2083
花落未央
花落未央 2020-11-27 13:56

I have problem with eloquent query. I am using eager loading (one to one Relationship) to get \'student\' With the \'exam\', Using the code

相关标签:
7条回答
  • 2020-11-27 14:39

    You could use \Illuminate\Database\Eloquent\Relations\Relation and query scopes to add far column through relationship, I wrote a traits for this, it misses HasOne o HasMany but having BelongsTo and BelongsToMany could easily adapted

    Also the method could be enhanced to support more than depth 1 for multiple chained relationship, I made room for that

    <?php
    /**
     * User: matteo.orefice
     * Date: 16/05/2017
     * Time: 10:54
     */
    
    
    use Illuminate\Database\Eloquent\Relations\BelongsToMany;
    use Illuminate\Database\Eloquent\Relations\BelongsTo;
    use Illuminate\Support\Facades\DB;
    use Illuminate\Database\Eloquent\Builder;
    
    
    trait WithFarColumnsTrait
    {
    
        public function scopeWithFarColumns(Builder $query , $relationPath , $columns , $tableAliasPrefix = null)
        {
            $relationPath = array_wrap($relationPath);
            $tableAliasPrefix = $tableAliasPrefix ?: WithFarColumnsTrait::randomStringAlpha(3);
            $currentModel = $this;
    
            $subQueries = [];
            $relationIndex = 0;
            foreach ($relationPath as $relationName) {
                if (method_exists($currentModel , $relationName)) {
                    $relation = $currentModel->$relationName();
                } else {
                    throw new BadMethodCallException("Relationship $relationName does not exist, cannot join.");
                }
                $currentTable = $currentModel->getTable();
                if ($relationIndex == 0) {
                    $query->addSelect($currentTable . '.*');
                }
                $relatedModel = $relation->getRelated();
                /**
                 * @var string
                 */
                $relatedTable = $relatedModel->getTable();
    
                if ($relation instanceof BelongsTo) {
                    foreach ($columns as $alias => $column) {
                        $tableAlias = $tableAliasPrefix . $relationIndex;
                        $tableAndAlias = $relatedTable . ' AS ' . $tableAlias;
                        /**
                         * Al momento gestisce soltanto la prima relazione
                         * todo: navigare le far relationships e creare delle join composte
                         */
                        if (!isset($subQueries[$alias])) {
                            $subQueries[$alias] = $currentQuery = DB::query()
                                ->from($tableAndAlias)
                                ->whereColumn(
                                    $relation->getQualifiedForeignKey() , // 'child-table.fk-column'
                                    '=' ,
                                    $tableAlias . '.' . $relation->getOwnerKey()  // 'parent-table.id-column'
                                )
                                ->select($tableAlias . '.' . $column);
                            // se la colonna ha una chiave stringa e' un alias
                            /**
                             * todo: in caso di relazioni multiple aggiungere solo per la piu lontana
                             */
                            if (is_string($alias)) {
                                $query->selectSub($currentQuery , $alias);
                            } else {
                                throw new \InvalidArgumentException('Columns must be an associative array');
                            }
                        } 
                        else {
                            throw new \Exception('Multiple relation chain not implemented yet');
                        }
                    } // end foreach <COLUMNs>
                } // endif
                else if ($relation instanceof BelongsToMany) {
                    foreach ($columns as $alias => $column) {
    
                        $tableAlias = $tableAliasPrefix . $relationIndex;
                        $tableAndAlias = $relatedTable . ' AS ' . $tableAlias;
    
                        if (!isset($subQueries[$alias])) {
                            $pivotTable = $relation->getTable();
                            $subQueries[$alias] = $currentQuery = DB::query()
                                ->from($tableAndAlias)
                                ->select($tableAlias . '.' . $column)
                                // final table vs pivot table
                                ->join(
                                    $pivotTable ,                               // tabelle pivot
                                    $relation->getQualifiedRelatedKeyName() ,    // pivot.fk_related_id
                                    '=' ,
                                    $tableAlias . '.' . $relatedModel->getKeyName() // related_with_alias.id
                                )
                                ->whereColumn(
                                    $relation->getQualifiedForeignKeyName() ,
                                    '=' ,
                                    $relation->getParent()->getQualifiedKeyName()
                                );
    
                            if (is_string($alias)) {
                                $query->selectSub($currentQuery , $alias);
                            } else {
                                throw new \InvalidArgumentException('Columns must be an associative array');
                            }
                        } 
                        else {
                            throw new \Exception('Multiple relation chain not implemented yet');
                        }
                    } // end foreach <COLUMNs>
                } else {
                    throw new \InvalidArgumentException(
                        sprintf("Relation $relationName of type %s is not supported" , get_class($relation))
                    );
                }
                $currentModel = $relatedModel;
                $relationIndex++;
            } // end foreach <RELATIONs>
        }
    
        /**
         * @param $length
         * @return string
         */
        public static function randomStringAlpha($length) {
            $pool = array_merge(range('a', 'z'),range('A', 'Z'));
            $key = '';
            for($i=0; $i < $length; $i++) {
                $key .= $pool[mt_rand(0, count($pool) - 1)];
            }
            return $key;
        }
    }
    
    0 讨论(0)
  • 2020-11-27 14:42

    If you ALWAYS want it sorted by exam result, you can add the sortBy call directly in the relationship function on the model.

    public function exam() {
      return this->hasMany(Exam::class)->orderBy('result');
    }
    

    (credit for this answer goes to pfriendly - he answered it here: How to sort an Eloquent subquery)

    0 讨论(0)
  • 2020-11-27 14:42

    This worked for me:

    $query = Student::select(['id','name']);
    
    
        $query->has('exam')->with(['exam' => function ($query) {
            return $query->orderBy('result','ASC');
        }]);
    
    
        return $query->get();
    
    0 讨论(0)
  • 2020-11-27 14:42

    There is an alternative way of achieving the result you want to have without using joins. You can do the following to sort the students based on their exam's result. (Laravel 5.1):

    $students = Student::with('exam')->get();
    
    $students = $students->sortByDesc(function ($student, $key)
    {
        return $student->exam->result;
    });
    
    0 讨论(0)
  • 2020-11-27 14:46

    tl;dr

    Student::with('exam')->get()->sortByDesc('exam.result');
    

    This will sort the results of the query after eager loading using collection methods and not by a MySQL ORDER BY.

    Explanation

    When you eager load you can't use an ORDER BY on the loaded relations because those will be requested and assembled as a result of a second query. As you can see it in the Laravel documentation eager loading happens in 2 query.

    If you want to use MySQL's ORDER BY you have to join the related tables.

    As a workaround, you can run your query and sort the resulting collection with sortBy, sortByDesc or even sort. This solution has advantages and disadvantages over the join solution:

    Advantages:

    • You keep Eloquent functionality.
    • Shorter and more intuitive code.

    Disadvantages:

    • Sorting will be done by PHP instead of the database engine.
    • You can sort only by a single column, unless you provide a custom closure for the sorter functions.
    • If you need only a part of the ordered results of a query (e.g. ORDER BY with LIMIT), you have to fetch everything, order it, then filter the ordered result, otherwise you will end up with only the filtered part being ordered (ordering will not consider the filtered out elements). So this solution is only acceptable when you would work on the whole data set anyway or the overhead is not a problem.
    0 讨论(0)
  • 2020-11-27 14:55

    If you need to order your students collection by the result column, you will need to join the tables.

    Student::with('exam')
           ->join('exam', 'students.id', '=', 'exam.student_id')
           ->orderBy('exam.result', 'DESC')
           ->get()
    

    In this case, assuming you have a column student_id and your exams table are named exam.

    0 讨论(0)
提交回复
热议问题