<?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
}
共同学习，写下你的评论
评论加载中...
作者其他优质文章
