# HavingExpressionBuilder (/docs/core/reference/api/interfaces/HavingExpressionBuilder)



[@kysoql/core](/docs/core/reference/api) / HavingExpressionBuilder

Expression helper passed to typed HAVING callbacks.

## Type Parameters [#type-parameters]

| Type Parameter                      | Default type |
| ----------------------------------- | ------------ |
| `DB`                                | -            |
| `TB` *extends* keyof `DB`           | -            |
| `GroupedBy` *extends* `string`      | -            |
| `GroupingFields` *extends* `string` | `never`      |

## Call Signature [#call-signature]

```ts
HavingExpressionBuilder<Reference, Operator, Right>(
   lhs,
   op,
   rhs
): HavingExpressionWrapper<DB, TB, GroupedBy>;
```

Builds a typed `HAVING` comparison from the supplied left operand, operator, and right operand.

### Type Parameters [#type-parameters-1]

| Type Parameter                                                                                                                                                                                                                                                                          |
| --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `Reference` *extends* `string`                                                                                                                                                                                                                                                          |
| `Operator` *extends* \| `"="` \| `"!="` \| [`OrderedComparisonOperator`](/docs/core/reference/api/type-aliases/OrderedComparisonOperator) \| `"in"` \| `"not in"` \| [`MultiSelectComparisonOperator`](/docs/core/reference/api/type-aliases/MultiSelectComparisonOperator) \| `"like"` |
| `Right`                                                                                                                                                                                                                                                                                 |

### Parameters [#parameters]

| Parameter | Type                                                                                                                                          |
| --------- | --------------------------------------------------------------------------------------------------------------------------------------------- |
| `lhs`     | `Reference` & [`GroupedHavingFieldName`](/docs/core/reference/api/type-aliases/GroupedHavingFieldName)\<`DB`, `TB`, `GroupedBy`, `Reference`> |
| `op`      | `Operator`                                                                                                                                    |
| `rhs`     | `Right`                                                                                                                                       |

### Returns [#returns]

[`HavingExpressionWrapper`](/docs/core/reference/api/interfaces/HavingExpressionWrapper)\<`DB`, `TB`, `GroupedBy`>

## Call Signature [#call-signature-1]

```ts
HavingExpressionBuilder<Output, Value, AllowedOperator, Operator, Right>(
   lhs,
   op,
   rhs
): HavingExpressionWrapper<DB, TB, GroupedBy>;
```

Builds a typed `HAVING` comparison from the supplied left operand, operator, and right operand.

### Type Parameters [#type-parameters-2]

| Type Parameter                                                                                               |
| ------------------------------------------------------------------------------------------------------------ |
| `Output`                                                                                                     |
| `Value`                                                                                                      |
| `AllowedOperator` *extends* [`ComparisonOperator`](/docs/core/reference/api/type-aliases/ComparisonOperator) |
| `Operator` *extends* [`ComparisonOperator`](/docs/core/reference/api/type-aliases/ComparisonOperator)        |
| `Right`                                                                                                      |

### Parameters [#parameters-1]

| Parameter | Type                                                                                                                                    |
| --------- | --------------------------------------------------------------------------------------------------------------------------------------- |
| `lhs`     | [`AggregateFunctionExpression`](/docs/core/reference/api/interfaces/AggregateFunctionExpression)\<`Output`, `Value`, `AllowedOperator`> |
| `op`      | `Operator`                                                                                                                              |
| `rhs`     | `Right`                                                                                                                                 |

### Returns [#returns-1]

[`HavingExpressionWrapper`](/docs/core/reference/api/interfaces/HavingExpressionWrapper)\<`DB`, `TB`, `GroupedBy`>

## Call Signature [#call-signature-2]

```ts
HavingExpressionBuilder<Output, Value, AllowedOperator, Identity, Operator, Right>(
   lhs,
   op,
   rhs
): HavingExpressionWrapper<DB, TB, GroupedBy>;
```

Builds a typed `HAVING` comparison from the supplied left operand, operator, and right operand.

### Type Parameters [#type-parameters-3]

