Adds a raw HAVING clause.

@param  string $raw       Raw SQL
@param  string $operator  Operator
@param  mixed  $value     Value
@param  string $separator Clause separator
@return $this
969612
public function havingRaw($raw, $operator, $value, string $separator = 'AND')
	{
		return $this->having(new Raw($raw), $operator, $value, $separator);
	}
1151384
public function condition($field, $value = NULL, $operator = NULL)
    {
        $this->condition->condition($field, $value, $operator);
        return $this;
    }
1097705
function addOr($column, $value = null, $operator = self::EQUAL, $quote = null) {
		if (func_num_args() === 1) {
			$this->where->addOr($column);
		} else {
			$this->where->addOr($column, $value, $operator, $quote);
		}
		return $this;
	}
1328784
function having(column, operator, value) {
    if (column instanceof Raw && arguments.length === 1) {
      return this._havingRaw(column);
    }

    // Check if the column is a function, in which case it's
    // a having statement wrapped in parens.
    if (typeof column === 'function') {
      return this.havingWrapped(column);
    }

    this._statements.push({
      grouping: 'having',
      type: 'havingBasic',
      column: column,
      operator: operator,
      value: value,
      bool: this._bool()
    });
    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;
    }
807880
public function having($function, $column, $operator, $value)
    {
        $placeholder = $this->getUniqPlaceholder();

        $this->queryBuilder->having($function, $column, $operator, $placeholder);
        $this->bind($placeholder, $value);

        return $this;
    }
690466
public function where($column, $value = '', $operator = Criterion::EQUALS, $variable = null, $additional = null, $special = null): self
        {
            if (!$column instanceof CriterionProvider) {
                $column = new Criterion($column, $value, $operator, $variable, $additional, $special);
            }

            $this->parts[] = $column;

            return $this;
        }
147744
public function raw($value, $format = '%s')
	{
		array_push($this->pattern, sprintf($format, $value));

		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;
    }
1195276
public function where($field, $operator = null, $value = null) {
        if (strlen($field) && is_null($operator) && is_null($value)) {
            // For RAW string
            array_push($this->_where, $field);
        } else {
            if (is_null($value)) {
                $value = $operator;
                $operator = '=';
            }

            if (is_array($value)) {
                $str = '(';
                
                for ($i = 0; $i < count($value); $i++) {
                    $d = $value[$i];
                    $str .= is_numeric($d) ? $d : "'$d'";
                    $str .= count($value) === $i + 1 ? '' : ', ';
                }
                
                $str .= ')';
                
                $value = $str;
                
                array_push($this->_where, $field . ' ' . $operator . $value);
            } else {
                $value = (string)$value;
                array_push($this->_where, $field . ' ' . $operator . (!strcasecmp($operator, 'in') ? " ($value)" : ' \'' . $value . '\''));
            }
        }
        
        return $this;
    }
593292
public function havingRaw(string $raw, string $logicalOperator = LogicalOperator::AND)
    {
        $having = new Having();
        $having->useRaw();
        $having->setRawSQL($raw);
        $having->setLogicalOperator($logicalOperator);
        $this->option->having[] = $having;
        return $this;
    }
1197241
public function orWhereRaw($column, $operator = null, ?string $raw = null)
	{
		return $this->whereRaw($column, $operator, $raw, 'OR');
	}
517846
public function orWhere($column, $value, $operator = self::OPERATOR_EQ): self
    {
        $this->criteria($this->where, $column, $value, $operator, self::LOGICAL_OR);

        return $this;
    }
438931
public function addFilter($column, $operator, $value)
    {
        $this->filter->addFilter($column, $operator, $value);
        return $this;
    }
514831
public function where($column, $operator, $value, $quoted = false)
    {
        $this->where[] = array(
            'column' => $column,
            'operator' => $operator,
            'value' => $value,
            'quoted' => $quoted
        );
        return $this;
    }
1085070
public function where($column, $operator, $value = null)
    {
        $this->wConditions()->column(...func_get_args());

        return $this;
    }
808066
function _havingRaw(sql, bindings) {
    var raw = sql instanceof Raw ? sql : this.client.raw(sql, bindings);
    this._statements.push({
      grouping: 'having',
      type: 'havingRaw',
      value: raw,
      bool: this._bool()
    });
    return this;
  }