ClickHouse/clickhouse-docs-embeddings huggingface dataset:
uniq

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

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

Introduced in: v1.1.0

Calculates the approximate number of different values of the argument.

The function uses an adaptive sampling algorithm. For the calculation state, the function uses a sample of element hash values up to 65536. This algorithm is very accurate and very efficient on the CPU. When the query contains several of these functions, using uniq is almost as fast as using other aggregate functions.

Implementation details

This function calculates a hash for all parameters in the aggregate, then uses it in calculations.
It uses an adaptive sampling algorithm.
For the calculation state, the function uses a sample of element hash values up to 65536.
This algorithm is very accurate and very efficient on the CPU.
When the query contains several of these functions, using `uniq` is almost as fast as using other aggregate functions.

Tip

We recommend using this function over other variants in almost all scenarios.

**Syntax**

```
uniq(x[, ...])
```

**Arguments**

- `x` — The function takes a variable number of parameters. [`Tuple(T)`](/docs/sql-reference/data-types/tuple) or [`Array(T)`](/docs/sql-reference/data-types/array) or [`Date`](/docs/sql-reference/data-types/date) or [`DateTime`](/docs/sql-reference/data-types/datetime) or [`String`](/docs/sql-reference/data-types/string) or [`(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 a UInt64-type number representing the approximate number of different values. [`UInt64`](/docs/sql-reference/data-types/int-uint)

**Examples**

**Example usage**

```
CREATE TABLE example_table (
    id UInt32,
    category String,
    value Float64
) ENGINE = Memory;

INSERT INTO example_table VALUES
(1, 'A', 10.5),
(2, 'B', 20.3),
(3, 'A', 15.7),
(4, 'C', 8.9),
(5, 'B', 12.1),
(6, 'A', 18.4);

SELECT uniq(category) as unique_categories
FROM example_table;
```

```
┌─unique_categories─┐
│                 3 │
└───────────────────┘
```

**Multiple arguments**

```
SELECT uniq(category, value) as unique_combinations
FROM example_table;
```

```
┌─unique_combinations─┐
│                   6 │
└─────────────────────┘
```

**See Also**

- [uniqCombined](/docs/sql-reference/aggregate-functions/reference/uniqcombined)
- [uniqCombined64](/docs/sql-reference/aggregate-functions/reference/uniqcombined64)
- [uniqHLL12](/docs/sql-reference/aggregate-functions/reference/uniqhll12)
- [uniqExact](/docs/sql-reference/aggregate-functions/reference/uniqexact)
- [uniqTheta](/docs/sql-reference/aggregate-functions/reference/uniqthetasketch)

- [uniq](#uniq)

Was this page helpful?
uniqExact

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

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

Introduced in: v1.1.0

Calculates the exact number of different argument values.

Note

The `uniqExact` function uses more memory than `uniq`, because the size of the state has unbounded growth as the number of different values increases.
Use the `uniqExact` function if you absolutely need an exact result.
Otherwise use the [`uniq`](https://clickhouse.com/docs/sql-reference/aggregate-functions/reference/uniq) function.

**Syntax**

```
uniqExact(x[, ...])
```

**Arguments**

- `x` — The function takes a variable number of parameters. [`Tuple(T)`](/docs/sql-reference/data-types/tuple) or [`Array(T)`](/docs/sql-reference/data-types/array) or [`Date`](/docs/sql-reference/data-types/date) or [`DateTime`](/docs/sql-reference/data-types/datetime) or [`String`](/docs/sql-reference/data-types/string) or [`(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 exact number of different argument values as a UInt64. [`UInt64`](/docs/sql-reference/data-types/int-uint)

**Examples**

**Basic usage**

```
CREATE TABLE example_data
(
    id UInt32,
    category String
)
ENGINE = Memory;

INSERT INTO example_data VALUES
(1, 'A'), (2, 'B'), (3, 'A'), (4, 'C'), (5, 'B'), (6, 'A');

SELECT uniqExact(category) as exact_unique_categories
FROM example_data;
```

```
┌─exact_unique_categories─┐
│                       3 │
└─────────────────────────┘
```

**Multiple arguments**

```
SELECT uniqExact(id, category) as exact_unique_combinations
FROM example_data;
```

```
┌─exact_unique_combinations─┐
│                         6 │
└───────────────────────────┘
```

**See Also**

- [uniq](/docs/sql-reference/aggregate-functions/reference/uniq)
- [uniqCombined](/docs/sql-reference/aggregate-functions/reference/uniqcombined)
- [uniqHLL12](/docs/sql-reference/aggregate-functions/reference/uniqhll12)
- [uniqTheta](/docs/sql-reference/aggregate-functions/reference/uniqthetasketch)

- [uniqExact](#uniqExact)

Was this page helpful?
uniqHLL12

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

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

Introduced in: v1.1.0

Calculates the approximate number of different argument values, using the [HyperLogLog](https://en.wikipedia.org/wiki/HyperLogLog) algorithm.

Note

We do not recommend using this function. In most cases, use the [uniq](https://clickhouse.com/docs/sql-reference/aggregate-functions/reference/uniq) or [uniqCombined](https://clickhouse.com/docs/sql-reference/aggregate-functions/reference/uniqcombined) function.

Details

Implementation details
This function calculates a hash for all parameters in the aggregate, then uses it in calculations.
It uses the HyperLogLog algorithm to approximate the number of different argument values.

2^12 5-bit cells are used.
The size of the state is slightly more than 2.5 KB.
The result is not very accurate (up to ~10% error) for small data sets (<10K elements).
However, the result is fairly accurate for high-cardinality data sets (10K-100M), with a maximum error of ~1.6%.
Starting from 100M, the estimation error increases, and the function will return very inaccurate results for data sets with extremely high cardinality (1B+ elements).

Provides a determinate result (it does not depend on the query processing order).

**Syntax**

```
uniqHLL12(x[, ...])
```

**Arguments**

- `x` — The function takes a variable number of parameters. [`Tuple(T)`](/docs/sql-reference/data-types/tuple) or [`Array(T)`](/docs/sql-reference/data-types/array) or [`Date`](/docs/sql-reference/data-types/date) or [`DateTime`](/docs/sql-reference/data-types/datetime) or [`String`](/docs/sql-reference/data-types/string) or [`(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 a UInt64-type number representing the approximate number of different argument values. [`UInt64`](/docs/sql-reference/data-types/int-uint)

**Examples**

**Basic usage**

```
CREATE TABLE example_hll
(
    id UInt32,
    category String
)
ENGINE = Memory;

INSERT INTO example_hll VALUES
(1, 'A'), (2, 'B'), (3, 'A'), (4, 'C'), (5, 'B'), (6, 'A');

SELECT uniqHLL12(category) AS hll_unique_categories
FROM example_hll;
```

```
┌─hll_unique_categories─┐
│                     3 │
└───────────────────────┘
```

**See Also**

- [uniq](/docs/sql-reference/aggregate-functions/reference/uniq)
- [uniqCombined](/docs/sql-reference/aggregate-functions/reference/uniqcombined)
- [uniqExact](/docs/sql-reference/aggregate-functions/reference/uniqexact)
- [uniqTheta](/docs/sql-reference/aggregate-functions/reference/uniqthetasketch)

- [uniqHLL12](#uniqHLL12)

Was this page helpful?
uniqTheta

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

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

Introduced in: v21.6.0

Calculates the approximate number of different argument values, using the [Theta Sketch Framework](https://datasketches.apache.org/docs/Theta/ThetaSketches.html#theta-sketch-framework).

Implementation details

This function calculates a hash for all parameters in the aggregate, then uses it in calculations.
It uses the [KMV](https://datasketches.apache.org/docs/Theta/InverseEstimate.html) algorithm to approximate the number of different argument values.

4096(2^12) 64-bit sketch are used.
The size of the state is about 41 KB.

The relative error is 3.125% (95% confidence), see the [relative error table](https://datasketches.apache.org/docs/Theta/ThetaErrorTable.html) for detail.

**Syntax**

```
uniqTheta(x[, ...])
```

**Arguments**

- `x` — The function takes a variable number of parameters. [`Tuple(T)`](/docs/sql-reference/data-types/tuple) or [`Array(T)`](/docs/sql-reference/data-types/array) or [`Date`](/docs/sql-reference/data-types/date) or [`DateTime`](/docs/sql-reference/data-types/datetime) or [`String`](/docs/sql-reference/data-types/string) or [`(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 a UInt64-type number representing the approximate number of different argument values. [`UInt64`](/docs/sql-reference/data-types/int-uint)

**Examples**

**Basic usage**

```
CREATE TABLE example_theta
(
    id UInt32,
    category String
)
ENGINE = Memory;

INSERT INTO example_theta VALUES
(1, 'A'), (2, 'B'), (3, 'A'), (4, 'C'), (5, 'B'), (6, 'A');

SELECT uniqTheta(category) as theta_unique_categories
FROM example_theta;
```

```
┌─theta_unique_categories─┐
│                       3 │
└─────────────────────────┘
```

**See Also**

- [uniq](/docs/sql-reference/aggregate-functions/reference/uniq)
- [uniqCombined](/docs/sql-reference/aggregate-functions/reference/uniqcombined)
- [uniqCombined64](/docs/sql-reference/aggregate-functions/reference/uniqcombined64)
- [uniqHLL12](/docs/sql-reference/aggregate-functions/reference/uniqhll12)
- [uniqExact](/docs/sql-reference/aggregate-functions/reference/uniqexact)

- [uniqTheta](#uniqTheta)

Was this page helpful?
varPop

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

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

Introduced in: v1.1.0

Calculates the population variance.

The population variance is calculated using the formula:

Σ(x−xˉ)2n\frac{\Sigma{(x - \bar{x})^2}}{n}nΣ(x−xˉ)2​
  

Where:

- xxx is each value in the population
- xˉ\bar{x}xˉ is the population mean
- nnn is the population size

Note

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

**Syntax**

```
varPop(x)
```

**Aliases**: `VAR_POP`

**Arguments**

- `x` — Population of values to find the population variance 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 population variance of `x`. [`Float64`](/docs/sql-reference/data-types/float)

**Examples**

**Computing population variance**

```
DROP TABLE IF EXISTS test_data;
CREATE TABLE test_data
(
    x UInt8,
)
ENGINE = Memory;

INSERT INTO test_data VALUES (3), (3), (3), (4), (4), (5), (5), (7), (11), (15);

SELECT
    varPop(x) AS var_pop
FROM test_data;
```

```
┌─var_pop─┐
│    14.4 │
└─────────┘
```

- [varPop](#varPop)

Was this page helpful?
varSamp

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

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

Introduced in: v1.1.0

Calculate the sample variance of a data set.

The sample variance is calculated using the formula:

Σ(x−xˉ)2n−1\frac{\Sigma{(x - \bar{x})^2}}{n-1}n−1Σ(x−xˉ)2​
  

Where:

- xxx is each individual data point in the data set
- xˉ\bar{x}xˉ is the arithmetic mean of the data set
- nnn is the number of data points in the data set

The function assumes that the input data set represents a sample from a larger population. If you want to calculate the variance of the entire population (when you have the complete data set), you should use [`varPop`](/docs/sql-reference/aggregate-functions/reference/varPop) instead.

Note

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

**Syntax**

```
varSamp(x)
```

**Aliases**: `VAR_SAMP`

**Arguments**

- `x` — The population for which you want to calculate the sample variance. [`(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 sample variance of the input data set `x`. [`Float64`](/docs/sql-reference/data-types/float)

**Examples**

**Computing sample variance**

```
DROP TABLE IF EXISTS test_data;
CREATE TABLE test_data
(
    x Float64
)
ENGINE = Memory;

INSERT INTO test_data VALUES (10.5), (12.3), (9.8), (11.2), (10.7);

SELECT round(varSamp(x),3) AS var_samp FROM test_data;
```

```
┌─var_samp─┐
│    0.865 │
└──────────┘
```

- [varSamp](#varSamp)

Was this page helpful?
varPopStable

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

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

Introduced in: v1.1.0

Returns the population variance.
Unlike [`varPop`](/docs/sql-reference/aggregate-functions/reference/varPop), this function uses a [numerically stable](https://en.wikipedia.org/wiki/Numerical_stability) algorithm.
It works slower but provides a lower computational error.

**Syntax**

```
varPopStable(x)
```

**Arguments**

- `x` — Population of values to find the population variance 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 population variance of `x`. [`Float64`](/docs/sql-reference/data-types/float)

**Examples**

**Computing stable population variance**

```
DROP TABLE IF EXISTS test_data;
CREATE TABLE test_data
(
    x UInt8,
)
ENGINE = Memory;

INSERT INTO test_data VALUES (3),(3),(3),(4),(4),(5),(5),(7),(11),(15);

SELECT
    varPopStable(x) AS var_pop_stable
FROM test_data;
```

```
┌─var_pop_stable─┐
│           14.4 │
└────────────────┘
```

- [varPopStable](#varPopStable)

Was this page helpful?
varSampStable

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

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

Introduced in: v1.1.0

Calculate the sample variance of a data set. Unlike [`varSamp`](/docs/sql-reference/aggregate-functions/reference/varSamp), this function uses a [numerically stable](https://en.wikipedia.org/wiki/Numerical_stability) algorithm. It works slower but provides a lower computational error.

The sample variance is calculated using the same formula as [`varSamp`](/docs/sql-reference/aggregate-functions/reference/varSamp):

Σ(x−xˉ)2n−1\frac{\Sigma{(x - \bar{x})^2}}{n-1}n−1Σ(x−xˉ)2​
  

Where:

- xxx is each individual data point in the data set
- xˉ\bar{x}xˉ is the arithmetic mean of the data set
- nnn is the number of data points in the data set

**Syntax**

```
varSampStable(x)
```

**Arguments**

- `x` — The population for which you want to calculate the sample variance. [`(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 sample variance of the input data set. [`Float64`](/docs/sql-reference/data-types/float)

**Examples**

**Computing stable sample variance**

```
DROP TABLE IF EXISTS test_data;
CREATE TABLE test_data
(
    x Float64
)
ENGINE = Memory;

INSERT INTO test_data VALUES (10.5), (12.3), (9.8), (11.2), (10.7);

SELECT round(varSampStable(x),3) AS var_samp_stable FROM test_data;
```

```
┌─var_samp_stable─┐
│           0.865 │
└─────────────────┘
```

- [varSampStable](#varSampStable)

Was this page helpful?
welchTTest

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

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

Introduced in: v21.1.0

Applies [Welch's t-test](https://en.wikipedia.org/wiki/Welch%27s_t-test) to samples from two populations.

Values of both samples are in the `sample_data` column.
If `sample_index` equals to 0 then the value in that row belongs to the sample from the first population.
Otherwise it belongs to the sample from the second population.
The null hypothesis is that means of populations are equal.
Normal distribution is assumed.
Populations may have unequal variance.

**Syntax**

```
welchTTest([confidence_level])(sample_data, sample_index)
```

**Parameters**

- `confidence_level` — Optional. Confidence level in order to calculate confidence intervals. [`Float`](/docs/sql-reference/data-types/float)

**Arguments**

- `sample_data` — Sample data. [`Int*`](/docs/sql-reference/data-types/int-uint) or [`UInt*`](/docs/sql-reference/data-types/int-uint) or [`Float*`](/docs/sql-reference/data-types/float) or [`Decimal*`](/docs/sql-reference/data-types/decimal)
- `sample_index` — Sample index. [`Int*`](/docs/sql-reference/data-types/int-uint) or [`UInt*`](/docs/sql-reference/data-types/int-uint)

**Returned value**

Returns a Tuple with two or four elements (if the optional `confidence_level` is specified): calculated t-statistic, calculated p-value, and optionally calculated confidence-interval-low and confidence-interval-high. [`Tuple(Float64, Float64)`](/docs/sql-reference/data-types/tuple) or [`Tuple(Float64, Float64, Float64, Float64)`](/docs/sql-reference/data-types/tuple)

**Examples**

**Basic Welch's t-test**

```
CREATE TABLE welch_ttest (sample_data Float64, sample_index UInt8) ENGINE = Memory;
INSERT INTO welch_ttest VALUES (20.3, 0), (22.1, 0), (21.9, 0), (18.9, 1), (20.3, 1), (19, 1);

SELECT welchTTest(sample_data, sample_index) FROM welch_ttest;
```

```
┌─welchTTest(sample_data, sample_index)──────┐
│ (2.7988719532211235, 0.051807360348581945) │
└────────────────────────────────────────────┘
```

**With confidence level**

```
SELECT welchTTest(0.95)(sample_data, sample_index) FROM welch_ttest;
```

```
┌─welchTTest(0.95)(sample_data, sample_index)─────────────────────────────────────────┐
│ (2.7988719532211235, 0.05180736034858519, -0.026294346671631885, 4.092961013338302) │
└─────────────────────────────────────────────────────────────────────────────────────┘
```

**See Also**

- [Welch's t-test](https://en.wikipedia.org/wiki/Welch%27s_t-test)
- [studentTTest function](/docs/sql-reference/aggregate-functions/reference/studentttest)

- [welchTTest](#welchTTest)

Was this page helpful?
title_wip

[Edit this page](https://github.com/ClickHouse/ClickHouse/tree/master/docs/en/sql-reference/data-types/index.md)

This section describes the data types supported by ClickHouse, for example [integers](/docs/sql-reference/data-types/int-uint), [floats](/docs/sql-reference/data-types/float) and [strings](/docs/sql-reference/data-types/string).

System table [system.data\_type\_families](/docs/operations/system-tables/data_type_families) provides an
overview of all available data types.
It also shows whether a data type is an alias to another data type and its name is case-sensitive (e.g. `bool` vs. `BOOL`).

Was this page helpful?
title_wip

[Edit this page](https://github.com/ClickHouse/ClickHouse/tree/master/docs/en/sql-reference/data-types/boolean.md)

Type `bool` is internally stored as UInt8. Possible values are `true` (1), `false` (0).

```
SELECT true AS col, toTypeName(col);
┌─col──┬─toTypeName(true)─┐
│ true │ Bool             │
└──────┴──────────────────┘

select true == 1 as col, toTypeName(col);
┌─col─┬─toTypeName(equals(true, 1))─┐
│   1 │ UInt8                       │
└─────┴─────────────────────────────┘
```

```
CREATE TABLE test_bool
(
    `A` Int64,
    `B` Bool
)
ENGINE = Memory;

INSERT INTO test_bool VALUES (1, true),(2,0);

SELECT * FROM test_bool;
┌─A─┬─B─────┐
│ 1 │ true  │
│ 2 │ false │
└───┴───────┘
```

Was this page helpful?
title_wip

### Aggregate function parameter binary encoding[​](#aggregate-function-parameter-binary-encoding "Direct link to Aggregate function parameter binary encoding")

The table below describes how parameters of `AggregateFunction` and `SimpleAggregateFunction` are encoded.
The encoding of a parameter consists of 1 byte indicating the type of the parameter and the value itself.

|  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| Parameter type Binary encoding|  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  | | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | | `Null` `0x00`| `UInt64` `0x01<var_uint_value>`| `Int64` `0x02<var_int_value>`| `UInt128` `0x03<uint128_little_endian_value>`| `Int128` `0x04<int128_little_endian_value>`| `UInt256` `0x05<uint256_little_endian_value>`| `Int256` `0x06<int256_little_endian_value>`| `Float64` `0x07<float64_little_endian_value>`| `Decimal32` `0x08<var_uint_scale><int32_little_endian_value>`| `Decimal64` `0x09<var_uint_scale><int64_little_endian_value>`| `Decimal128` `0x0A<var_uint_scale><int128_little_endian_value>`| `Decimal256` `0x0B<var_uint_scale><int256_little_endian_value>`| `String` `0x0C<var_uint_size><data>`| `Array` `0x0D<var_uint_size><value_encoding_1>...<value_encoding_N>`| `Tuple` `0x0E<var_uint_size><value_encoding_1>...<value_encoding_N>`| `Map` `0x0F<var_uint_size><key_encoding_1><value_encoding_1>...<key_encoding_N><value_encoding_N>`| `IPv4` `0x10<uint32_little_endian_value>`| `IPv6` `0x11<uint128_little_endian_value>`| `UUID` `0x12<uuid_value>`| `Bool` `0x13<bool_value>`| `Object` `0x14<var_uint_size><var_uint_key_size_1><key_data_1><value_encoding_1>...<var_uint_key_size_N><key_data_N><value_encoding_N>`| `AggregateFunctionState` `0x15<var_uint_name_size><name_data><var_uint_data_size><data>`| `Negative infinity` `0xFE`| `Positive infinity` `0xFF` | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | |

- [Interval kind binary encoding](#interval-kind-binary-encoding)- [Aggregate function parameter binary encoding](#aggregate-function-parameter-binary-encoding)

Was this page helpful?