# How Less Than Checks Work

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

## Definition

*Asserts that every value in a numeric field is less than a configured threshold.*

## Overview

The Less Than rule compares a single numeric field against a fixed threshold. Each row passes when its value is less than the configured **Value**. The **Inclusive** setting decides whether a value exactly equal to the threshold passes (<=) or fails (<). An optional **Numeric** comparator adds a tolerance, so values that miss the threshold by less than the configured margin are still accepted.

Typical use cases:

- Enforce a latency, cost, or size budget, deciding whether the budget value itself is already a breach.
- Cap a rate or a ratio while tolerating the floating-point error a computation introduces.
- Express a policy limit such as a maximum discount or a maximum retry count.

## Field Scope

**Single:** The rule evaluates exactly one field per check.

**Accepted Types**

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

## General Properties

**Tab: Details**

| Name | Supported |
| --- | --- |
| Filter  Allows the targeting of specific data based on conditions | Supported |
| Coverage Customization  Allows adjusting the percentage of records that must meet the rule's conditions | Supported |

**Tab: Filter Guide**

The filter allows you to define a subset of data upon which the rule will operate.

It requires a valid **Spark SQL** expression that determines the criteria rows in the DataFrame should meet. This means the expression specifies which rows the DataFrame should include based on those criteria. Since it's applied directly to the Spark DataFrame, traditional SQL constructs like WHERE clauses **are not** supported.

> **Example: Examples**
>
> **Direct Conditions**
>
> Simply specify the condition you want to be met.
>
> > **Success: Correct usage" collapsible="true**
> >
> > ```sql
> > O_TOTALPRICE > 1000
> > ```
> >
> > ```sql
> > C_MKTSEGMENT = 'BUILDING'
> > ```
>
> > **Failure: Incorrect usage" collapsible="true**
> >
> > ```sql
> > WHERE O_TOTALPRICE > 1000
> > ```
> >
> > ```sql
> > WHERE C_MKTSEGMENT = 'BUILDING'
> > ```
>
> **Combining Conditions**
>
> Combine multiple conditions using logical operators like `AND` and `OR`.
>
> > **Success: Correct usage" collapsible="true**
> >
> > ```sql
> > O_ORDERPRIORITY = '1-URGENT' AND O_ORDERSTATUS = 'O'
> > ```
> >
> > ```sql
> > (L_SHIPDATE = '1998-09-02' OR L_RECEIPTDATE = '1998-09-01') AND L_RETURNFLAG = 'R'
> > ```
>
> > **Failure: Incorrect usage" collapsible="true**
> >
> > ```sql
> > WHERE O_ORDERPRIORITY = '1-URGENT' AND O_ORDERSTATUS = 'O'
> > ```
> >
> > ```sql
> > O_TOTALPRICE > 1000, O_ORDERSTATUS = 'O'
> > ```
>
> **Utilizing Functions**
>
> Leverage Spark SQL functions to refine and enhance your conditions.
>
> > **Success: Correct usage" collapsible="true**
> >
> > ```sql
> > RIGHT(
> >     O_ORDERPRIORITY,
> >     LENGTH(O_ORDERPRIORITY) - INSTR('-', O_ORDERPRIORITY)
> > ) = 'URGENT'
> > ```
> >
> > ```sql
> > LEVENSHTEIN(C_NAME, 'Supplier#000000001') < 7
> > ```
>
> > **Failure: Incorrect usage" collapsible="true**
> >
> > ```sql
> > RIGHT(
> >     O_ORDERPRIORITY,
> >     LENGTH(O_ORDERPRIORITY) - CHARINDEX('-', O_ORDERPRIORITY)
> > ) = 'URGENT'
> > ```
> >
> > ```sql
> > EDITDISTANCE(C_NAME, 'Supplier#000000001') < 7
> > ```
>
> **Using scan-time variables**
>
> To refer to the current dataframe being analyzed, use the reserved dynamic variable `{{_qualytics_self}}`.
>
> > **Success: Correct usage" collapsible="true**
> >
> > ```sql
> > O_ORDERSTATUS IN (
> >     SELECT DISTINCT O_ORDERSTATUS
> >     FROM {{_qualytics_self}}
> >     WHERE O_TOTALPRICE > 1000
> > )
> > ```
>
> > **Failure: Incorrect usage" collapsible="true**
> >
> > ```sql
> > O_ORDERSTATUS IN (
> >     SELECT DISTINCT O_ORDERSTATUS
> >     FROM ORDERS
> >     WHERE O_TOTALPRICE > 1000
> > )
> > ```
>
> While subqueries can be useful, their application within filters in our context has limitations. For example, directly referencing other containers or the broader target container in such subqueries **is not supported**. Attempting to do so will result in an error.
>
> > **Warning: Important Note on {{_qualytics_self}}**
> >
> > The `{{_qualytics_self}}` keyword refers to the dataframe that's currently under examination. In the context of a full scan, this variable represents the entire target container. However, during incremental scans, it only reflects a subset of the target container, capturing just the incremental data. It's crucial to recognize that in such scenarios, using `{{_qualytics_self}}` may not encompass all entries from the target container.

