Sets having clause, more calls rewrite old value.
@param string condition, for example fruit <> apple
@param mixed
@return self
509335
public function having($condition, $parameter = [])
	{
		$this->emptyResult();
		$this->queryBuilder->addHaving($condition, $parameter);
		return $this;
	}
274005
public function orWhere(...$conditions) : self
    {
        $this->conditionalQueryBuilder->orWhere(
            ...$this->createConditionExpressions($conditions)
        );

        return $this;
    }
586913
public function orHavingRaw(string $condition): self
    {
        $this->condition->orHaving([new RawExp($condition)]);

        return $this;
    }
1243495
public function having($column, $operator = null, $value = null, $boolean = 'and')
    {
        $type = 'basic';

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

        if (! $value instanceof Expression) {
            $this->addBinding($value, 'having');
        }

        return $this;
    }
911251
private function cleanCondition($condition)
    {
        if (is_array($condition)) {
            $condition = array_filter($condition);
            if (empty($condition)) {
                $condition = null;
            }
        }

        return $condition;
    }
433711
public function having($having)
    {
        if (false == ($having instanceof Q)) {
            $having = new QAnd($having);
        }
        $having->setLookupBuilder($this->getLookupBuilder());
        $having->setAdapter($this->getAdapter());

        $this->sqlParts['having'] = $having;

        return $this;
    }
444647
public function having($having)
    {
        if (is_string($having)) {
            $having = [$having];
        }

        $this->having = $having;
        return $this;
    }
936027
public function andWith($condition, ...$values): self
    {
        if ($condition instanceof EasyStatement) {
            $condition = '(' . $condition . ')';
        }
        if (!\is_string($condition)) {
            throw new \TypeError('An EasyStatement or string is expected for argument 1');
        }
        return $this->andWithString($condition, ...$values);
    }
806668
public function having($conditions, $parameters = [])
	{
		$this->having = [];

		if (!empty($conditions)) {
			$this->addHaving($conditions, $parameters);
		}

		return $this;
	}
561945
public function removeCondition($condition)
    {
        if ($this->conditions->contains($condition)) {
            $this->conditions->removeElement($condition);
        }

        return $this;
    }
131838
public function andBinaryBody(Condition $condition)
    {
        $this->bodyCondition = new BodyCondition(
            $condition->getMatcher(),
            new BinaryBody($condition->getValue())
        );

        return $this;
    }
763147
public static function create($condition): self
    {
        $condition = $condition instanceof Condition ? $condition : Condition::fromValue($condition);

        return new self($condition);
    }
341297
public function filter( $condition ) {
		$storage = array();

		foreach ( $this->storage as $key => $value ) {
			if ( call_user_func( $condition, $value, $key ) ) {
				$storage[ $key ] = $value;
			}
		}

		return new static( $this->get_key_type(), $this->get_value_type(), $storage );
	}
1239972
public function having()
    {
        $args = func_get_args();
        $count = count($args);
        
        if ($count == 1) {
            $this->having[] = $args[0];
        } else {
            $this->having[] = array_shift($args);
            
            if ($count == 2 && is_array($args[0]))
                $args = $args[0];
            
            if ($args)
                $this->having_params = array_merge($this->having_params, $args);
        }
        return $this;
    }
817445
public function orWithString(string $condition, ...$values): self
    {
        $this->parts[] = [
            'type' => 'OR',
            'condition' => $condition,
            'values' => $values,
        ];

        return $this;
    }
1208833
public function having($conditions): self
    {
        if ($conditions[0] instanceof Closure) {
            $this->addClauseCondClosure('having', 'AND', $conditions[0]);

            return $this;
        }
        $this->having[] = ['and', $conditions];

        return $this;
    }
1182696
public function having($column, Closure $value = null): self
    {
        $this->getHavingStatement()->having($column, $value);
        return $this;
    }