Add a nested where statement to the query.
|
public whereNested ( Closure $callback, string $boolean = 'and' ) : |
||
| $callback | Closure | |
| $boolean | string | |
| return | ||
/**
* {@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);
}
