PHP Builder::whereIn方法代码示例

 /**
  *
  *
  * @param Builder $query
  * @return Builder
  */
 public function scopeNewestGrouped($query)
 {
     // @todo: find a better way of doing this
     $newest = \DB::select("select max(id) as id from mail_statistics group by service_message_id");
     $newest = collect($newest)->pluck('id');
     return $query->whereIn('id', $newest->toArray())->newest();
 }

 /**
  * Method returns models geted by uuid
  * @param  Builder $query
  * @param  array|tring $uuid  uuid or list of uuids
  * @return Collection|Model Single model or collection of models
  */
 public function scopeFindByUuid($query, $uuid)
 {
     if (!is_array($uuid)) {
         if (!Uuid::isValid($uuid)) {
             throw (new ModelNotFoundException())->setModel(get_class($this));
         }
         return $query->where('uuid', $uuid)->first();
     } elseif (is_array($uuid)) {
         array_map(function ($element) {
             if (!Uuid::isValid($element)) {
                 throw (new ModelNotFoundException())->setModel(get_class($this));
             }
         }, $uuid);
         return $query->whereIn('uuid', $uuid)->get();
     }
 }

 /**
  * @param string $category
  * @return Builder
  */
 public function scopeWhereCategoryIs(Builder $q, $category)
 {
     //aliases
     if ($category == 'contorni') {
         $category = 'Verdure, ortaggi e contorni';
     } elseif ($category == 'primi') {
         $category = 'Primi Piatti';
     } elseif ($category == 'secondi') {
         $category = ['Secondi di carne', 'Secondi di pesce'];
     }
     //dd($category);
     if (is_array($category)) {
         return $q->whereIn('category', $category);
     } else {
         return $q->where('category', '=', $category);
     }
 }

 /**
  * Filter results by a user level
  * @param  Builder $query
  * @return void
  */
 public function scopeOfLevel($query)
 {
     $args = func_get_args();
     $levels = array_splice($args, 1);
     $query->whereIn('level', $levels);
 }

 private function manyMany()
 {
     $db = Config::get('database.' . $this->link_config);
     $db['connection'] = $this->link_config;
     $connection = Connection::get($db);
     $builder = new Builder($connection, $db, $this->link_table, $this->link_primary_key, null);
     //$child_list = $builder->whereIn($this->parent_column, $this->parent_list)->lists($this->child_column);
     $child_list = $builder->whereIn($this->parent_column, $this->parent_list)->get();
     $children = array();
     foreach ($child_list as $child) {
         $children[] = $child->{$this->child_column};
     }
     $child = $this->child;
     $return = $child::whereIn($this->child_column, $children)->get();
     if (count($this->parent_list) <= 1) {
         return $return;
     }
     foreach ($this->collection as &$item) {
         $collection = array();
         foreach ($child_list as $link) {
             if ($item->{$this->parent_column} == $link->{$this->parent_column}) {
                 foreach ($return as $child) {
                     if ($link->{$this->child_column} == $child->{$this->child_column}) {
                         $collection[] = $child;
                     }
                 }
             }
         }
         $item->{$this->function} = new \Frame\Collection($collection);
     }
 }

 /**
  * @param  array   $queries  {
  *
  * @type string    $relation Optional. The MySQL keyword used to join the clauses of the query. Accepts 'AND', Or
  *       'OR'. Default 'AND'.
  *
  * @type array {
  * @type string    $key      Meta key to filter by.
  * @type string    $value    Meta value to filter by.
  * @type string    $compare  MySQL operator used for comparing the $value. Accepts '=',
  *                               '!=', '>', '>=', '<', '<=', 'LIKE', 'NOT LIKE', 'IN', 'NOT IN',
  *                               'BETWEEN', 'NOT BETWEEN', 'REGEXP', 'NOT REGEXP', or 'RLIKE'.
  *                               Default is '='
  *             }
  * }
  *
  * @param  Builder $q
  * @param  int     $depth
  */
 public function metaQueryClause($queries, &$q, $depth = 0)
 {
     $i = 0;
     foreach ($queries as $key => $query) {
         if ('relation' === $key) {
             //if relation were found we shall skip to the next iteration
             continue;
         } else {
             if (isset($query['key'])) {
                 // That happens when a non-nested query found on the first iteration
                 // in that case we the clause should be AND
                 $relation = 0 === $i ? 'AND' : $queries['relation'];
                 $q->where(function ($q) use($query) {
                     if (isset($query['key'])) {
                         $q->where('meta_key', '=', $query['key']);
                     }
                     if (isset($query['value'])) {
                         if (isset($query['compare'])) {
                             switch (strtolower($query['compare'])) {
                                 case 'between':
                                     $q->whereBetween('meta_value', $query['value']);
                                     break;
                                 case 'not between':
                                     $q->whereNotBetween('meta_value', $query['value']);
                                     break;
                                 case 'in':
                                     $q->whereIn('meta_value', $query['value']);
                                     break;
                                 case 'not in':
                                     $q->whereNotIn('meta_value', $query['value']);
                                     break;
                                 case 'is null':
                                     $q->whereIsNull('meta_value');
                                     break;
                                 case 'is not null':
                                     $q->whereIsNotNull('meta_value');
                                     break;
                                 default:
                                     $q->where('meta_value', $query['compare'], $query['value']);
                             }
                         } else {
                             $q->where('meta_value', '=', $query['value']);
                         }
                     }
                 }, null, null, $relation);
             } else {
                 if (is_array($query)) {
                     $depth = $depth + 1;
                     // If we're going recursive for the first iterate we shall make the relation AND by default
                     // else we should use the provided relation
                     $relation = 1 === $depth && 0 === $i ? 'AND' : $queries['relation'];
                     $q->where(function ($q) use($query, $depth) {
                         $this->metaQueryClause($query, $q, $depth);
                     }, null, null, $relation);
                 } else {
                     continue;
                 }
             }
         }
         $i++;
     }
 }

 /**
  * Exclude IDs that are not in a given array
  * @param  Builder $query
  * @param  array  $ids
  * @return void
  */
 public function scopeWithIds($query, array $ids)
 {
     $query->whereIn($this->getKeyName(), $ids);
 }