| Type Parameter                                                                                               |
| ------------------------------------------------------------------------------------------------------------ |
| `Output`                                                                                                     |
| `Value`                                                                                                      |
| `AllowedOperator` *extends* [`ComparisonOperator`](/docs/core/reference/api/type-aliases/ComparisonOperator) |
| `Identity` *extends* `string`                                                                                |
| `Operator` *extends* [`ComparisonOperator`](/docs/core/reference/api/type-aliases/ComparisonOperator)        |
| `Right`                                                                                                      |

### Parameters [#parameters-2]

| Parameter | Type                                                                                                                                      |
| --------- | ----------------------------------------------------------------------------------------------------------------------------------------- |
| `lhs`     | [`DateFunctionExpression`](/docs/core/reference/api/interfaces/DateFunctionExpression)\<`Output`, `Value`, `AllowedOperator`, `Identity`> |
| `op`      | `Operator`                                                                                                                                |
| `rhs`     | `Right`                                                                                                                                   |

### Returns [#returns-2]

[`HavingExpressionWrapper`](/docs/core/reference/api/interfaces/HavingExpressionWrapper)\<`DB`, `TB`, `GroupedBy`>

## Methods [#methods]

<a id="api-and" />

### and() [#and]

```ts
and(expressions): HavingExpressionWrapper<DB, TB, GroupedBy>;
```

Combines two or more expressions with boolean `AND`.

#### Parameters [#parameters-3]

| Parameter     | Type                                                                                                                                                                                                                                                                                                                                                                   |
| ------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `expressions` | readonly \[[`HavingExpressionWrapper`](/docs/core/reference/api/interfaces/HavingExpressionWrapper)\<`DB`, `TB`, `GroupedBy`>, [`HavingExpressionWrapper`](/docs/core/reference/api/interfaces/HavingExpressionWrapper)\<`DB`, `TB`, `GroupedBy`>, [`HavingExpressionWrapper`](/docs/core/reference/api/interfaces/HavingExpressionWrapper)\<`DB`, `TB`, `GroupedBy`>] |

#### Returns [#returns-3]

[`HavingExpressionWrapper`](/docs/core/reference/api/interfaces/HavingExpressionWrapper)\<`DB`, `TB`, `GroupedBy`>

***

<a id="api-not" />

### not() [#not]

```ts
not(expression): HavingExpressionWrapper<DB, TB, GroupedBy>;
```

Negates an expression with boolean `NOT`.

#### Parameters [#parameters-4]

| Parameter    | Type                                                                                                               |
| ------------ | ------------------------------------------------------------------------------------------------------------------ |
| `expression` | [`HavingExpressionWrapper`](/docs/core/reference/api/interfaces/HavingExpressionWrapper)\<`DB`, `TB`, `GroupedBy`> |

#### Returns [#returns-4]

[`HavingExpressionWrapper`](/docs/core/reference/api/interfaces/HavingExpressionWrapper)\<`DB`, `TB`, `GroupedBy`>

***

<a id="api-or" />

### or() [#or]

```ts
or(expressions): HavingExpressionWrapper<DB, TB, GroupedBy>;
```

Combines two or more expressions with boolean `OR`.

#### Parameters [#parameters-5]

| Parameter     | Type                                                                                                                                                                                                                                                                                                                                                                   |
| ------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `expressions` | readonly \[[`HavingExpressionWrapper`](/docs/core/reference/api/interfaces/HavingExpressionWrapper)\<`DB`, `TB`, `GroupedBy`>, [`HavingExpressionWrapper`](/docs/core/reference/api/interfaces/HavingExpressionWrapper)\<`DB`, `TB`, `GroupedBy`>, [`HavingExpressionWrapper`](/docs/core/reference/api/interfaces/HavingExpressionWrapper)\<`DB`, `TB`, `GroupedBy`>] |

#### Returns [#returns-5]

[`HavingExpressionWrapper`](/docs/core/reference/api/interfaces/HavingExpressionWrapper)\<`DB`, `TB`, `GroupedBy`>

## Properties [#properties]

| Property                        | Modifier   | Type                                                                                                                    | Description                                            |
| ------------------------------- | ---------- | ----------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------ |
| <a id="api-property-fn" /> `fn` | `readonly` | [`AggregateFunctionModule`](/docs/core/reference/api/interfaces/AggregateFunctionModule)\<`DB`, `TB`, `GroupingFields`> | Function helpers available in this expression context. |