设置 having 条件，使用 IHaving 结构
@param IHaving $having
@param string $logicalOperator
@return static
491914
public function havingStruct(IHaving $having, string $logicalOperator = LogicalOperator::AND)
    {
        $this->option->having[] = $having;
        return $this;
    }
707217
public function havingBrackets(callable $callback, string $logicalOperator = LogicalOperator::AND)
    {
        $this->option->having[] = new HavingBrackets($callback, $logicalOperator);
        return $this;
    }
969612
public function havingRaw($raw, $operator, $value, string $separator = 'AND')
	{
		return $this->having(new Raw($raw), $operator, $value, $separator);
	}
425293
public function having($function, $column, $operator, $value)
    {
        $this->append(sprintf(' HAVING %s(%s) %s %s ', $function, $column, $operator, $value));
        return $this;
    }
660917
public function having($field, $condition = false, $operator = '=')
    {
        if (func_num_args() >= 2) {
            $this->having->addCondition($field, $condition, $operator);
        } else {
            $this->having->addCondition($field);
        }

        return $this;
    }
450439
public function havingRelation($column1, $operator, $column2 = null)
    {
        $instance = $this->havingStrategyInstance();

        $instance->havingStrategy()->havingRelation(...func_get_args());

        return $instance;
    }
131560
public function orHaving($column, $value, $operator = self::EQUALS, $quote = null)
    {
        return $this->orCriteria($this->having, $column, $value, $operator, self::LOGICAL_OR, $quote);
    }
1086336
public SqlBuilder having(String having) {
		if (StrUtil.isNotBlank(having)) {
			sql.append(" HAVING ").append(having);
		}
		return this;
	}
898737
public function whereStruct(IBaseWhere $where, string $logicalOperator = LogicalOperator::AND)
    {
        $this->option->where[] = $where;
        return $this;
    }
1307799
public function having($column, $op, $value = null)
    {
        return $this->andHaving($column, $op, $value);
    }
1063826
public function andHaving($having)
    {
        $args   = func_get_args();
        $having = $this->getQueryPart('having');

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

        return $this->add('having', $having);
    }
1290160
protected function compileBasicHaving($having)
	{
		$column = $this->wrap($having['column']);

		$parameter = $this->parameter($having['value']);

		return 'and '.$column.' '.$having['operator'].' '.$parameter;
	}
1153319
public function having($key, $op, $val, $type = "AND")
    {
        $key = $this->formatColumn($key);
        $this->_sql['having'][] = [$key, $op, $val, $type];
        return $this;
    }
311281
public function having($column, $operator = '=', $value, $logic = 'AND')
    {
        $having = $this->sql['having'] == '' ? 'HAVING' : " {$logic} ";
        $this->sql['having'] .= "{$having} {$column} {$operator} ";
        if ($value) {
            if (is_array($value)) {//手动传%s
                $this->bindParams = array_merge($this->bindParams, $value);
            } else {
                $this->sql['having'] .= ' %s ';
                $this->bindParams[] = $value;
            }
        }
        return $this;
    }
1261272
public function having($column, $operator, $value = null)
    {
        $this->hConditions()->column(...func_get_args());

        return $this;
    }
1301587
public function orHaving($having)
    {
        $args   = func_get_args();
        $having = $this->getDQLPart('having');

        if ($having instanceof Expr\Orx) {
            $having->addMultiple($args);
        } else {
            array_unshift($args, $having);
            $having = new Expr\Orx($args);
        }

        return $this->add('having', $having);
    }
753064
@NonNull
    @Override
    public Having having(@NonNull Expression expression) {
        if (expression == null) {
            throw new IllegalArgumentException("expression cannot be null.");
        }
        return new Having(this, expression);
    }