# Overview

Learn general aspects of logical operations.

This section breaks down how CQL evaluates logical operations across different scenarios and operand types.

## Type conversion

For your convenience, all logical operations automatically convert their operands to boolean values whenever possible.

For example, 0 and 1 are typically used to represent the boolean values false and true, respectively. That is why the following expression is valid:

```cql
1 and true // true
```

Without type conversion, you would have to handle this case manually, which would make your queries more verbose and less readable. For more information about which values can be converted to boolean, see [boolean conversion](/reference/cql/conversions#boolean).

Be aware that not all values can be converted to boolean. However, boolean operations are designed to be error-tolerant and can still return a value, as explained in more detail below.

## Error tolerance

Boolean expressions in CQL are designed to be error-tolerant, meaning that they can handle specific errors by treating the result of the faulty operand as false.

For example, consider the following query:

```cql
page's query's coupon is "10OFF"
```

Without error tolerance, this query would fail if the `coupon` parameter was missing from the query string. To handle this, you would need something like the [`or else`](/reference/cql/expressions/operations/other/fallback) operator to provide a default value:

```cql
(page's query's example or else null) is "10OFF"
```

As you can see, this query is more verbose and less readable than the original. You can still use this approach if you need to handle errors in a specific way, but in most cases, you can rely on error tolerance to simplify your queries.

The errors that are tolerated by boolean expressions include:

- **Undefined values**\
  When a variable, attribute, or parameter is missing.
- **Conversion errors**\
  When a value doesn't satisfy the [boolean conversion](/reference/cql/conversions#boolean) criteria.
- **Comparison errors**\
  When the operands involved in a [comparison](/reference/cql/expressions/operations/comparison) are not comparable.

Depending on the boolean operator, the result of the entire expression may vary:

- In an [*and* operation](/reference/cql/expressions/operations/logical/and), if one of the operands fails, the result will always be `false`, as both expressions must be `true` for the operation to be `true`.
- In an [*or* operation](/reference/cql/expressions/operations/logical/or), if one of the operands succeeds, the result will always be `true`, as only one expression needs to be `true` for the operation to be `true`.
- In a [*not* operation](/reference/cql/expressions/operations/logical/not), if the operand fails, the result will be `true`.

Note that the behavior mentioned above does not differ from the standard behavior of the boolean operators. It is simply a consequence of treating the result of a faulty operand as `false`.

## Short-circuiting

The conjunction and disjunction operations employ [short-circuiting](https://en.wikipedia.org/wiki/Short-circuit_evaluation), an optimization technique that stops evaluating an expression as soon as its result can be determined without evaluating the remaining operands.

This is how short-circuiting works:

- In an [*and* operation](/reference/cql/expressions/operations/logical/and), if the first operand is `false`, the operation will short-circuit and return `false` without evaluating the second operand. This is because the result of an *and* operation is [always `false`](https://en.wikipedia.org/wiki/Logical_conjunction#truth_table) if any of its operands are `false`.
- In a [*or* operation](/reference/cql/expressions/operations/logical/or), if the first operand is `true`, the operation will short-circuit and return `true` without evaluating the second operand. This is because the result of an *or* operation is [always `true`](https://en.wikipedia.org/wiki/Logical_disjunction#semantics) if any of its operands are `true`.

To illustrate the benefits of short-circuiting, consider the following query:

```cql
today's weekday is "monday" and user is returning
```

In this query, we used the `and` operator to combine two conditions: checking if today's weekday is Monday and if a user is returning.

With short-circuiting, if today is not Monday, the CQL engine will not even check the rest. This can be very efficient because checking if a user is returning may involve retrieving user data, which can be time-consuming. This can save resources and increase the efficiency of your queries.