ClickHouse/clickhouse-docs-embeddings huggingface dataset:
quantilesExactInclusive

[Edit this page](https://github.com/ClickHouse/ClickHouse/tree/master/docs/en/sql-reference/aggregate-functions/reference/quantilesExactInclusive.md)

## quantilesExactInclusive[​](#quantilesExactInclusive "Direct link to quantilesExactInclusive")

Introduced in: v20.1.0

Exactly computes multiple [quantiles](https://en.wikipedia.org/wiki/Quantile) of a numeric data sequence at different levels simultaneously using the inclusive method.

This function is equivalent to [`quantileExactInclusive`](/docs/sql-reference/aggregate-functions/reference/quantileExactInclusive) but allows computing multiple quantile levels in a single pass, which is more efficient than calling individual quantile functions.

This function uses the inclusive method for calculating quantiles, as described in the [R-7 method](https://en.wikipedia.org/wiki/Quantile#Estimating_quantiles_from_a_sample).
This is equivalent to [PERCENTILE.INC](https://support.microsoft.com/en-us/office/percentile-inc-function-680f9539-45eb-410b-9a5e-c1355e5fe2ed) Excel function.

To get exact values, all the passed values are combined into an array, which is then partially sorted.
The sorting algorithm's complexity is `O(N·log(N))`, where `N = std::distance(first, last)` comparisons.

**Syntax**

```
quantilesExactInclusive(level1, level2, ...)(expr)
```

**Parameters**

- `level` — Levels of quantiles. Constant floating-point numbers from 0 to 1 (inclusive). We recommend using `level` values in the range of `[0.01, 0.99]`. [`Float*`](/docs/sql-reference/data-types/float)

**Arguments**

- `expr` — Expression over the column values resulting in numeric data types, Date or DateTime. [`(U)Int*`](/docs/sql-reference/data-types/int-uint) or [`Float*`](/docs/sql-reference/data-types/float) or [`Decimal*`](/docs/sql-reference/data-types/decimal) or [`Date`](/docs/sql-reference/data-types/date) or [`DateTime`](/docs/sql-reference/data-types/datetime)

**Returned value**

Array of quantiles of the specified levels in the same order as the levels were specified. [`Array(Float64)`](/docs/sql-reference/data-types/array)

**Examples**

**Computing multiple exact inclusive quantiles**

```
CREATE TABLE num AS numbers(1000);
SELECT quantilesExactInclusive(0.25, 0.5, 0.75, 0.9, 0.95, 0.99, 0.999)(number) FROM num;
```

```
┌─quantilesExactInclusive(0.25, 0.5, 0.75, 0.9, 0.95, 0.99, 0.999)(number)─┐
│ [249.75,499.5,749.25,899.1,949.05,989.01,998.001]                        │
└──────────────────────────────────────────────────────────────────────────┘
```

- [quantilesExactInclusive](#quantilesExactInclusive)

Was this page helpful?
quantilesGK

[Edit this page](https://github.com/ClickHouse/ClickHouse/tree/master/docs/en/sql-reference/aggregate-functions/reference/quantilesGK.md)

## quantilesGK[​](#quantilesGK "Direct link to quantilesGK")

Introduced in: v23.4.0

Computes multiple [quantiles](https://en.wikipedia.org/wiki/Quantile) of a numeric data sequence at different levels simultaneously using the [Greenwald-Khanna](http://infolab.stanford.edu/~datar/courses/cs361a/papers/quantiles.pdf) algorithm.

This function works similarly with [`quantileGK`](/docs/sql-reference/aggregate-functions/reference/quantileGK) but allows computing multiple quantile levels in a single pass, which is more efficient than calling individual quantile functions.

The Greenwald-Khanna algorithm is an algorithm used to compute quantiles on a stream of data in a highly efficient manner.
It was introduced by Michael Greenwald and Sanjeev Khanna in 2001.
The algorithm is highly efficient, taking only O(log n) space and O(log log n) time per item (where n is the size of the input).
It is also highly accurate, providing approximate quantile values with controllable accuracy.

**Syntax**

```
quantilesGK(accuracy, level1, level2, ...)(expr)
```

**Parameters**

- `accuracy` — Accuracy of quantiles. Constant positive integer. Larger accuracy value means less error. For example, if the accuracy argument is set to 100, the computed quantiles will have an error no greater than 1% with high probability. There is a trade-off between the accuracy of the computed quantiles and the computational complexity of the algorithm. [`UInt*`](/docs/sql-reference/data-types/int-uint)
- `level` — Levels of quantiles. One or more constant floating-point numbers from 0 to 1. [`Float*`](/docs/sql-reference/data-types/float)

**Arguments**

- `expr` — Expression over the column values resulting in numeric data types, Date or DateTime. [`(U)Int*`](/docs/sql-reference/data-types/int-uint) or [`Float*`](/docs/sql-reference/data-types/float) or [`Decimal*`](/docs/sql-reference/data-types/decimal) or [`Date`](/docs/sql-reference/data-types/date) or [`DateTime`](/docs/sql-reference/data-types/datetime)

**Returned value**

Array of quantiles of the specified levels in the same order as the levels were specified. [`Array(Float64)`](/docs/sql-reference/data-types/array) or [`Array(Date)`](/docs/sql-reference/data-types/array) or [`Array(DateTime)`](/docs/sql-reference/data-types/array)

**Examples**

**Computing multiple quantiles with GK algorithm**

```
SELECT quantilesGK(1, 0.25, 0.5, 0.75)(number + 1) FROM numbers(1000);
```

```
┌─quantilesGK(1, 0.25, 0.5, 0.75)(plus(number, 1))─┐
│ [1, 1, 1]                                        │
└──────────────────────────────────────────────────┘
```

**Higher accuracy quantiles**

```
SELECT quantilesGK(100, 0.25, 0.5, 0.75)(number + 1) FROM numbers(1000);
```

```
┌─quantilesGK(100, 0.25, 0.5, 0.75)(plus(number, 1))─┐
│ [251, 498, 741]                                    │
└────────────────────────────────────────────────────┘
```

- [quantilesGK](#quantilesGK)

Was this page helpful?
quantilesTimingWeighted

[Edit this page](https://github.com/ClickHouse/ClickHouse/tree/master/docs/en/sql-reference/aggregate-functions/reference/quantilesTimingWeighted.md)

## quantilesTimingWeighted[​](#quantilesTimingWeighted "Direct link to quantilesTimingWeighted")

Introduced in: v1.1.0

Computes multiple [quantiles](https://en.wikipedia.org/wiki/Quantile) of a numeric data sequence at different levels simultaneously with determined precision, taking into account the weight of each sequence member.

This function is equivalent to [`quantileTimingWeighted`](/docs/sql-reference/aggregate-functions/reference/quantiletimingweighted) but allows computing multiple quantile levels in a single pass, which is more efficient than calling individual quantile functions.

The result is deterministic (it does not depend on the query processing order). The function is optimized for working with sequences which describe distributions like loading web pages times or backend response times.

**Accuracy**

The calculation is accurate if:

- Total number of values does not exceed 5670.
- Total number of values exceeds 5670, but the page loading time is less than 1024ms.

Otherwise, the result of the calculation is rounded to the nearest multiple of 16 ms.

Note

For calculating page loading time quantiles, this function is more effective and accurate than [`quantiles`](/docs/sql-reference/aggregate-functions/reference/quantiles).

**Syntax**

```
quantilesTimingWeighted(level1, level2, ...)(expr, weight)
```

**Parameters**

- `level` — Levels of quantiles. One or more constant floating-point numbers from 0 to 1. We recommend using `level` values in the range of `[0.01, 0.99]`. [`Float*`](/docs/sql-reference/data-types/float)

**Arguments**

- `expr` — Expression over a column values returning a Float\*-type number. If negative values are passed to the function, the behavior is undefined. If the value is greater than 30,000 (a page loading time of more than 30 seconds), it is assumed to be 30,000. [`Float*`](/docs/sql-reference/data-types/float)
- `weight` — Column with weights of sequence elements. Weight is a number of value occurrences. [`UInt*`](/docs/sql-reference/data-types/int-uint)

**Returned value**

Array of quantiles of the specified levels in the same order as the levels were specified. [`Array(Float32)`](/docs/sql-reference/data-types/array)

**Examples**

**Computing multiple weighted timing quantiles**

```
SELECT quantilesTimingWeighted(0.5, 0.99)(response_time, weight) FROM t;
```

```
┌─quantilesTimingWeighted(0.5, 0.99)(response_time, weight)─┐
│ [112, 162]                                                │
└───────────────────────────────────────────────────────────┘
```

**See Also**

- [median](/docs/sql-reference/aggregate-functions/reference/median)
- [quantiles](/docs/sql-reference/aggregate-functions/reference/quantiles)

- [quantilesTimingWeighted](#quantilesTimingWeighted)

Was this page helpful?
quantileTDigest

[Edit this page](https://github.com/ClickHouse/ClickHouse/tree/master/docs/en/sql-reference/aggregate-functions/reference/quantileTDigest.md)

## quantileTDigest[​](#quantileTDigest "Direct link to quantileTDigest")

Introduced in: v1.1.0

Computes an approximate [quantile](https://en.wikipedia.org/wiki/Quantile) of a numeric data sequence using the [t-digest](https://github.com/tdunning/t-digest/blob/master/docs/t-digest-paper/histo.pdf) algorithm.

Memory consumption is `log(n)`, where `n` is a number of values. The result depends on the order of running the query, and is nondeterministic.

The performance of the function is lower than performance of [`quantile`](/docs/sql-reference/aggregate-functions/reference/quantile) or [`quantileTiming`](/docs/sql-reference/aggregate-functions/reference/quantiletiming). In terms of the ratio of State size to precision, this function is much better than `quantile`.

When using multiple `quantile*` functions with different levels in a query, the internal states are not combined (that is, the query works less efficiently than it could). In this case, use the [`quantiles`](/docs/sql-reference/aggregate-functions/reference/quantiles#quantiles) function.

**Syntax**

```
quantileTDigest(level)(expr)
```

**Aliases**: `medianTDigest`

**Parameters**

- `level` — Optional. Level of quantile. Constant floating-point number from 0 to 1. We recommend using a `level` value in the range of `[0.01, 0.99]`. Default value: 0.5. At `level=0.5` the function calculates median. [`Float*`](/docs/sql-reference/data-types/float)

**Arguments**

- `expr` — Expression over the column values resulting in numeric data types, Date or DateTime. [`(U)Int*`](/docs/sql-reference/data-types/int-uint) or [`Float*`](/docs/sql-reference/data-types/float) or [`Decimal*`](/docs/sql-reference/data-types/decimal) or [`Date`](/docs/sql-reference/data-types/date) or [`DateTime`](/docs/sql-reference/data-types/datetime)

**Returned value**

Approximate quantile of the specified level. [`Float64`](/docs/sql-reference/data-types/float) or [`Date`](/docs/sql-reference/data-types/date) or [`DateTime`](/docs/sql-reference/data-types/datetime)

**Examples**

**Computing quantile with t-digest**

```
SELECT quantileTDigest(number) FROM numbers(10);
```

```
┌─quantileTDigest(number)─┐
│                     4.5 │
└─────────────────────────┘
```

**See Also**

- [median](/docs/sql-reference/aggregate-functions/reference/median)
- [quantiles](/docs/sql-reference/aggregate-functions/reference/quantiles)

- [quantileTDigest](#quantileTDigest)

Was this page helpful?
rankCorr

[Edit this page](https://github.com/ClickHouse/ClickHouse/tree/master/docs/en/sql-reference/aggregate-functions/reference/rankCorr.md)

## rankCorr[​](#rankCorr "Direct link to rankCorr")

Introduced in: v20.9.0

Computes a rank correlation coefficient.

Returns a rank correlation coefficient of the ranks of x and y. The value of the correlation coefficient ranges from -1 to +1. If less than two arguments are passed, the function will return an exception. The value close to +1 denotes a high linear relationship, and with an increase of one random variable, the second random variable also increases. The value close to -1 denotes a high linear relationship, and with an increase of one random variable, the second random variable decreases. The value close or equal to 0 denotes no relationship between the two random variables.

**See Also**

- [Spearman's rank correlation coefficient](https://en.wikipedia.org/wiki/Spearman%27s_rank_correlation_coefficient)

**Syntax**

```
rankCorr(x, y)
```

**Arguments**

- `x` — Arbitrary value. [`Float*`](/docs/sql-reference/data-types/float)
- `y` — Arbitrary value. [`Float*`](/docs/sql-reference/data-types/float)

**Returned value**

Returns a rank correlation coefficient of the ranks of x and y. The value ranges from -1 to +1. [`Float64`](/docs/sql-reference/data-types/float)

**Examples**

**Perfect correlation**

```
SELECT rankCorr(number, number) FROM numbers(100);
```

```
┌─rankCorr(number, number)─┐
│                        1 │
└──────────────────────────┘
```

**Non-linear relationship**

```
SELECT roundBankers(rankCorr(exp(number), sin(number)), 3) FROM numbers(100);
```

```
┌─roundBankers(rankCorr(exp(number), sin(number)), 3)─┐
│                                              -0.037 │
└─────────────────────────────────────────────────────┘
```

**See Also**

- [Spearman's rank correlation coefficient](https://en.wikipedia.org/wiki/Spearman%27s_rank_correlation_coefficient)

- [rankCorr](#rankCorr)

Was this page helpful?
simpleLinearRegression

[Edit this page](https://github.com/ClickHouse/ClickHouse/tree/master/docs/en/sql-reference/aggregate-functions/reference/simpleLinearRegression.md)

## simpleLinearRegression[​](#simpleLinearRegression "Direct link to simpleLinearRegression")

Introduced in: v20.1.0

Performs simple (unidimensional) linear regression.

**Syntax**

```
simpleLinearRegression(x, y)
```

**Arguments**

- `x` — Column with explanatory variable values. [`Float64`](/docs/sql-reference/data-types/float)
- `y` — Column with dependent variable values. [`Float64`](/docs/sql-reference/data-types/float)

**Returned value**

Returns constants `(k, b)` of the resulting line `y = k*x + b`. [`Tuple(Float64, Float64)`](/docs/sql-reference/data-types/tuple)

**Examples**

**Perfect linear fit**

```
SELECT arrayReduce('simpleLinearRegression', [0, 1, 2, 3], [0, 1, 2, 3]);
```

```
┌─arrayReduce('simpleLinearRegression', [0, 1, 2, 3], [0, 1, 2, 3])─┐
│ (1,0)                                                             │
└───────────────────────────────────────────────────────────────────┘
```

**Linear fit with offset**

```
SELECT arrayReduce('simpleLinearRegression', [0, 1, 2, 3], [3, 4, 5, 6]);
```

```
┌─arrayReduce('simpleLinearRegression', [0, 1, 2, 3], [3, 4, 5, 6])─┐
│ (1,3)                                                             │
└───────────────────────────────────────────────────────────────────┘
```

- [simpleLinearRegression](#simpleLinearRegression)

Was this page helpful?
singleValueOrNull

[Edit this page](https://github.com/ClickHouse/ClickHouse/tree/master/docs/en/sql-reference/aggregate-functions/reference/singleValueOrNull.md)

## singleValueOrNull[​](#singleValueOrNull "Direct link to singleValueOrNull")

Introduced in: v21.9.0

The aggregate function `singleValueOrNull` is used to implement subquery operators, such as `x = ALL (SELECT ...)`. It checks if there is only one unique non-NULL value in the data.
If there is only one unique value, it returns it. If there are zero or at least two distinct values, it returns NULL.

**Syntax**

```
singleValueOrNull(x)
```

**Arguments**

- `x` — A column of any data type except Map, Array or Tuple which cannot be of type Nullable. [`Any`](/docs/sql-reference/data-types)

**Returned value**

Returns the unique value if there is only one unique non-NULL value in `x`. Returns `NULL` if there are zero or at least two distinct values. [`Any`](/docs/sql-reference/data-types) or [`NULL`](/docs/sql-reference/syntax#null)

**Examples**

**Single unique value**

```
CREATE TABLE test (x UInt8 NULL) ENGINE=Log;
INSERT INTO test (x) VALUES (NULL), (NULL), (5), (NULL), (NULL);
SELECT singleValueOrNull(x) FROM test;
```

```
┌─singleValueOrNull(x)─┐
│                    5 │
└──────────────────────┘
```

**Multiple distinct values**

```
INSERT INTO test (x) VALUES (10);
SELECT singleValueOrNull(x) FROM test;
```

```
┌─singleValueOrNull(x)─┐
│                 ᴺᵁᴸᴸ │
└──────────────────────┘
```

- [singleValueOrNull](#singleValueOrNull)

Was this page helpful?
skewPop

[Edit this page](https://github.com/ClickHouse/ClickHouse/tree/master/docs/en/sql-reference/aggregate-functions/reference/skewPop.md)

## skewPop[​](#skewPop "Direct link to skewPop")

Introduced in: v20.1.0

Computes the [skewness](https://en.wikipedia.org/wiki/Skewness) of a sequence.

**Syntax**

```
skewPop(expr)
```

**Arguments**

- `expr` — An expression returning a number. [`Expression`](/docs/sql-reference/data-types/special-data-types/expression)

**Returned value**

Returns the skewness of the given distribution. [`Float64`](/docs/sql-reference/data-types/float)

**Examples**

**Symmetric distribution**

```
SELECT skewPop(number) FROM numbers(100);
```

```
┌─skewPop(number)─┐
│               0 │
└─────────────────┘
```

**Right-skewed distribution**

```
SELECT skewPop(x) FROM (SELECT pow(number, 2) AS x FROM numbers(10));
```

```
┌─────────skewPop(x)─┐
│ 0.6735701055423582 │
└────────────────────┘
```

- [skewPop](#skewPop)

Was this page helpful?
skewSamp

[Edit this page](https://github.com/ClickHouse/ClickHouse/tree/master/docs/en/sql-reference/aggregate-functions/reference/skewSamp.md)

## skewSamp[​](#skewSamp "Direct link to skewSamp")

Introduced in: v20.1.0

Computes the [sample skewness](https://en.wikipedia.org/wiki/Skewness) of a sequence.

It represents an unbiased estimate of the skewness of a random variable if passed values form its sample.

**Syntax**

```
skewSamp(expr)
```

**Arguments**

- `expr` — An expression returning a number. [`Expression`](/docs/sql-reference/data-types/special-data-types/expression)

**Returned value**

Returns the skewness of the given distribution. If `n <= 1` (`n` is the size of the sample), then the function returns `nan`. [`Float64`](/docs/sql-reference/data-types/float)

**Examples**

**Symmetric distribution**

```
SELECT skewSamp(number) FROM numbers(100);
```

```
┌─skewSamp(number)─┐
│                0 │
└──────────────────┘
```

**Right-skewed distribution**

```
SELECT skewSamp(x) FROM (SELECT pow(number, 2) AS x FROM numbers(10));
```

```
┌────────skewSamp(x)─┐
│ 0.5751042382747413 │
└────────────────────┘
```

- [skewSamp](#skewSamp)

Was this page helpful?
sparkbar

[Edit this page](https://github.com/ClickHouse/ClickHouse/tree/master/docs/en/sql-reference/aggregate-functions/reference/sparkbar.md)

## sparkbar[​](#sparkbar "Direct link to sparkbar")

Introduced in: v21.11.0

The function plots a frequency histogram for values `x` and the repetition rate `y` of these values over the interval `[min_x, max_x]`.
Repetitions for all `x` falling into the same bucket are averaged, so data should be pre-aggregated.
Negative repetitions are ignored.

If no interval is specified, then the minimum `x` is used as the interval start, and the maximum `x` — as the interval end.
Otherwise, values outside the interval are ignored.

**Syntax**

```
sparkbar(buckets[, min_x, max_x])(x, y)
```

**Aliases**: `sparkBar`

**Parameters**

- `buckets` — The number of segments. [`(U)Int*`](/docs/sql-reference/data-types/int-uint)
- `min_x` — Optional. The interval start. [`(U)Int*`](/docs/sql-reference/data-types/int-uint) or [`Float*`](/docs/sql-reference/data-types/float) or [`Decimal`](/docs/sql-reference/data-types/decimal)
- `max_x` — Optional. The interval end. [`(U)Int*`](/docs/sql-reference/data-types/int-uint) or [`Float*`](/docs/sql-reference/data-types/float) or [`Decimal`](/docs/sql-reference/data-types/decimal)

**Arguments**

- `x` — The field with values. [`const String`](/docs/sql-reference/data-types/string)
- `y` — The field with the frequency of values. [`const String`](/docs/sql-reference/data-types/string)

**Returned value**

Returns the frequency histogram. [`String`](/docs/sql-reference/data-types/string)

**Examples**

**Without interval specification**

```
CREATE TABLE spark_bar_data (`value` Int64, `event_date` Date) ENGINE = MergeTree ORDER BY event_date;

INSERT INTO spark_bar_data VALUES (1,'2020-01-01'), (3,'2020-01-02'), (4,'2020-01-02'), (-3,'2020-01-02'), (5,'2020-01-03'), (2,'2020-01-04'), (3,'2020-01-05'), (7,'2020-01-06'), (6,'2020-01-07'), (8,'2020-01-08'), (2,'2020-01-11');

SELECT sparkbar(9)(event_date, cnt) FROM (SELECT sum(value) AS cnt, event_date FROM spark_bar_data GROUP BY event_date);
```

```
┌─sparkbar(9)(event_date, cnt)─┐
│ ▂▅▂▃▆█  ▂                    │
└──────────────────────────────┘
```

**With interval specification**

```
SELECT sparkbar(9, toDate('2020-01-01'), toDate('2020-01-10'))(event_date, cnt) FROM (SELECT sum(value) AS cnt, event_date FROM spark_bar_data GROUP BY event_date);
```

```
┌─sparkbar(9, toDate('2020-01-01'), toDate('2020-01-10'))(event_date, cnt)─┐
│ ▂▅▂▃▇▆█                                                                  │
└──────────────────────────────────────────────────────────────────────────┘
```

- [sparkbar](#sparkbar)

Was this page helpful?
stddevPop

[Edit this page](https://github.com/ClickHouse/ClickHouse/tree/master/docs/en/sql-reference/aggregate-functions/reference/stddevPop.md)

## stddevPop[​](#stddevPop "Direct link to stddevPop")

Introduced in: v1.1.0

Returns the population standard deviation of a numeric data sequence.
The result is equal to the square root of [`varPop`](/docs/sql-reference/aggregate-functions/reference/varPop).

Note

This function uses a numerically unstable algorithm. If you need [numerical stability](https://en.wikipedia.org/wiki/Numerical_stability) in calculations, use the [`stddevPopStable`](/docs/sql-reference/aggregate-functions/reference/stddevpopstable) function. It works slower but provides a lower computational error.

**Syntax**

```
stddevPop(x)
```

**Aliases**: `STD`, `STDDEV_POP`

**Arguments**

- `x` — Population of values to find the standard deviation of. [`(U)Int*`](/docs/sql-reference/data-types/int-uint) or [`Float*`](/docs/sql-reference/data-types/float) or [`Decimal*`](/docs/sql-reference/data-types/decimal)

**Returned value**

Returns the square root of population variance of `x`. [`Float64`](/docs/sql-reference/data-types/float)

**Examples**

**Computing population standard deviation**

```
CREATE TABLE test_data (population UInt8) ENGINE = Log;
INSERT INTO test_data VALUES (3),(3),(3),(4),(4),(5),(5),(7),(11),(15);

SELECT stddevPop(population) AS stddev FROM test_data;
```

```
┌────────────stddev─┐
│ 3.794733192202055 │
└───────────────────┘
```

- [stddevPop](#stddevPop)

Was this page helpful?
stddevPopStable

[Edit this page](https://github.com/ClickHouse/ClickHouse/tree/master/docs/en/sql-reference/aggregate-functions/reference/stddevPopStable.md)

## stddevPopStable[​](#stddevPopStable "Direct link to stddevPopStable")

Introduced in: v1.1.0

The result is equal to the square root of [varPop](/docs/sql-reference/aggregate-functions/reference/varPop). Unlike [stddevPop](/docs/sql-reference/aggregate-functions/reference/stddevpop), this function uses a numerically stable algorithm. It works slower but provides a lower computational error.

**Syntax**

```
stddevPopStable(x)
```

**Arguments**

- `x` — Population of values to find the standard deviation of. [`(U)Int*`](/docs/sql-reference/data-types/int-uint) or [`Float*`](/docs/sql-reference/data-types/float) or [`Decimal*`](/docs/sql-reference/data-types/decimal)

**Returned value**

Returns the square root of the variance of `x`. [`Float64`](/docs/sql-reference/data-types/float)

**Examples**

**Basic usage**

```
DROP TABLE IF EXISTS test_data;
CREATE TABLE test_data
(
    population Float64,
)
ENGINE = Log;

INSERT INTO test_data SELECT randUniform(5.5, 10) FROM numbers(1000000);

SELECT
    stddevPopStable(population) AS stddev
FROM test_data;
```

```
┌─────────────stddev─┐
│ 1.2999977786592576 │
└────────────────────┘
```

- [stddevPopStable](#stddevPopStable)

Was this page helpful?