[李景山php]每天laravel-20161128|BelongsTon.php

<?php

namespace Illuminate\Database\Eloquent\Relations;

use Illuminate\Database\Eloquent\Model;
use Illuminate\Database\Eloquent\Builder;
use Illuminate\Database\Query\Expression;
use Illuminate\Database\Eloquent\Collection;
// this is a new world about this belongs Top
class BelongsTo extends Relation
{//BelongsTo extends Relation
    /**
     * The foreign key of the parent model.
     *
     * @var string
     */
    protected $foreignKey;//The foreign key of the parent model.

    /**
     * The associated key on the parent model.
     *
     * @var string
     */
    protected $otherKey;//The associated key on the parent model

    /**
     * The name of the relationship.
     *
     * @var string
     */
    protected $relation;//The name of the relationship

    /**
     * Create a new belongs to relationship instance.
     *
     * @param  \Illuminate\Database\Eloquent\Builder  $query
     * @param  \Illuminate\Database\Eloquent\Model  $parent
     * @param  string  $foreignKey
     * @param  string  $otherKey
     * @param  string  $relation
     * @return void
     */
    public function __construct(Builder $query, Model $parent, $foreignKey, $otherKey, $relation)
    {//Create a new belongs to relationship instance.
        $this->otherKey = $otherKey;// set other key
        $this->relation = $relation;// set relation
        $this->foreignKey = $foreignKey;// set foreign key

        parent::__construct($query, $parent);// use parent construct
    }

    /**
     * Get the results of the relationship.
     *
     * @return mixed
     */
    public function getResults()
    {
        return $this->query->first();// get the first results
    }// Get the results of the relationship

    /**
     * Set the base constraints on the relation query.
     *
     * @return void
     */
    public function addConstraints()
    {//Set the base constraints on the relation query.
        if (static::$constraints) {
            // if has this constraints
            // For belongs to relationships, which are essentially the inverse of has one
            // or has many relationships, we need to actually query on the primary key
            // of the related models matching on the foreign key that's on a parent.
            $table = $this->related->getTable();
            // essentially the inverse of has one or has many relationships
// get table
            $this->query->where($table.'.'.$this->otherKey, '=', $this->parent->{$this->foreignKey});
        }
    }// add Constraints ,just like to add where condition
    // set the foreign key equal the associated key.

    /**
     * Add the constraints for a relationship query.
     *
     * @param  \Illuminate\Database\Eloquent\Builder  $query
     * @param  \Illuminate\Database\Eloquent\Builder  $parent
     * @param  array|mixed  $columns
     * @return \Illuminate\Database\Eloquent\Builder
     */
    public function getRelationQuery(Builder $query, Builder $parent, $columns = ['*'])
    {//Add the constraints for a relationship query.
        if ($parent->getQuery()->from == $query->getQuery()->from) {
            return $this->getRelationQueryForSelfRelation($query, $parent, $columns);
        }// if parent equal with this query from,
        // use this self function to get the relationQuery

        $query->select($columns);//query set the select columns

        $otherKey = $this->wrap($query->getModel()->getTable().'.'.$this->otherKey);
// get the otherKey
        return $query->where($this->getQualifiedForeignKey(), '=', new Expression($otherKey));
    }// just like add constraints , add foreign key equal associated key in this where condition


    /**
     * Add the constraints for a relationship query on the same table.
     *
     * @param  \Illuminate\Database\Eloquent\Builder  $query
     * @param  \Illuminate\Database\Eloquent\Builder  $parent
     * @param  array|mixed  $columns
     * @return \Illuminate\Database\Eloquent\Builder
     */
    public function getRelationQueryForSelfRelation(Builder $query, Builder $parent, $columns = ['*'])
    {// Add the constraints for a relationship query on the same table.
        $query->select($columns);// set the select columns

        $query->from($query->getModel()->getTable().' as '.$hash = $this->getRelationCountHash());
// get from
        $query->getModel()->setTable($hash);
// set Table
        $key = $this->wrap($this->getQualifiedForeignKey());
// wrap this foreign key
        return $query->where($hash.'.'.$query->getModel()->getKeyName(), '=', new Expression($key));
    }// where get key

    /**
     * Get a relationship join table hash.
     *
     * @return string
     */
    public function getRelationCountHash()
    {// get a relationship join table hash.
        return 'self_'.md5(microtime(true));
    }

    /**
     * Set the constraints for an eager load of the relation.
     *
     * @param  array  $models
     * @return void
     */
    public function addEagerConstraints(array $models)
    {//Set the constraints for an eager load of the relation.
        // We'll grab the primary key name of the related models since it could be set to
        // a non-standard name and not "id". We will then construct the constraint for
        // our eagerly loading query so it returns the proper models from execution.
        $key = $this->related->getTable().'.'.$this->otherKey;
// get Table key for out eagerly loading query so it returns the proper models from execution.
        $this->query->whereIn($key, $this->getEagerModelKeys($models));
    }// whereIn

