Function registerDataTypeDecimal

src/DataTypes/DataTypesDecimal.cpp:629–778

template class DataTypeDecimal<Decimal256>;

void registerDataTypeDecimal(DataTypeFactory & factory)
{
    factory.registerDataType("Decimal32", createExact<Decimal32>, DataTypeFactory::Case::Insensitive,
        Documentation{
            .description = "A fixed-point decimal with a fixed bit width; equivalent to `Decimal(P, S)` with a fixed precision range. See the `Decimal` entry for full documentation.",
            .syntax = "Decimal32(S)",
            .related = {"Decimal"},
        });
    factory.registerDataType("Decimal64", createExact<Decimal64>, DataTypeFactory::Case::Insensitive,
        Documentation{
            .description = "A fixed-point decimal with a fixed bit width; equivalent to `Decimal(P, S)` with a fixed precision range. See the `Decimal` entry for full documentation.",
            .syntax = "Decimal64(S)",
            .related = {"Decimal"},
        });
    factory.registerDataType("Decimal128", createExact<Decimal128>, DataTypeFactory::Case::Insensitive,
        Documentation{
            .description = "A fixed-point decimal with a fixed bit width; equivalent to `Decimal(P, S)` with a fixed precision range. See the `Decimal` entry for full documentation.",
            .syntax = "Decimal128(S)",
            .related = {"Decimal"},
        });
    factory.registerDataType("Decimal256", createExact<Decimal256>, DataTypeFactory::Case::Insensitive,
        Documentation{
            .description = "A fixed-point decimal with a fixed bit width; equivalent to `Decimal(P, S)` with a fixed precision range. See the `Decimal` entry for full documentation.",
            .syntax = "Decimal256(S)",
            .related = {"Decimal"},
        });

    factory.registerDataType("Decimal", create, DataTypeFactory::Case::Insensitive,
        Documentation{
            .description = R"DOCS_MD(
Signed fixed-point numbers that keep precision during add, subtract and multiply operations. For division least significant digits are discarded (not rounded).

## Parameters {#parameters}

- P - precision. Valid range: \[ 1 : 76 \]. Determines how many decimal digits number can have (including fraction). By default, the precision is 10.
- S - scale. Valid range: \[ 0 : P \]. Determines how many decimal digits fraction can have.

Decimal(P) is equivalent to Decimal(P, 0). Similarly, the syntax Decimal is equivalent to Decimal(10, 0).

Depending on P parameter value Decimal(P, S) is a synonym for:
- P from \[ 1 : 9 \] - for Decimal32(S)
- P from \[ 10 : 18 \] - for Decimal64(S)
- P from \[ 19 : 38 \] - for Decimal128(S)
- P from \[ 39 : 76 \] - for Decimal256(S)

## Decimal Value Ranges {#decimal-value-ranges}

- Decimal(P, S) - (-1 \* 10^(P - S), 1 \* 10^(P - S))
- Decimal32(S) - (-1 \* 10^(9 - S), 1 \* 10^(9 - S))
- Decimal64(S) - (-1 \* 10^(18 - S), 1 \* 10^(18 - S))
- Decimal128(S) - (-1 \* 10^(38 - S), 1 \* 10^(38 - S))
- Decimal256(S) - (-1 \* 10^(76 - S), 1 \* 10^(76 - S))

For example, Decimal32(4) can contain numbers from -99999.9999 to 99999.9999 with 0.0001 step.

## Internal Representation {#internal-representation}

Internally data is represented as normal signed integers with respective bit width. Real value ranges that can be stored in memory are a bit larger than specified above, which are checked only on conversion from a string.