Add an array of where clauses to the query.

@param  array  $column
@param  string  $boolean
@param  string  $method
@return $this
978464
protected function addArrayOfWheres($column, $boolean, $method = 'where')
    {
        return $this->whereNested(function ($query) use ($column, $method, $boolean) {
            foreach ($column as $key => $value) {
                if (is_numeric($key) && is_array($value)) {
                    $query->{$method}(...array_values($value));
                } else {
                    $query->$method($key, '=', $value, $boolean);
                }
            }
        }, $boolean);
    }
490145
public static function where($column, $operator = null, $value = null, $boolean = 'and')
    {
        return parent::query()->where($column, $operator, $value, $boolean);
    }
517846
public function orWhere($column, $value, $operator = self::OPERATOR_EQ): self
    {
        $this->criteria($this->where, $column, $value, $operator, self::LOGICAL_OR);

        return $this;
    }
1140323
public function whereColumn($first, $operator = null, $second = null, $boolean = 'and')
    {
        // If the column is an array, we will assume it is an array of key-value pairs
        // and can add them each as a where clause. We will maintain the boolean we
        // received when the method was called and pass it into the nested where.
        if (is_array($first)) {
            return $this->addArrayOfWheres($first, $boolean, 'whereColumn');
        }

        // If the given operator is not found in the list of valid operators we will
        // assume that the developer is just short-cutting the '=' operators and
        // we will set the operators to '=' and set the values appropriately.
        if ($this->invalidOperator($operator)) {
            list($second, $operator) = [$operator, '='];
        }

        // Finally, we will add this where clause into this array of clauses that we
        // are building for the query. All of them will be compiled via a grammar
        // once the query is about to be executed and run against the database.
        $type = 'Column';

        $this->wheres[] = compact(
            'type',
            'first',
            'operator',
            'second',
            'boolean'
        );

        return $this;
    }
481740
public function whereBetween($column, array $values, $boolean = 'and', $not = false)
    {
        $type = 'between';

        $property = $column;

        if ($column == 'id') $column = 'id('. $this->modelAsNode() .')';

        $this->wheres[] = compact('column', 'type', 'boolean', 'not');

        $this->addBinding([$property => $values], 'where');

        return $this;
    }
145775
public function where( $column, $operator = null, $value = null, $boolean = 'and' )
	{
		if ( $column instanceof Closure )
		{
			$query = $this->model->newQueryWithoutScopes();
			call_user_func( $column, $query );
			$this->query->addNestedWhereQuery( $query->getQuery(), $boolean );
		}
		else
			call_user_func_array( [$this->query, 'where'], func_get_args() );

		return $this;
	}
321707
public function wherePivotIn($column, $values, $boolean = 'and', $not = false)
	{
		$this->pivotWheres[] = func_get_args();

		return $this->whereIn($this->table.'.'.$column, $values, $boolean, $not);
	}
210250
public function whereBetween($column, array $range, $boolean = 'and')
    {

        if (count($range) !== 2) {
            throw new QueryBuilderException(
                'Parameter 2 must be contains two values.',
                E_ERROR
            );
        }

        $between = implode(' and ', $range);

        if (is_null($this->where)) {
            if ($boolean == 'not') {
                $this->where = '(`' . $column.'` not between ' . $between . ')';
            } else {
                $this->where = '(`' . $column . '` between ' . $between . ')';
            }
        } else {
            if ($boolean == 'not') {
                $this->where .= ' and (`'.$column .'` not between ' . $between . ')';
            } else {
                $this->where .= ' ' . $boolean . ' (`' . $column. '` between ' . $between . ')';
            }
        }

        return $this;
    }
56738
public function whereCarried($column, $operator = null, $value = null, $boolean = 'and')
    {
        $type = 'Carried';

        $this->wheres[] = compact('type', 'column', 'operator', 'value', 'boolean');

        return $this;
    }
917598
public function whereTime($column, $operator, $value, $boolean = 'and')
    {
        return $this->addDateBasedWhere('Time', $column, $operator, $value, $boolean);
    }
660817
protected function createSearchClause(Builder $query, $param, $column, $value, $boolean = 'and')
    {
        if ($param === 'query') {
            $query->where($this->appendTableName($column), self::$searchOperator, '%' . $value . '%', $boolean);
        }
        elseif (is_array($value)) {
            $query->whereIn($this->appendTableName($column), $value, $boolean);
        }
        else {
            $query->where($this->appendTableName($column), '=', $value, $boolean);
        }
    }
311298
public function whereMonth($column, $operator, $value, $boolean = 'and')
    {
        return $this->addDateBasedWhere('Month', $column, $operator, $value, $boolean);
    }
366082
public function addNestedWhereQuery($query, $boolean = 'and')
    {
        if (count($query->wheres)) {
            $type = 'Nested';
            $column = null;
            $value = $query->wheres;
            $this->wheres[] = compact('column', 'type', 'value', 'boolean');
        }

        return $this;
    }
542271
public function where($column, $operator, $value = null)
    {
        if (count($this->wheres) > 0) {
            $this->andWhere($column, $operator, $value);
        }

        $this->wheres[] = new Where($column, $operator, $value);

        return $this;
    }
305889
private function elementMethodCall(string $method, $item, bool &$isMethod = null, array $args = [])
    {
        if (is_array($item)) {
            return $item[$method];
        }

        if (is_null($isMethod)) {
            $isMethod = method_exists($item, $method);
        }

        if ($isMethod) {
            return call_user_func_array([$item, $method], $args);
        } else {
            return $item->$method;
        }
    }
1095998
public function atLeast($value, bool $is_column = false): WhereStatement
    {
        return $this->addCondition($value, '>=', $is_column);
    }
837718
public function whereDate($column, $operator, $value, $boolean = 'and')
    {
        return $this->addDateBasedWhere('Date', $column, $operator, $value, $boolean);
    }