    /**
     * Gather the keys from an array of related models.
     *
     * @param  array  $models
     * @return array
     */
    protected function getEagerModelKeys(array $models)
    {//Gather the keys from an array of related models.
        $keys = [];//$Keys

        // First we need to gather all of the keys from the parent models so we know what
        // to query for via the eager loading query. We will add them to an array then
        // execute a "where in" statement to gather up all of those related records.
        foreach ($models as $model) {
            if (! is_null($value = $model->{$this->foreignKey})) {
                $keys[] = $value;// filter the key
            }// is_null
        }// loop the models

        // If there are no keys that were not null we will just return an array with 0 in
        // it so the query doesn't fail, but will not return any results, which should
        // be what this developer is expecting in a case where this happens to them.
        if (count($keys) == 0) {
            return [0];
        }// no key return zero

        return array_values(array_unique($keys));
    }// just return array values

    /**
     * Initialize the relation on a set of models.
     *
     * @param  array   $models
     * @param  string  $relation
     * @return array
     */
    public function initRelation(array $models, $relation)
    {
        foreach ($models as $model) {
            $model->setRelation($relation, null);
        }// models as model

        return $models;//just return the models
    }//Initialize the relations on a set of models.

    /**
     * Match the eagerly loaded results to their parents.
     *
     * @param  array   $models
     * @param  \Illuminate\Database\Eloquent\Collection  $results
     * @param  string  $relation
     * @return array
     */
    public function match(array $models, Collection $results, $relation)
    {// Match the eagerly loaded results to their parents
        $foreign = $this->foreignKey;
// set foreignKey
        $other = $this->otherKey;// set other

        // First we will get to build a dictionary of the child models by their primary
        // key of the relationship, then we can easily match the children back onto
        // the parents using that dictionary and the primary key of the children.
        $dictionary = [];// set a store
        // i  like this word to set a dictionary about the children.

        foreach ($results as $result) {
            $dictionary[$result->getAttribute($other)] = $result;
        }// loop this re

        // Once we have the dictionary constructed, we can loop through all the parents
        // and match back onto their children using these keys of the dictionary and
        // the primary key of the children to map them onto the correct instances.
        foreach ($models as $model) {
            if (isset($dictionary[$model->$foreign])) {
                $model->setRelation($relation, $dictionary[$model->$foreign]);
            }
        }//Once we have the dictionary constructed, we can loop through all the parents
        // and match back onto their children using these keys of the dictionary and
        // the primary key of the children to map them onto the correct instances.

        return $models;
    }

    /**
     * Associate the model instance to the given parent.
     *
     * @param  \Illuminate\Database\Eloquent\Model|int  $model
     * @return \Illuminate\Database\Eloquent\Model
     */
    public function associate($model)
    {//Associate the model instance to the given parent
        $otherKey = ($model instanceof Model ? $model->getAttribute($this->otherKey) : $model);
// set other Key
        $this->parent->setAttribute($this->foreignKey, $otherKey);
//set Attribute
        if ($model instanceof Model) {
            $this->parent->setRelation($this->relation, $model);
        }
// set the model
        return $this->parent;
    }// return this parent

    /**
     * Dissociate previously associated model from the given parent.
     *
     * @return \Illuminate\Database\Eloquent\Model
     */
    public function dissociate()
    {
        $this->parent->setAttribute($this->foreignKey, null);
// set Attribute
        return $this->parent->setRelation($this->relation, null);
    }// Dissociate previously associated model from the given parent.

    /**
     * Update the parent model on the relationship.
     *
     * @param  array  $attributes
     * @return mixed
     */
    public function update(array $attributes)
    {// Update the parent model on the relationship.
        $instance = $this->getResults();

        return $instance->fill($attributes)->save();
    }// get instance and fill something and save it

    /**
     * Get the foreign key of the relationship.
     *
     * @return string
     */
    public function getForeignKey()
    {
        return $this->foreignKey;
    }//Get the foreign key of the relationship
    // big return

    /**
     * Get the fully qualified foreign key of the relationship.
     *
     * @return string
     */
    public function getQualifiedForeignKey()
    {
        return $this->parent->getTable().'.'.$this->foreignKey;
    }// big get

    /**
     * Get the associated key of the relationship.
     *
     * @return string
     */
    public function getOtherKey()
    {
        return $this->otherKey;
    }// just get

    /**
     * Get the fully qualified associated key of the relationship.
     *
     * @return string
     */
    public function getQualifiedOtherKeyName()
    {
        return $this->related->getTable().'.'.$this->otherKey;
    }// same
}