PHP Builder::whereNested方法代码示例

 /**
  * {@inheritdoc}
  */
 public function applyFilterConstraint(Builder $query, $data)
 {
     if ($this->multiple or !($data = $this->parse($data))) {
         return;
     }
     $query->whereNested(function ($inner) use($data) {
         foreach ($data as $key) {
             $inner->orWhere($this->id, '=', $key);
         }
     });
 }

 /**
  * @param \Illuminate\Database\Query\Builder|\Illuminate\Database\Eloquent\Builder $query
  *
  * @return void
  */
 public function apply($query)
 {
     $query->where(function ($query) {
         $logic = $this->logic === static::LOGIC_AND ? 'and' : 'or';
         foreach ($this->criteria as $criteria) {
             $query->whereNested(function ($query) use($criteria) {
                 $criteria->apply($query);
             }, $logic);
         }
     });
 }

 /**
  * @param Builder|QueryBuilder $queryBuilder
  * @param array $wheres
  * @param string $boolean
  */
 protected function buildWheres($queryBuilder, array $wheres, $boolean = 'and')
 {
     foreach ($wheres as $whereField => $where) {
         if (!isset($whereField) || !isset($where)) {
             continue;
         }
         $whereField = strtolower($whereField);
         // Nested OR where
         // Example: 'or' => ['foo' => 'bar', 'x => 'y']
         if ($whereField === 'or') {
             $queryBuilder->whereNested(function ($queryBuilder) use($where) {
                 $this->buildWheres($queryBuilder, $where, 'or');
             }, $boolean);
             continue;
         }
         // Nested AND where
         // Example: 'and' => ['foo' => 'bar', 'x => 'y']
         if ($whereField === 'and') {
             $queryBuilder->whereNested(function ($queryBuilder) use($where) {
                 $this->buildWheres($queryBuilder, $where, 'and');
             }, $boolean);
             continue;
         }
         // Operator is present on query
         // Example: 'foo' => ['like' => '%bar%']
         if (is_array($where)) {
             foreach ($where as $whereOperator => $whereValue) {
                 $whereOperator = $this->parseOperator($whereOperator);
                 $this->buildWhere($queryBuilder, $whereField, $whereOperator, $whereValue, $boolean);
             }
             continue;
         }
         // Operator is omitted on query, assumes '='
         // Example: 'foo' => 'bar'
         $whereOperator = is_array($where) ? array_keys($where)[0] : '=';
         $whereValue = is_array($where) ? $where[$whereOperator] : $where;
         $whereOperator = $this->parseOperator($whereOperator);
         $this->buildWhere($queryBuilder, $whereField, $whereOperator, $whereValue, $boolean);
     }
 }

 /**
  * Add a nested where statement to the query.
  *
  * @param \Closure $callback
  * @param string $boolean
  * @return \Illuminate\Database\Query\Builder|static 
  * @static 
  */
 public static function whereNested($callback, $boolean = 'and')
 {
     return \Illuminate\Database\Query\Builder::whereNested($callback, $boolean);
 }

 /**
  * Filter by keywords.
  *
  * @param \Illuminate\Database\Query\Builder $builder
  * @param array $keywords
  *
  * @return void
  */
 protected function applyKeywordsFilter(QueryBuilder $builder, array $keywords)
 {
     $builder->whereNested(function ($q) use($keywords) {
         /**
          * @var KeywordsFilter $item
          */
         foreach ($this->items as $item) {
             if ($item instanceof KeywordsFilter) {
                 $item->applyKeywordsFilter($q, $keywords);
             }
         }
     });
 }

 /**
  * Create nested queries
  *
  * When a rule is actually a group of rules, we want to build a nested query, and set the consition to be the
  * specified condition (AND/OR) within this new set of rules
  *
  * @param Builder $querybuilder
  * @param stdClass $rule
  * @param String $condition
  * @return mixed
  */
 protected function createNestedQuery(Builder $querybuilder, stdClass $rule, $condition)
 {
     $subCondition = $this->validateCondition($rule->condition);
     return $querybuilder->whereNested(function ($query) use(&$rule, &$querybuilder, &$subCondition) {
         foreach ($rule->rules as $_rule) {
             if ($this->isNested($_rule)) {
                 $querybuilder = $this->createNestedQuery($query, $_rule, $subCondition);
             } else {
                 $querybuilder = $this->makeQuery($query, $_rule, $subCondition);
             }
         }
     }, $condition);
 }