Adds to a "HAVING" condition that will be "AND"ed with other conditions

@param array $conditions,... A variable list of conditions to be met
@return self For method chaining
355111
public function andHaving(...$conditions) : self
    {
        $this->havingConditions = $this->conditionalQueryBuilder->addConditionToClause(
            $this->havingConditions, 'AND', ...$this->createConditionExpressions($conditions)
        );

        return $this;
    }
817445
public function orWithString(string $condition, ...$values): self
    {
        $this->parts[] = [
            'type' => 'OR',
            'condition' => $condition,
            'values' => $values,
        ];

        return $this;
    }
232105
public function andHaving(...$conditions): Select
    {
        $condition = $this->prepareCondition($conditions);

        if ($this->having instanceof CompositeBuilder
            && $this->having->getType() === 'AND') {
            $this->having->addPart($condition);
        } else {
            $this->having = new CompositeBuilder([$this->having, $condition]);
        }
        return $this;
    }
1248454
public function merge(Condition $condition)
    {
        $this->expressions = array_merge($this->expressions, $condition->toArray());

        return $this;
    }
922938
public function addHaving(array $having): void
    {
        if (empty($having)) {
            return;
        }

        $firstClause = true;
        $this->statement .= ' HAVING ';
        foreach ($having as $clause) {
            if ($firstClause === false) {
                $this->statement .= ' ' . $clause['concatenator'] . ' ';
            }
            $placeholder = $this->addBindingValue($clause['key'], $clause['value']);
            $key = $this->quoteName($clause['key']);
            $this->statement .= sprintf('%s %s %s', $key, $clause['operator'], $placeholder);
            $this->statement .= PHP_EOL;
            $firstClause = false;
        }
    }
423197
public function orHaving($having)
    {
        $args   = func_get_args();
        $having = $this->getQueryPart('having');

        if ($having instanceof CompositeExpression && $having->getType() === CompositeExpression::TYPE_OR) {
            $having->addMultiple($args);
        } else {
            array_unshift($args, $having);
            $having = new CompositeExpression(CompositeExpression::TYPE_OR, $args);
        }

        return $this->add('having', $having);
    }
347331
protected function arrayToConditions($conditions)
    {
        $ret = [];

        foreach ($conditions as $key => $value) {
            if ($value instanceof Condition) {
                $ret[] = $value;
                continue;
            }

            $propertyOperator = explode('-', $key);

            if (in_array(count($propertyOperator), [1, 2])) {
                $ret[] = new Condition($propertyOperator[0], $value, $propertyOperator[1] ?? null);
            }
        }

        return $ret;
    }
20472
public function whereGroup($conditions, $logic = 'AND')
    {
        $whereGroup = $this->_append('Where_Group', $conditions, $logic);
        if ($group = $whereGroup->__toString()) {
            $this->where('(' . $group . ')', null, $logic);
        }

        return $this;
    }
590525
public function addCondition( $condition )
	{
		if( is_array( $condition ) )
			return $this->addConditions( $condition );
		if( in_array( $condition, $this->conditions ) )
			return FALSE;
		$this->conditions[] = $condition;
		return TRUE;
	}
962531
public function set($condition, array $params = [])
    {
        $this->conditions = [];
        $this->add($condition, $params);
        return $this;
    }
989415
public function addCondition($condition)
    {
        if (!$this->conditions->contains($condition)) {
            $this->conditions[] = $condition;
        }

        return $this;
    }
1195399
public function having(...$args): self
    {
        $this->createToken('AND', $args, $this->havingTokens, $this->havingWrapper());

        return $this;
    }
313159
public function havingRaw(string $condition): self
    {
        $this->condition->having([new RawExp($condition)]);

        return $this;
    }
293805
public function where($conditions)
    {
        if ($conditions = is_array($conditions) && func_num_args() === 1 ? $conditions : func_get_args()) {
            $this->_parts['where'][] = $conditions;
        }
        return $this;
    }
189611
public function having($having)
    {
        if (! (func_num_args() === 1 && ($having instanceof Expr\Andx || $having instanceof Expr\Orx))) {
            $having = new Expr\Andx(func_get_args());
        }

        return $this->add('having', $having);
    }
1317331
public function withSettings(array $settings): self
    {
        $this->settings = [];
        foreach ($settings as $name => $value) {
            $this->withSetting($name, $value);
        }

        return $this;
    }
806668
public function having($conditions, $parameters = [])
	{
		$this->having = [];

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

		return $this;
	}