# How Equal To Checks Work

Source: https://userguide.qualytics.io/data-quality-checks/equal-to/deep-dive/how-it-works/

## Definition

*Asserts that every selected numeric field equals a configured value on every row.*

## Overview

The Equal To rule pins one or more numeric fields to a constant. Each selected field must equal the configured **Value** on every row; when several fields are selected they are asserted together, so a row passes only when all of them match.

An optional **Numeric** comparator adds a tolerance, which is what makes the rule usable on computed values: an exact equality on a number that went through a division or an accumulation almost never holds.

Typical use cases:

- Pin a column that should never vary, such as a version marker or a fixed rate.
- Confirm a computed balance or delta lands exactly on its expected value.
- Catch a field that drifted away from the constant a configuration guarantees.

## Field Scope

**Multiple:** The rule accepts one or more numeric fields, asserted together. A row passes only when every selected field equals the value.

**Accepted Types**

| Type | Supported |
| --- | --- |
| `Integral` | Yes |
| `Fractional` | Yes |

## Anomaly Types

| Type | Supported |
| --- | --- |
| Record Flag inconsistencies at the row level | Supported |
| Shape Flag inconsistencies in the overall patterns and distributions of a field | Supported |

## Evaluation Flow

Every Equal To check follows the same four-step evaluation flow:

1. **Apply the filter clause.** If the check has a `filter` set, only rows matching the filter expression continue to the next step. Rows outside the filter are ignored and cannot contribute to the violation count.
2. **Read the selected fields.** The platform reads every field listed on the check for the current row.
3. **Compare each one against the value.** A row passes when all of them are present and equal **Value**; a `NULL` in any selected field fails the row. When a **Numeric** comparator is configured, the margin is applied before the comparison, so a near-miss inside the margin still passes, and a row whose selected fields are all NULL passes as well (see [NULL Handling](https://userguide.qualytics.io/data-quality-checks/equal-to/deep-dive/how-it-works/#null-handling)).
4. **Apply coverage.** At 100% coverage, any failing row causes the check to fail. Below 100% coverage, the check fails only when the passing fraction drops below the threshold (see [Coverage and Tolerance](https://userguide.qualytics.io/data-quality-checks/equal-to/deep-dive/how-it-works/#coverage-and-tolerance)).

## Exact Equality Is Fragile on Computed Numbers

A value that went through a division, a currency conversion, or an accumulation rarely lands on an exact constant, even when the business result is right. Without a tolerance the check reports every one of those rows.

Set the **Numeric** comparator when the field is computed: an absolute margin for money (`0.01`), a relative one when the magnitudes vary widely. Leave it empty only when the value is written directly and must match bit for bit.

## Several Fields Are Asserted Together

Selecting more than one field means *all of them* must equal the value on the same row. That is compact when a group of columns shares one constant, and misleading when they do not: a row is reported as soon as one of them differs, and the message names the field that failed. Split the check when the fields have different owners or different expected values.

## NULL Handling

Without a **Numeric** comparator the check **fails on NULL**. Each selected field is asserted as *present and equal to the value*, so a row with `NULL` in any selected field is counted as a violation exactly like a row carrying the wrong number.

Setting a **Numeric** comparator changes this. The tolerant comparison passes a row where *every* selected field is NULL, and fails a row where only some of them are. On a single-field check that means a NULL row passes.

Because the default already requires the field to be populated, a separate [Not Null](https://userguide.qualytics.io/data-quality-checks/not-null/introduction/) check is only worth adding when you want the missing values reported as their own anomalies, or when a **Numeric** comparator is in play and NULL rows would otherwise go unreported.

## The Filter Clause

The filter clause is a SQL `WHERE` expression applied **before** the evaluation. Filtered-out rows are ignored entirely (they cannot trigger a violation and are not counted in the totals).

When a filter is set, the message names it at the end of its first sentence, as `(applied to records where <expression>)`. Record and Shape Anomaly messages both carry it.

## Coverage and Tolerance

Coverage is a fractional value between `0` and `1` that defines the minimum fraction of evaluated rows that must pass:

- **`1.0` (100%, default):** every row in the filtered set must pass. Any failing row causes the check to fail. This is the strictest setting.
- **`< 1.0`:** the check tolerates a fraction of rows failing. The check fails only when the fraction of passing rows drops below the threshold.

Lower coverage values are useful when a small, known fraction of failures is expected. Use coverage carefully: a 0.5% tolerance can mask a real regression that happens to fall just under the threshold.

## See Also

- **Anomaly Reporting**

  The anomaly messages the check produces, what the numbers mean, Source Records highlighting, and Custom Anomaly Description.

  [Anomaly Reporting](https://userguide.qualytics.io/data-quality-checks/equal-to/deep-dive/anomaly-reporting/)
- **Examples**

  Three production scenarios with sample data, anomaly messages, and the SQL equivalent of what the check evaluates.

  [Examples](https://userguide.qualytics.io/data-quality-checks/equal-to/deep-dive/examples/)
- **Best Practices**

  Guidelines for pinning constants, using tolerance, and choosing between Equal To and its alternatives.

  [Best Practices](https://userguide.qualytics.io/data-quality-checks/equal-to/deep-dive/best-practices/)
- **Permissions**

  The team permission each action needs: view, create, edit, archive, restore, and delete.

  [Permissions](https://userguide.qualytics.io/data-quality-checks/equal-to/deep-dive/permissions/)

*Last updated: September 22, 2026.*
