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



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

Expression helper passed to typed WHERE callbacks.

## Type Parameters [#type-parameters]

| Type Parameter                      | Default type |
| ----------------------------------- | ------------ |
| `DB`                                | -            |
| `TB` *extends* keyof `DB`           | -            |
| `AllowSemiJoin` *extends* `boolean` | `true`       |

## Call Signature [#call-signature]

```ts
ExpressionBuilder<Output, Sortable>(
   lhs,
   op,
   rhs
): ExpressionWrapper<DB, TB, false>;
```

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

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

| Type Parameter                 |
| ------------------------------ |
| `Output`                       |
| `Sortable` *extends* `boolean` |

### Parameters [#parameters]

| Parameter | Type                                                                                                                          |
| --------- | ----------------------------------------------------------------------------------------------------------------------------- |
| `lhs`     | [`DistanceFunctionExpression`](/docs/core/reference/api/interfaces/DistanceFunctionExpression)\<`Output`, `true`, `Sortable`> |
| `op`      | [`DistanceComparisonOperator`](/docs/core/reference/api/type-aliases/DistanceComparisonOperator)                              |
| `rhs`     | `number`                                                                                                                      |

### Returns [#returns]

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

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

```ts
ExpressionBuilder<Output, Value, AllowedOperator, Operator, Identity, Right>(
   lhs,
   op,
   rhs
): ExpressionWrapper<DB, TB, false>;
```

Builds a typed `WHERE` 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)        |
| `Identity` *extends* `string`                                                                                |
| `Right`                                                                                                      |

### Parameters [#parameters-1]

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

### Returns [#returns-1]

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

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

```ts
ExpressionBuilder<Reference, Operator, Right>(
   lhs,
   op,
   rhs
): ExpressionWrapper<DB, TB, false>;
```

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

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

| Type Parameter                                                                                                   |
| ---------------------------------------------------------------------------------------------------------------- |
| `Reference` *extends* `string`                                                                                   |
| `Operator` *extends* `"="` \| `"!="` \| `"like"`                                                                 |
| `Right` *extends* `string` \| [`SoqlLikeLiteral`](/docs/core/reference/api/interfaces/SoqlLikeLiteral) \| `null` |

### Parameters [#parameters-2]

| Parameter | Type                                                                                                                   |
| --------- | ---------------------------------------------------------------------------------------------------------------------- |
| `lhs`     | [`ToLabelFilterFunctionExpression`](/docs/core/reference/api/interfaces/ToLabelFilterFunctionExpression)\<`Reference`> |
| `op`      | `Operator`                                                                                                             |
| `rhs`     | `Right`                                                                                                                |

### Returns [#returns-2]

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

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

```ts
ExpressionBuilder<Value, Operator>(
   lhs,
   op,
   rhs
): ExpressionWrapper<DB, TB, false>;
```

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

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

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

### Parameters [#parameters-3]

| Parameter | Type                                                                                                               |
| --------- | ------------------------------------------------------------------------------------------------------------------ |
| `lhs`     | [`FormulaFilterFunctionExpression`](/docs/core/reference/api/interfaces/FormulaFilterFunctionExpression)\<`Value`> |
| `op`      | `Operator`                                                                                                         |
| `rhs`     | `Value`                                                                                                            |

### Returns [#returns-3]

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

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

```ts
ExpressionBuilder<RE, OP, RHS>(
   lhs,
   op,
   rhs
): ExpressionWrapper<DB, TB, SemiJoinFlag<RHS>>;
```

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

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

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

### Parameters [#parameters-4]

| Parameter | Type                                            |
| --------- | ----------------------------------------------- |
| `lhs`     | `RE` & `FilterableFieldName`\<`DB`, `TB`, `RE`> |
| `op`      | `OP`                                            |
| `rhs`     | `RHS`                                           |

### Returns [#returns-4]

[`ExpressionWrapper`](/docs/core/reference/api/interfaces/ExpressionWrapper)\<`DB`, `TB`, `SemiJoinFlag`\<`RHS`>>

## Methods [#methods]

<a id="api-and" />

### and() [#and]

```ts
and<Expressions>(expressions): ExpressionWrapper<DB, TB, CombinedSemiJoinFlag<Expressions>>;
```

Combines two or more expressions with boolean `AND`.

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

| Type Parameter                                                                                                                                                                                                                                                                                                                                       |
| ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `Expressions` *extends* readonly \[[`ExpressionWrapper`](/docs/core/reference/api/interfaces/ExpressionWrapper)\<`DB`, `TB`, `boolean`>, [`ExpressionWrapper`](/docs/core/reference/api/interfaces/ExpressionWrapper)\<`DB`, `TB`, `boolean`>, [`ExpressionWrapper`](/docs/core/reference/api/interfaces/ExpressionWrapper)\<`DB`, `TB`, `boolean`>] |

#### Parameters [#parameters-5]

| Parameter     | Type          |
| ------------- | ------------- |
| `expressions` | `Expressions` |

#### Returns [#returns-5]

[`ExpressionWrapper`](/docs/core/reference/api/interfaces/ExpressionWrapper)\<`DB`, `TB`, `CombinedSemiJoinFlag`\<`Expressions`>>

***

<a id="api-not" />

### not() [#not]

```ts
not(expression): ExpressionWrapper<DB, TB, false>;
```

Negates an expression with boolean `NOT`.

#### Parameters [#parameters-6]

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

#### Returns [#returns-6]

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

***

<a id="api-or" />

### or() [#or]

```ts
or(expressions): ExpressionWrapper<DB, TB, false>;
```

Combines two or more expressions with boolean `OR`.

#### Parameters [#parameters-7]

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

#### Returns [#returns-7]

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

## Properties [#properties]

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