## Specific Properties

Less Than has three rule-specific properties:

| Name | Description |
| --- | --- |
| Value | The threshold the field is compared against. |
| Inclusive | Whether a value exactly equal to **Value** passes. On, the comparison is `<=`; off, it is `<`. |
| Numeric | An optional tolerance applied before the comparison, so values that miss the threshold by less than the margin still pass. The margin can be absolute or a percentage of the value. |

## 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 Less Than 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 field value.** The platform reads the numeric value for the current row.
3. **Compare against the threshold.** With no tolerance configured, the row passes when the value is less than **Value**, using `<=` or `<` depending on the **Inclusive** setting. With a tolerance, the margin is subtracted from the row's value before the comparison runs, which effectively raises the ceiling by the margin.
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/less-than/deep-dive/how-it-works/#coverage-and-tolerance)).

## Inclusivity

The **Inclusive** setting changes what happens exactly at the threshold. With it on, the comparison is `<=` and a value equal to **Value** passes. With it off, the comparison is `<` and that same value is flagged. When the threshold is a service level objective, decide explicitly whether hitting it exactly counts as a breach, and record that decision in the check's description.

## The Numeric Comparator

The optional **Numeric** comparator gives the comparison a tolerance. The margin is subtracted from the row's value before the threshold is applied (`row_value - margin < Value`), so a value that overshoots **Value** by less than the margin still passes. The margin can be **absolute** (a fixed amount) or **relative** (a percentage of the value being compared), which matters when the magnitudes in the column vary widely.

Use it for measures where tiny deviations are noise rather than defects, such as amounts that accumulate rounding through a pipeline. Leave it empty when the threshold is a hard limit.

## NULL Handling

The check **passes NULL values**: a row with `NULL` in the evaluated field is not counted as a violation. Less Than only asserts that *present* values satisfy the comparison.

If the field must also be populated, pair it with a [Not Null](https://userguide.qualytics.io/data-quality-checks/not-null/introduction/) check on the same field.

## Numeric Fields Inside an Array

Less Than has no array-element mode. It accepts `Integral` and `Fractional` fields only, so an array column cannot be selected, and anything else is rejected with `422`. A numeric field nested inside an array of structs is stored as an array, so it is excluded too. To check the numbers inside an array element by element, use [Between](https://userguide.qualytics.io/data-quality-checks/between/introduction/), [Not Negative](https://userguide.qualytics.io/data-quality-checks/not-negative/introduction/), or [Positive](https://userguide.qualytics.io/data-quality-checks/positive/introduction/), which support array elements.

## 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/less-than/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/less-than/deep-dive/examples/)
- **Best Practices**

  Guidelines for setting the threshold, using inclusivity and tolerance, and keeping the signal clean.

  [Best Practices](https://userguide.qualytics.io/data-quality-checks/less-than/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/less-than/deep-dive/permissions/)

*Last updated: October 19, 2026.*
