Laravel动态关系 - 在渴望加载时访问模型属性

1 回答

• 5

  由于渴望加载的方式起作用，因此没有任何东西可以用来运行SQL来完成你正在寻找的东西 .

  当你执行 Product::with('parent')->get() 时，它会运行两个查询 .

  首先，它运行查询以获取所有产品：

  select * from `products`
  

  接下来，它运行一个查询来获取渴望加载的父项：

  select * from `products` where `products`.`id` in (?, ?, ?)
  

  参数数量（ ? ）对应于第一个查询的结果数 . 一旦检索到第二组模型， match() 函数用于将对象相互关联 .

  为了做你想做的事，你将不得不创建一个新的关系并覆盖 match() 方法 . 这将处理急切的加载方面 . 此外，您还需要覆盖 addConstraints 方法来处理延迟加载方面 .

  首先，创建一个自定义关系类：

  class CustomBelongsTo extends BelongsTo
  {
      // Override the addConstraints method for the lazy loaded relationship.
      // If the foreign key of the model is 0, change the foreign key to the
      // model's own key, so it will load itself as the related model.
  
      /**
       * Set the base constraints on the relation query.
       *
       * @return void
       */
      public function addConstraints()
      {
          if (static::$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();
  
              $key = $this->parent->{$this->foreignKey} == 0 ? $this->otherKey : $this->foreignKey;
  
              $this->query->where($table.'.'.$this->otherKey, '=', $this->parent->{$key});
          }
      }
  
      // Override the match method for the eager loaded relationship.
      // Most of this is copied from the original method. The custom
      // logic is in the elseif.
  
      /**
       * 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)
      {
          $foreign = $this->foreignKey;
  
          $other = $this->otherKey;
  
          // 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 = [];
  
          foreach ($results as $result) {
              $dictionary[$result->getAttribute($other)] = $result;
          }
  
          // 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]);
              }
              // If the foreign key is 0, set the relation to a copy of the model
              elseif($model->$foreign == 0) {
                  // Make a copy of the model.
                  // You don't want recursion in your relationships.
                  $copy = clone $model;
  
                  // Empty out any existing relationships on the copy to avoid
                  // any accidental recursion there.
                  $copy->setRelations([]);
  
                  // Set the relation on the model to the copy of itself.
                  $model->setRelation($relation, $copy);
              }
          }
  
          return $models;
      }
  }
  

  创建自定义关系类后，需要更新模型以使用此自定义关系 . 在模型上创建一个将使用新的 CustomBelongsTo 关系的新方法，并更新 parent() 关系方法以使用此新方法，而不是基本 belongsTo() 方法 .

  class Product extends Model
  {
  
      // Update the parent() relationship to use the custom belongsto relationship
      public function parent()
      {
          return $this->customBelongsTo('App\Product', 'parent_id', 'id');
      }
  
      // Add the method to create the CustomBelongsTo relationship. This is
      // basically a copy of the base belongsTo method, but it returns
      // a new CustomBelongsTo relationship instead of the original BelongsTo relationship
      public function customBelongsTo($related, $foreignKey = null, $otherKey = null, $relation = null)
      {
          // If no relation name was given, we will use this debug backtrace to extract
          // the calling method's name and use that as the relationship name as most
          // of the time this will be what we desire to use for the relationships.
          if (is_null($relation)) {
              list($current, $caller) = debug_backtrace(DEBUG_BACKTRACE_IGNORE_ARGS, 2);
  
              $relation = $caller['function'];
          }
  
          // If no foreign key was supplied, we can use a backtrace to guess the proper
          // foreign key name by using the name of the relationship function, which
          // when combined with an "_id" should conventionally match the columns.
          if (is_null($foreignKey)) {
              $foreignKey = Str::snake($relation).'_id';
          }
  
          $instance = new $related;
  
          // Once we have the foreign key names, we'll just create a new Eloquent query
          // for the related models and returns the relationship instance which will
          // actually be responsible for retrieving and hydrating every relations.
          $query = $instance->newQuery();
  
          $otherKey = $otherKey ?: $instance->getKeyName();
  
          return new CustomBelongsTo($query, $this, $foreignKey, $otherKey, $relation);
      }
  }
  

  公平警告，这些都没有经过测试 .

  回复于 2024-04-27T13:42:18+08:00