PHP Builder::whereIn方法代码示例

 public static function scopeWithTag(Builder $query, $tags, $type = 'slug')
 {
     $tags = (new static())->prepareTags($tags);
     return $query->whereHas('tags', function ($query) use($type, $tags) {
         $query->whereIn($type, $tags);
     });
 }

 /**
  * Add a whereIn to the query
  *
  * @param  string $field
  * @param  array  $values
  * @param  bool   $order
  *
  * @return $this
  */
 public function whereIn($field, $values, $order = false)
 {
     $this->builder = $this->builder->whereIn($field, $values);
     if ($order) {
         $this->builder = $this->builder->orderByRaw(DB::raw("FIELD(" . $field . ", " . implode(',', $values) . ")"));
     }
     return $this;
 }

 public function scopeInLog(Builder $query, ...$logNames) : Builder
 {
     if (is_array($logNames[0])) {
         $logNames = $logNames[0];
     }
     return $query->whereIn('log_name', $logNames);
 }

 /**
  * In
  *
  * @param $key
  * @param $value
  * @return $this
  */
 private function setIn($key, $value)
 {
     if (is_array($value)) {
         $this->query->whereIn($key, $value);
     }
     return $this;
 }

 /**
  * Fired just before querying
  * for table entries.
  *
  * @param Builder $query
  */
 public function onQuerying(Builder $query)
 {
     $uploaded = $this->getUploaded();
     $query->whereIn('id', $uploaded ?: [0]);
     $query->orderBy('updated_at', 'ASC');
     $query->orderBy('created_at', 'ASC');
 }

 /**
  * Apply the scope to a given Eloquent query builder.
  *
  * @param  \Illuminate\Database\Eloquent\Builder  $builder
  * @return void
  */
 public function apply(Builder $builder, Model $model)
 {
     $subclassTypes = array_keys($model->getSingleTableTypeMap());
     if (!empty($subclassTypes)) {
         $builder->whereIn($model->getQualifiedSingleTableTypeColumn(), $subclassTypes);
     }
 }

 /**
  * Constrain the given users query by all provided roles.
  *
  * @param  \Illuminate\Database\Eloquent\Builder  $query
  * @param  string  $role
  * @return \Illuminate\Database\Eloquent\Builder
  */
 public function constrainWhereIsAll($query, $role)
 {
     $roles = array_slice(func_get_args(), 1);
     return $query->whereHas('roles', function ($query) use($roles) {
         $query->whereIn('name', $roles);
     }, '=', count($roles));
 }

 /**
  * Apply the scope to a given Eloquent query builder.
  *
  * @param  \Illuminate\Database\Eloquent\Builder  $builder
  * @param  \Illuminate\Database\Eloquent\Model  $model
  * @return void
  */
 public function apply(Builder $builder, Model $model)
 {
     if (isset($model->type_field) && isset($model->type)) {
         if (!is_array($model->type)) {
             $builder->where($model->type_field, $model->type);
         } else {
             $builder->whereIn($model->type_field, $model->type);
         }
     } elseif (isset($model->type)) {
         if (!is_array($model->type)) {
             $builder->where('type', $model->type);
         } else {
             $builder->whereIn('type', $model->type);
         }
     }
 }

 /**
  *
  * Delete numbers of notifications equals
  * to the number passing as 2 parameter of
  * the current user
  *
  * @param $user_id    int
  * @param $entity
  * @param $number     int
  * @param $order      string
  * @return int
  * @throws \Exception
  */
 public function deleteLimit($user_id, $entity, $number, $order)
 {
     $notifications_ids = $this->notification->wherePolymorphic($user_id, $entity)->orderBy('id', $order)->select('id')->limit($number)->lists('id');
     if (count($notifications_ids) == 0) {
         return false;
     }
     return $this->notification->whereIn('id', $notifications_ids)->delete();
 }

 public function build(Builder $query)
 {
     if (is_array($this->title)) {
         return $query->whereIn('title', $this->title);
     } else {
         return $query->where('title', '=', $this->title);
     }
 }

 public function findAllBy($attribute, $value, $columns = ['*'])
 {
     $this->newQuery();
     // Perform where in
     if (is_array($value)) {
         return $this->query->whereIn($attribute, $value)->get($columns);
     }
     return $this->query->where($attribute, '=', $value)->get($columns);
 }

 /**
  * Apply simple filter
  *
  * @param Filter $filter
  */
 protected function applySimpleFilter(Filter $filter)
 {
     $value = (array) $filter->getValue();
     if (count($value) > 1) {
         $this->query->whereIn($filter->getField(), $value);
     } else {
         $this->query->where($filter->getField(), $filter->getOperator(), $value[0]);
     }
 }

 public function build(Builder $query)
 {
     $query->join('assets_tags', 'assets_tags.asset_id', '=', 'assets.id');
     if (is_array($this->tags)) {
         $query->whereIn('assets_tags.tag', $this->tags)->groupBy('tag')->having(DB::raw('count(distinct tag)'), '=', count($this->tags));
     } else {
         $query->where('assets_tags.tag', '=', $this->tags);
     }
     return $query;
 }

 /**
  * Apply the scope to a given Eloquent query builder.
  *
  * @param  \Illuminate\Database\Eloquent\Builder $builder
  * @param  \Illuminate\Database\Eloquent\Model $model
  *
  * @return void
  */
 public function apply(Builder $builder, Model $model)
 {
     $strict = isset($model::$strictModeration) ? $model::$strictModeration : config('moderation.strict');
     if ($strict) {
         $builder->where($model->getQualifiedStatusColumn(), '=', Status::APPROVED);
     } else {
         $builder->whereIn($model->getStatusColumn(), [Status::APPROVED, Status::PENDING]);
     }
     $this->extend($builder);
 }

 /**
  * Apply logged in scope.
  *
  * @param \Illuminate\Database\Eloquent\Builder  $query
  * @param \Gitamin\Models\User  $user
  *
  * @return \Illuminate\Database\Eloquent\Builder
  */
 public function applyLoggedInScope(Builder $query, User $user)
 {
     $isPrivate = function ($query) use($user) {
         $query->where('visibility_level', '=', self::VISIBILITY_PRIVATE)->where("{$this->tableName}.creator_id", '=', $user->id);
     };
     $whereVisible = function ($query) use($isPrivate) {
         $query->whereIn('visibility_level', [self::VISIBILITY_PUBLIC, self::VISIBILITY_LOGGED_IN])->orWhere($isPrivate);
     };
     return $query->where($whereVisible);
 }