│
└──────────────────────────────────────────────┘
```
## formatRowNoNewline
Introduit dans : v20.7.0
Identique à [`formatRow`](#formatRow), mais supprime le caractère de nouvelle ligne de chaque ligne.
Convertit des expressions arbitraires en chaîne à l’aide du format donné, mais supprime tout caractère de nouvelle ligne final du résultat.
**Syntaxe**
```sql theme={null}
formatRowNoNewline(format, x, y, ...)
```
**Arguments**
* `format` — Format de texte. Par exemple, CSV, TSV. [`String`](/fr/reference/data-types/string)
* `x, y, ...` — Expressions. [`Any`](/fr/reference/data-types/index)
**Valeur renvoyée**
Renvoie une chaîne formatée dont les retours à la ligne ont été supprimés. [`String`](/fr/reference/data-types/string)
**Exemples**
**Utilisation de base**
```sql title=Query theme={null}
SELECT formatRowNoNewline('CSV', number, 'good')
FROM numbers(3)
```
```response title=Response theme={null}
┌─formatRowNoNewline('CSV', number, 'good')─┐
│ 0,"good" │
│ 1,"good" │
│ 2,"good" │
└───────────────────────────────────────────┘
```
## fromUnixTimestamp64Micro
Introduit dans : v20.5.0
Convertit un timestamp Unix en microsecondes en valeur `DateTime64` avec une précision à la microseconde.
La valeur d’entrée est traitée comme un timestamp Unix avec une précision à la microseconde (nombre de microsecondes écoulées depuis 1970-01-01 00:00:00 UTC).
**Syntaxe**
```sql theme={null}
fromUnixTimestamp64Micro(value[, timezone])
```
**Arguments**
* `value` — Timestamp Unix en microsecondes. [`Int64`](/fr/reference/data-types/int-uint)
* `timezone` — Facultatif. Fuseau horaire de la valeur renvoyée. [`String`](/fr/reference/data-types/string)
**Valeur renvoyée**
Renvoie une valeur `DateTime64` avec une précision en microsecondes. [`DateTime64(6)`](/fr/reference/data-types/datetime64)
**Exemples**
**Exemple d'utilisation**
```sql title=Query theme={null}
SELECT fromUnixTimestamp64Micro(1640995200123456)
```
```response title=Response theme={null}
┌─fromUnixTimestamp64Micro(1640995200123456)─┐
│ 2022-01-01 00:00:00.123456 │
└────────────────────────────────────────────┘
```
## fromUnixTimestamp64Milli
Introduit dans : v20.5.0
Convertit un timestamp Unix en millisecondes en valeur `DateTime64` avec une précision de l’ordre de la milliseconde.
La valeur d’entrée est traitée comme un timestamp Unix avec une précision à la milliseconde (nombre de millisecondes écoulées depuis 1970-01-01 00:00:00 UTC).
**Syntaxe**
```sql theme={null}
fromUnixTimestamp64Milli(value[, timezone])
```
**Arguments**
* `value` — timestamp Unix en millisecondes. [`Int64`](/fr/reference/data-types/int-uint)
* `timezone` — Facultatif. Fuseau horaire de la valeur renvoyée. [`String`](/fr/reference/data-types/string)
**Valeur renvoyée**
Une valeur `DateTime64` avec une précision à la milliseconde. [`DateTime64(3)`](/fr/reference/data-types/datetime64)
**Exemples**
**Exemple d'utilisation**
```sql title=Query theme={null}
SELECT fromUnixTimestamp64Milli(1640995200123)
```
```response title=Response theme={null}
┌─fromUnixTimestamp64Milli(1640995200123)─┐
│ 2022-01-01 00:00:00.123 │
└─────────────────────────────────────────┘
```
## fromUnixTimestamp64Nano
Introduit dans : v20.5.0
Convertit un timestamp Unix en nanosecondes en une valeur [`DateTime64`](/fr/reference/data-types/datetime64) avec une précision en nanosecondes.
La valeur d’entrée est traitée comme un timestamp Unix avec une précision en nanosecondes (nombre de nanosecondes écoulées depuis 1970-01-01 00:00:00 UTC).
Veuillez noter que la valeur d’entrée est traitée comme un timestamp UTC, et non selon son fuseau horaire.
**Syntaxe**
```sql theme={null}
fromUnixTimestamp64Nano(value[, timezone])
```
**Arguments**
* `value` — timestamp Unix en nanosecondes. [`Int64`](/fr/reference/data-types/int-uint)
* `timezone` — Facultatif. Fuseau horaire de la valeur renvoyée. [`String`](/fr/reference/data-types/string)
**Valeur renvoyée**
Renvoie une valeur `DateTime64` avec une précision à la nanoseconde. [`DateTime64(9)`](/fr/reference/data-types/datetime64)
**Exemples**
**Exemple d'utilisation**
```sql title=Query theme={null}
SELECT fromUnixTimestamp64Nano(1640995200123456789)
```
```response title=Response theme={null}
┌─fromUnixTimestamp64Nano(1640995200123456789)─┐
│ 2022-01-01 00:00:00.123456789 │
└──────────────────────────────────────────────┘
```
## fromUnixTimestamp64Second
Introduit dans : v24.12.0
Convertit un timestamp Unix en secondes en valeur `DateTime64` avec une précision à la seconde.
La valeur d’entrée est traitée comme un timestamp Unix avec une précision à la seconde (nombre de secondes écoulées depuis 1970-01-01 00:00:00 UTC).
**Syntaxe**
```sql theme={null}
fromUnixTimestamp64Second(value[, timezone])
```
**Arguments**
* `value` — timestamp Unix en secondes. [`Int64`](/fr/reference/data-types/int-uint)
* `timezone` — Facultatif. Fuseau horaire de la valeur renvoyée. [`String`](/fr/reference/data-types/string)
**Valeur renvoyée**
Renvoie une valeur `DateTime64` avec une précision à la seconde. [`DateTime64(0)`](/fr/reference/data-types/datetime64)
**Exemples**
**Exemple d'utilisation**
```sql title=Query theme={null}
SELECT fromUnixTimestamp64Second(1640995200)
```
```response title=Response theme={null}
┌─fromUnixTimestamp64Second(1640995200)─┐
│ 2022-01-01 00:00:00 │
└───────────────────────────────────────┘
```
## parseDateTime
Introduit dans : v23.3.0
Analyse une chaîne de date et d’heure selon une chaîne de format de date MySQL.
Cette fonction est l’inverse de [`formatDateTime`](/fr/reference/functions/regular-functions/date-time-functions).
Elle analyse un argument de type String à l’aide d’une chaîne de format String. Elle renvoie un type DateTime.
**Syntaxe**
```sql theme={null}
parseDateTime(time_string, format[, timezone])
```
**Alias** : `TO_UNIXTIME`
**Arguments**
* `time_string` — Chaîne à analyser en DateTime. [`String`](/fr/reference/data-types/string)
* `format` — Chaîne de format indiquant comment analyser time\_string. [`String`](/fr/reference/data-types/string)
* `timezone` — Facultatif. Fuseau horaire. [`String`](/fr/reference/data-types/string)
**Valeur renvoyée**
Renvoie un DateTime analysé à partir de la chaîne d’entrée selon la chaîne de format de style MySQL. [`DateTime`](/fr/reference/data-types/datetime)
**Exemples**
**Exemple d’utilisation**
```sql title=Query theme={null}
SELECT parseDateTime('2025-01-04+23:00:00', '%Y-%m-%d+%H:%i:%s')
```
```response title=Response theme={null}
┌─parseDateTime('2025-01-04+23:00:00', '%Y-%m-%d+%H:%i:%s')─┐
│ 2025-01-04 23:00:00 │
└───────────────────────────────────────────────────────────┘
```
## parseDateTime32BestEffort
Introduite dans : v20.9.0
Convertit la représentation sous forme de chaîne d’une date et d’une heure en type de données [`DateTime`](/fr/reference/data-types/datetime).
La fonction analyse les formats [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601), [RFC 1123 - 5.2.14 RFC-822 Date and Time Specification](https://tools.ietf.org/html/rfc1123#page-55), ceux de ClickHouse, ainsi que certains autres formats de date et d’heure.
**Syntaxe**
```sql theme={null}
parseDateTime32BestEffort(time_string[, time_zone])
```
**Arguments**
* `time_string` — `String` contenant une date et une heure à convertir. [`String`](/fr/reference/data-types/string)
* `time_zone` — Facultatif. Fuseau horaire selon lequel `time_string` est interprété. [`String`](/fr/reference/data-types/string)
**Valeur renvoyée**
Renvoie `time_string` en `DateTime`. [`DateTime`](/fr/reference/data-types/datetime)
**Exemples**
**Exemple d'utilisation**
```sql title=Query theme={null}
SELECT parseDateTime32BestEffort('23/10/2025 12:12:57')
AS parseDateTime32BestEffort
```
```response title=Response theme={null}
┌─parseDateTime32BestEffort─┐
│ 2025-10-23 12:12:57 │
└───────────────────────────┘
```
**Avec un fuseau horaire**
```sql title=Query theme={null}
SELECT parseDateTime32BestEffort('Sat, 18 Aug 2025 07:22:16 GMT', 'Asia/Istanbul')
AS parseDateTime32BestEffort
```
```response title=Response theme={null}
┌─parseDateTime32BestEffort─┐
│ 2025-08-18 10:22:16 │
└───────────────────────────┘
```
**timestamp Unix**
```sql title=Query theme={null}
SELECT parseDateTime32BestEffort('1284101485')
AS parseDateTime32BestEffort
```
```response title=Response theme={null}
┌─parseDateTime32BestEffort─┐
│ 2015-07-07 12:04:41 │
└───────────────────────────┘
```
## parseDateTime32BestEffortOrNull
Introduit dans : v20.9.0
Identique à [`parseDateTime32BestEffort`](#parseDateTime32BestEffort), sauf qu’elle renvoie `NULL` lorsqu’elle rencontre un format de date qu’elle ne peut pas traiter.
**Syntaxe**
```sql theme={null}
parseDateTime32BestEffortOrNull(time_string[, time_zone])
```
**Arguments**
* `time_string` — `String` contenant une date et une heure à convertir. [`String`](/fr/reference/data-types/string)
* `time_zone` — Facultatif. Fuseau horaire selon lequel `time_string` est interprété. [`String`](/fr/reference/data-types/string)
**Valeur renvoyée**
Renvoie un objet `DateTime` interprété à partir de la chaîne, ou `NULL` si l’analyse échoue. [`DateTime`](/fr/reference/data-types/datetime)
**Exemples**
**Exemple d'utilisation**
```sql title=Query theme={null}
SELECT
parseDateTime32BestEffortOrNull('23/10/2025 12:12:57') AS valid,
parseDateTime32BestEffortOrNull('invalid date') AS invalid
```
```response title=Response theme={null}
┌─valid───────────────┬─invalid─┐
│ 2025-10-23 12:12:57 │ ᴺᵁᴸᴸ │
└─────────────────────┴─────────┘
```
## parseDateTime32BestEffortOrZero
Introduit dans : v20.9.0
Identique à [`parseDateTime32BestEffort`](#parseDateTime32BestEffort), sauf qu'elle renvoie une date nulle ou une date et heure nulles lorsqu'elle rencontre un format de date qui ne peut pas être traité.
**Syntaxe**
```sql theme={null}
parseDateTime32BestEffortOrZero(time_string[, time_zone])
```
**Arguments**
* `time_string` — `String` contenant une date et une heure à convertir. [`String`](/fr/reference/data-types/string)
* `time_zone` — Facultatif. Fuseau horaire selon lequel `time_string` est interprétée. [`String`](/fr/reference/data-types/string)
**Valeur renvoyée**
Renvoie un objet `DateTime` interprété à partir de la chaîne, ou la date zéro (`1970-01-01 00:00:00`) si l'analyse échoue. [`DateTime`](/fr/reference/data-types/datetime)
**Exemples**
**Exemple d'utilisation**
```sql title=Query theme={null}
SELECT
parseDateTime32BestEffortOrZero('23/10/2025 12:12:57') AS valid,
parseDateTime32BestEffortOrZero('invalid date') AS invalid
```
```response title=Response theme={null}
┌─valid───────────────┬─invalid─────────────┐
│ 2025-10-23 12:12:57 │ 1970-01-01 00:00:00 │
└─────────────────────┴─────────────────────┘
```
## parseDateTime64
Introduit dans : v24.11.0
Analyse une chaîne de date et d'heure avec une précision sub-secondes selon une chaîne de format de date MySQL.
Cette fonction est l'inverse de [`formatDateTime`](/fr/reference/functions/regular-functions/date-time-functions) pour DateTime64.
Elle analyse un argument de type String à l'aide d'un format String. Elle renvoie un type DateTime64 capable de représenter des dates de 1900 à 2299 avec une précision sub-secondes.
**Syntaxe**
```sql theme={null}
parseDateTime64(time_string, format[, timezone])
```
**Arguments**
* `time_string` — Chaîne à analyser pour obtenir un `DateTime64`. [`String`](/fr/reference/data-types/string)
* `format` — Chaîne de format indiquant comment analyser time\_string. [`String`](/fr/reference/data-types/string)
* `timezone` — Facultatif. Fuseau horaire. [`String`](/fr/reference/data-types/string)
**Valeur renvoyée**
Renvoie un `DateTime64` obtenu par analyse de la chaîne d'entrée selon une chaîne de format de style MySQL. [`DateTime64`](/fr/reference/data-types/datetime64)
**Exemples**
**Exemple d'utilisation**
```sql title=Query theme={null}
SELECT parseDateTime64('2025-01-04 23:00:00.123', '%Y-%m-%d %H:%i:%s.%f')
```
```response title=Response theme={null}
┌─parseDateTime64('2025-01-04 23:00:00.123', '%Y-%m-%d %H:%i:%s.%f')─┐
│ 2025-01-04 23:00:00.123 │
└─────────────────────────────────────────────────────────────────────┘
```
## parseDateTime64BestEffort
Introduit dans : v20.1.0
Identique à la fonction [`parseDateTimeBestEffort`](#parseDateTimeBestEffort), mais prend également en charge l’analyse des millisecondes et des microsecondes, et renvoie le type de données [`DateTime64`](/fr/reference/data-types/datetime64).
**Syntaxe**
```sql theme={null}
parseDateTime64BestEffort(time_string[, precision[, time_zone]])
```
**Arguments**
* `time_string` — `String` contenant une date ou une date avec heure à convertir. [`String`](/fr/reference/data-types/string)
* `precision` — Facultatif. Précision requise. `3` pour les millisecondes, `6` pour les microsecondes. Par défaut : `3`. [`UInt8`](/fr/reference/data-types/int-uint)
* `time_zone` — Facultatif. Fuseau horaire. La fonction interprète `time_string` en fonction du fuseau horaire. [`String`](/fr/reference/data-types/string)
**Valeur renvoyée**
Renvoie `time_string` converti en type de données [`DateTime64`](/fr/reference/data-types/datetime64). [`DateTime64`](/fr/reference/data-types/datetime64)
**Exemples**
**Exemple d'utilisation**
```sql title=Query theme={null}
SELECT parseDateTime64BestEffort('2025-01-01') AS a, toTypeName(a) AS t
UNION ALL
SELECT parseDateTime64BestEffort('2025-01-01 01:01:00.12346') AS a, toTypeName(a) AS t
UNION ALL
SELECT parseDateTime64BestEffort('2025-01-01 01:01:00.12346',6) AS a, toTypeName(a) AS t
UNION ALL
SELECT parseDateTime64BestEffort('2025-01-01 01:01:00.12346',3,'Asia/Istanbul') AS a, toTypeName(a) AS t
FORMAT PrettyCompactMonoBlock
```
```response title=Response theme={null}
┌──────────────────────────a─┬─t──────────────────────────────┐
│ 2025-01-01 01:01:00.123000 │ DateTime64(3) │
│ 2025-01-01 00:00:00.000000 │ DateTime64(3) │
│ 2025-01-01 01:01:00.123460 │ DateTime64(6) │
│ 2025-12-31 22:01:00.123000 │ DateTime64(3, 'Asia/Istanbul') │
└────────────────────────────┴────────────────────────────────┘
```
## parseDateTime64BestEffortOrNull
Introduit dans : v20.1.0
Identique à [`parseDateTime64BestEffort`](#parseDateTime64BestEffort), sauf qu'elle renvoie `NULL` lorsqu'elle rencontre un format de date impossible à traiter.
**Syntaxe**
```sql theme={null}
parseDateTime64BestEffortOrNull(time_string[, precision[, time_zone]])
```
**Arguments**
* `time_string` — `String` contenant une date ou une date avec heure à convertir. [`String`](/fr/reference/data-types/string)
* `precision` — Facultatif. Précision requise. `3` pour les millisecondes, `6` pour les microsecondes. Valeur par défaut : `3`. [`UInt8`](/fr/reference/data-types/int-uint)
* `time_zone` — Facultatif. Fuseau horaire. La fonction interprète `time_string` selon le fuseau horaire. [`String`](/fr/reference/data-types/string)
**Valeur renvoyée**
Renvoie `time_string` converti en [`DateTime64`](/fr/reference/data-types/datetime64), ou `NULL` si l’entrée ne peut pas être interprétée. [`DateTime64`](/fr/reference/data-types/datetime64) ou [`NULL`](/fr/reference/syntax#null)
**Exemples**
**Exemple d'utilisation**
```sql title=Query theme={null}
SELECT parseDateTime64BestEffortOrNull('2025-01-01 01:01:00.123') AS valid,
parseDateTime64BestEffortOrNull('invalid') AS invalid
```
```response title=Response theme={null}
┌─valid───────────────────┬─invalid─┐
│ 2025-01-01 01:01:00.123 │ ᴺᵁᴸᴸ │
└─────────────────────────┴─────────┘
```
## parseDateTime64BestEffortOrZero
Introduit dans : v20.1.0
Identique à [`parseDateTime64BestEffort`](#parseDateTime64BestEffort), sauf qu’elle renvoie une date zéro ou une date-heure zéro lorsqu’elle rencontre un format de date impossible à traiter.
**Syntaxe**
```sql theme={null}
parseDateTime64BestEffortOrZero(time_string[, precision[, time_zone]])
```
**Arguments**
* `time_string` — `String` contenant une date ou une date et heure à convertir. [`String`](/fr/reference/data-types/string)
* `precision` — Facultatif. Précision requise. `3` pour les millisecondes, `6` pour les microsecondes. Par défaut : `3`. [`UInt8`](/fr/reference/data-types/int-uint)
* `time_zone` — Facultatif. Fuseau horaire. La fonction interprète `time_string` selon ce fuseau horaire. [`String`](/fr/reference/data-types/string)
**Valeur renvoyée**
Renvoie `time_string` converti en [`DateTime64`](/fr/reference/data-types/datetime64), ou la date/date-heure zéro (`1970-01-01 00:00:00.000`) si l’entrée ne peut pas être interprétée. [`DateTime64`](/fr/reference/data-types/datetime64)
**Exemples**
**Exemple d’utilisation**
```sql title=Query theme={null}
SELECT parseDateTime64BestEffortOrZero('2025-01-01 01:01:00.123') AS valid,
parseDateTime64BestEffortOrZero('invalid') AS invalid
```
```response title=Response theme={null}
┌─valid───────────────────┬─invalid─────────────────┐
│ 2025-01-01 01:01:00.123 │ 1970-01-01 00:00:00.000 │
└─────────────────────────┴─────────────────────────┘
```
## parseDateTime64BestEffortUS
Introduit dans : v22.8.0
Identique à [`parseDateTime64BestEffort`](#parseDateTime64BestEffort), sauf que cette fonction privilégie le format de date américain (`MM/DD/YYYY`, etc.) en cas d'ambiguïté.
**Syntaxe**
```sql theme={null}
parseDateTime64BestEffortUS(time_string [, precision [, time_zone]])
```
**Arguments**
* `time_string` — `String` contenant une date ou une date avec heure à convertir. [`String`](/fr/reference/data-types/string)
* `precision` — Facultatif. Précision requise. `3` pour les millisecondes, `6` pour les microsecondes. Par défaut : `3`. [`UInt8`](/fr/reference/data-types/int-uint)
* `time_zone` — Facultatif. Fuseau horaire. La fonction interprète `time_string` selon le fuseau horaire. [`String`](/fr/reference/data-types/string)
**Valeur renvoyée**
Renvoie `time_string` converti en [`DateTime64`](/fr/reference/data-types/datetime64) en privilégiant le format de date US dans les cas ambigus. [`DateTime64`](/fr/reference/data-types/datetime64)
**Exemples**
**Exemple d’utilisation**
```sql title=Query theme={null}
SELECT parseDateTime64BestEffortUS('02/10/2025 12:30:45.123') AS us_format,
parseDateTime64BestEffortUS('15/08/2025 10:15:30.456') AS fallback_to_standard
```
```response title=Response theme={null}
┌─us_format───────────────┬─fallback_to_standard────┐
│ 2025-02-10 12:30:45.123 │ 2025-08-15 10:15:30.456 │
└─────────────────────────┴─────────────────────────┘
```
## parseDateTime64BestEffortUSOrNull
Introduit dans : v22.8.0
Identique à [`parseDateTime64BestEffort`](#parseDateTime64BestEffort), sauf que cette fonction privilégie le format de date américain (`MM/DD/YYYY`, etc.) en cas d’ambiguïté et renvoie `NULL` lorsqu’elle rencontre un format de date qu’elle ne peut pas traiter.
**Syntaxe**
```sql theme={null}
parseDateTime64BestEffortUSOrNull(time_string[, precision[, time_zone]])
```
**Arguments**
* `time_string` — `String` contenant une date ou une date avec heure à convertir. [`String`](/fr/reference/data-types/string)
* `precision` — Facultatif. Précision requise. `3` pour les millisecondes, `6` pour les microsecondes. Valeur par défaut : `3`. [`UInt8`](/fr/reference/data-types/int-uint)
* `time_zone` — Facultatif. Fuseau horaire. La fonction analyse `time_string` en fonction du fuseau horaire. [`String`](/fr/reference/data-types/string)
**Valeur renvoyée**
Renvoie `time_string` converti en [`DateTime64`](/fr/reference/data-types/datetime64) avec préférence pour le format US, ou `NULL` si l’entrée ne peut pas être analysée. [`DateTime64`](/fr/reference/data-types/datetime64) ou [`NULL`](/fr/reference/syntax#null)
**Exemples**
**Exemple d'utilisation**
```sql title=Query theme={null}
SELECT parseDateTime64BestEffortUSOrNull('02/10/2025 12:30:45.123') AS valid_us,
parseDateTime64BestEffortUSOrNull('invalid') AS invalid
```
```response title=Response theme={null}
┌─valid_us────────────────┬─invalid─┐
│ 2025-02-10 12:30:45.123 │ ᴺᵁᴸᴸ │
└─────────────────────────┴─────────┘
```
## parseDateTime64BestEffortUSOrZero
Introduit dans : v22.8.0
Identique à [`parseDateTime64BestEffort`](#parseDateTime64BestEffort), à ceci près que cette fonction privilégie le format de date américain (`MM/DD/YYYY`, etc.) en cas d’ambiguïté et renvoie une date zéro ou une date-heure zéro lorsqu’elle rencontre un format de date qui ne peut pas être traité.
**Syntaxe**
```sql theme={null}
parseDateTime64BestEffortUSOrZero(time_string [, precision [, time_zone]])
```
**Arguments**
* `time_string` — `String` contenant une date ou une date avec heure à convertir. [`String`](/fr/reference/data-types/string)
* `precision` — Facultatif. Précision requise. `3` pour les millisecondes, `6` pour les microsecondes. Par défaut : `3`. [`UInt8`](/fr/reference/data-types/int-uint)
* `time_zone` — Facultatif. Fuseau horaire. La fonction interprète `time_string` selon ce fuseau horaire. [`String`](/fr/reference/data-types/string)
**Valeur renvoyée**
Renvoie `time_string` converti en [`DateTime64`](/fr/reference/data-types/datetime64) avec préférence pour le format US, ou la date zéro/la date-heure zéro (`1970-01-01 00:00:00.000`) si l’entrée ne peut pas être interprétée. [`DateTime64`](/fr/reference/data-types/datetime64)
**Exemples**
**Exemple d’utilisation**
```sql title=Query theme={null}
SELECT parseDateTime64BestEffortUSOrZero('02/10/2025 12:30:45.123') AS valid_us,
parseDateTime64BestEffortUSOrZero('invalid') AS invalid
```
```response title=Response theme={null}
┌─valid_us────────────────┬─invalid─────────────────┐
│ 2025-02-10 12:30:45.123 │ 1970-01-01 00:00:00.000 │
└─────────────────────────┴─────────────────────────┘
```
## parseDateTime64InJodaSyntax
Introduit dans : v24.10.0
Analyse une chaîne de date et d'heure avec une précision inférieure à la seconde, selon une chaîne de format de date Joda.
Cette fonction est l'inverse de [`formatDateTimeInJodaSyntax`](/fr/reference/functions/regular-functions/date-time-functions#formatDateTimeInJodaSyntax) pour DateTime64.
Elle analyse un argument String à l'aide d'une chaîne de format de style Joda. Elle renvoie une valeur de type DateTime64, capable de représenter des dates de 1900 à 2299 avec une précision inférieure à la seconde.
Consultez la [documentation Joda Time](https://joda-time.sourceforge.net/apidocs/org/joda/time/format/DateTimeFormat.html) pour les motifs de format.
**Syntaxe**
```sql theme={null}
parseDateTime64InJodaSyntax(time_string, format[, timezone])
```
**Arguments**
* `time_string` — Chaîne à interpréter en DateTime64. [`String`](/fr/reference/data-types/string)
* `format` — Chaîne de format en syntaxe Joda indiquant comment interpréter time\_string. [`String`](/fr/reference/data-types/string)
* `timezone` — Facultatif. Fuseau horaire. [`String`](/fr/reference/data-types/string)
**Valeur renvoyée**
Renvoie un DateTime64 interprété à partir de la chaîne d’entrée selon la chaîne de format de style Joda. [`DateTime64`](/fr/reference/data-types/datetime64)
**Exemples**
**Exemple d’utilisation**
```sql title=Query theme={null}
SELECT parseDateTime64InJodaSyntax('2025-01-04 23:00:00.123', 'yyyy-MM-dd HH:mm:ss.SSS')
```
```response title=Response theme={null}
┌─parseDateTime64InJodaSyntax('2025-01-04 23:00:00.123', 'yyyy-MM-dd HH:mm:ss.SSS')─┐
│ 2025-01-04 23:00:00.123 │
└────────────────────────────────────────────────────────────────────────────────────┘
```
## parseDateTime64InJodaSyntaxOrNull
Introduit dans : v24.10.0
Identique à [`parseDateTime64InJodaSyntax`](#parseDateTime64InJodaSyntax), mais renvoie `NULL` si le format de date ne peut pas être analysé.
**Syntaxe**
```sql theme={null}
parseDateTime64InJodaSyntaxOrNull(time_string, format[, timezone])
```
**Arguments**
* `time_string` — Chaîne à analyser en DateTime64. [`String`](/fr/reference/data-types/string)
* `format` — Chaîne de format en syntaxe Joda indiquant comment analyser time\_string. [`String`](/fr/reference/data-types/string)
* `timezone` — Facultatif. Fuseau horaire. [`String`](/fr/reference/data-types/string)
**Valeur renvoyée**
Renvoie un DateTime64 analysé à partir de la chaîne d’entrée, ou NULL si l’analyse échoue. [`Nullable(DateTime64)`](/fr/reference/data-types/nullable)
**Exemples**
**Exemple d’utilisation**
```sql title=Query theme={null}
SELECT parseDateTime64InJodaSyntaxOrNull('2025-01-04 23:00:00.123', 'yyyy-MM-dd HH:mm:ss.SSS')
```
```response title=Response theme={null}
┌─parseDateTime64InJodaSyntaxOrNull('2025-01-04 23:00:00.123', 'yyyy-MM-dd HH:mm:ss.SSS')─┐
│ 2025-01-04 23:00:00.123 │
└──────────────────────────────────────────────────────────────────────────────────────────┘
```
## parseDateTime64InJodaSyntaxOrZero
Introduit dans : v24.10.0
Identique à [`parseDateTime64InJodaSyntax`](#parseDateTime64InJodaSyntax), mais renvoie une date zéro lorsqu’elle rencontre un format de date impossible à analyser.
**Syntaxe**
```sql theme={null}
parseDateTime64InJodaSyntaxOrZero(time_string, format[, timezone])
```
**Arguments**
* `time_string` — Chaîne à analyser en DateTime64. [`String`](/fr/reference/data-types/string)
* `format` — Chaîne de format en syntaxe Joda, indiquant comment analyser time\_string. [`String`](/fr/reference/data-types/string)
* `timezone` — Facultatif. Fuseau horaire. [`String`](/fr/reference/data-types/string)
**Valeur renvoyée**
Renvoie le DateTime64 analysé à partir de la chaîne d’entrée, ou un DateTime64 zéro si l’analyse échoue. [`DateTime64`](/fr/reference/data-types/datetime64)
**Exemples**
**Exemple d’utilisation**
```sql title=Query theme={null}
SELECT parseDateTime64InJodaSyntaxOrZero('2025-01-04 23:00:00.123', 'yyyy-MM-dd HH:mm:ss.SSS')
```
```response title=Response theme={null}
┌─parseDateTime64InJodaSyntaxOrZero('2025-01-04 23:00:00.123', 'yyyy-MM-dd HH:mm:ss.SSS')─┐
│ 2025-01-04 23:00:00.123 │
└──────────────────────────────────────────────────────────────────────────────────────────┘
```
## parseDateTime64OrNull
Introduit dans : v24.11.0
Identique à [`parseDateTime64`](#parseDateTime64), mais renvoie `NULL` lorsqu’elle rencontre un format de date non analysable.
**Syntaxe**
```sql theme={null}
parseDateTime64OrNull(time_string, format[, timezone])
```
**Arguments**
* `time_string` — Chaîne à analyser en DateTime64. [`String`](/fr/reference/data-types/string)
* `format` — Chaîne de format indiquant comment analyser time\_string. [`String`](/fr/reference/data-types/string)
* `timezone` — Facultatif. Fuseau horaire. [`String`](/fr/reference/data-types/string)
**Valeur renvoyée**
Renvoie la valeur DateTime64 obtenue à partir de la chaîne d’entrée, ou NULL si l’analyse échoue. [`Nullable(DateTime64)`](/fr/reference/data-types/nullable)
**Exemples**
**Exemple d’utilisation**
```sql title=Query theme={null}
SELECT parseDateTime64OrNull('2025-01-04 23:00:00.123', '%Y-%m-%d %H:%i:%s.%f')
```
```response title=Response theme={null}
┌─parseDateTime64OrNull('2025-01-04 23:00:00.123', '%Y-%m-%d %H:%i:%s.%f')─┐
│ 2025-01-04 23:00:00.123 │
└───────────────────────────────────────────────────────────────────────────┘
```
## parseDateTime64OrZero
Introduit dans : v24.11.0
Identique à [`parseDateTime64`](#parseDateTime64), mais renvoie une date zéro lorsqu'un format de date ne peut pas être analysé.
**Syntaxe**
```sql theme={null}
parseDateTime64OrZero(time_string, format[, timezone])
```
**Arguments**
* `time_string` — Chaîne à convertir en DateTime64. [`String`](/fr/reference/data-types/string)
* `format` — Chaîne de format indiquant comment analyser time\_string. [`String`](/fr/reference/data-types/string)
* `timezone` — Facultatif. Fuseau horaire. [`String`](/fr/reference/data-types/string)
**Valeur renvoyée**
Renvoie la valeur DateTime64 analysée à partir de la chaîne d’entrée, ou la valeur DateTime64 zéro si l’analyse échoue. [`DateTime64`](/fr/reference/data-types/datetime64)
**Exemples**
**Exemple d'utilisation**
```sql title=Query theme={null}
SELECT parseDateTime64OrZero('2025-01-04 23:00:00.123', '%Y-%m-%d %H:%i:%s.%f')
```
```response title=Response theme={null}
┌─parseDateTime64OrZero('2025-01-04 23:00:00.123', '%Y-%m-%d %H:%i:%s.%f')─┐
│ 2025-01-04 23:00:00.123 │
└───────────────────────────────────────────────────────────────────────────┘
```
## parseDateTimeBestEffort
Introduced in: v1.1.0
Convertit une date et une heure de leur représentation String vers le type de données DateTime.
La fonction analyse les formats de date et d'heure [ISO 8601](https://www.iso.org/iso-8601-date-and-time-format.html), [RFC 1123 - 5.2.14 RFC-822](https://datatracker.ietf.org/doc/html/rfc822), le format de date et d'heure de ClickHouse, ainsi que certains autres formats.
Formats non standard pris en charge :
* Une chaîne contenant un timestamp Unix sur 9 à 10 chiffres.
* Une chaîne contenant une composante de date et une composante d'heure : `YYYYMMDDhhmmss`, `DD/MM/YYYY hh:mm:ss`, `DD-MM-YY hh:mm`, `YYYY-MM-DD hh:mm:ss`, etc.
* Une chaîne contenant une date, mais sans composante d'heure : `YYYY`, `YYYYMM`, `YYYY*MM`, `DD/MM/YYYY`, `DD-MM-YY`, etc.
* Une chaîne contenant un jour et une heure : `DD`, `DD hh`, `DD hh:mm`. Dans ce cas, `MM` est remplacé par `01`.
* Une chaîne incluant la date et l'heure ainsi que des informations de décalage de fuseau horaire : `YYYY-MM-DD hh:mm:ss ±h:mm`, etc.
* Un timestamp syslog : `Mmm dd hh:mm:ss`. Par exemple, `Jun 9 14:20:32`.
Pour tous les formats avec séparateur, la fonction analyse les noms de mois exprimés sous leur forme complète ou par les trois premières lettres du mois.
Si l'année n'est pas indiquée, l'année en cours est utilisée.
**Syntax**
```sql theme={null}
parseDateTimeBestEffort(time_string[, time_zone])
```
**Arguments**
* `time_string` — Chaîne contenant une date et une heure à convertir. [`String`](/fr/reference/data-types/string)
* `time_zone` — Facultatif. Fuseau horaire utilisé pour analyser `time_string`. [`String`](/fr/reference/data-types/string)
**Valeur renvoyée**
Renvoie `time_string` sous forme de `DateTime`. [`DateTime`](/fr/reference/data-types/datetime)
**Exemples**
**Exemple d'utilisation**
```sql title=Query theme={null}
SELECT parseDateTimeBestEffort('23/10/2025 12:12:57') AS parseDateTimeBestEffort
```
```response title=Response theme={null}
┌─parseDateTimeBestEffort─┐
│ 2025-10-23 12:12:57 │
└─────────────────────────┘
```
**Avec un fuseau horaire**
```sql title=Query theme={null}
SELECT parseDateTimeBestEffort('Sat, 18 Aug 2025 07:22:16 GMT', 'Asia/Istanbul') AS parseDateTimeBestEffort
```
```response title=Response theme={null}
┌─parseDateTimeBestEffort─┐
│ 2025-08-18 10:22:16 │
└─────────────────────────┘
```
**timestamp Unix**
```sql title=Query theme={null}
SELECT parseDateTimeBestEffort('1735689600') AS parseDateTimeBestEffort
```
```response title=Response theme={null}
┌─parseDateTimeBestEffort─┐
│ 2025-01-01 00:00:00 │
└─────────────────────────┘
```
## parseDateTimeBestEffortOrNull
Introduit dans : v1.1.0
Identique à [`parseDateTimeBestEffort`](#parseDateTimeBestEffort), sauf qu'elle renvoie `NULL` lorsqu'elle rencontre un format de date impossible à traiter.
La fonction analyse les formats [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601), [RFC 1123 - 5.2.14 RFC-822 Date and Time Specification](https://tools.ietf.org/html/rfc1123#page-55), celui de ClickHouse, ainsi que certains autres formats de date et d'heure.
Formats non standard pris en charge :
* Une chaîne contenant un timestamp Unix de 9 à 10 chiffres.
* Une chaîne avec une composante de date et une composante d'heure : `YYYYMMDDhhmmss`, `DD/MM/YYYY hh:mm:ss`, `DD-MM-YY hh:mm`, `YYYY-MM-DD hh:mm:ss`, etc.
* Une chaîne avec une date, mais sans composante d'heure : `YYYY`, `YYYYMM`, `YYYY*MM`, `DD/MM/YYYY`, `DD-MM-YY`, etc.
* Une chaîne contenant un jour et une heure : `DD`, `DD hh`, `DD hh:mm`. Dans ce cas, `MM` est remplacé par `01`.
* Une chaîne qui inclut la date et l'heure ainsi que des informations de décalage de fuseau horaire : `YYYY-MM-DD hh:mm:ss ±h:mm`, etc.
* Un timestamp syslog : `Mmm dd hh:mm:ss`. Par exemple, `Jun 9 14:20:32`.
Pour tous les formats avec séparateur, la fonction analyse les noms de mois écrits soit en toutes lettres, soit avec les trois premières lettres du mois.
Si l'année n'est pas spécifiée, elle est considérée comme étant l'année en cours.
**Syntaxe**
```sql theme={null}
parseDateTimeBestEffortOrNull(time_string[, time_zone])
```
**Arguments**
* `time_string` — `String` contenant une date et une heure à convertir. [`String`](/fr/reference/data-types/string)
* `time_zone` — Facultatif. Fuseau horaire selon lequel `time_string` est interprétée. [`String`](/fr/reference/data-types/string)
**Valeur renvoyée**
Renvoie `time_string` sous forme de `DateTime`, ou `NULL` si l’entrée ne peut pas être interprétée. [`DateTime`](/fr/reference/data-types/datetime) ou [`NULL`](/fr/reference/syntax#null)
**Exemples**
**Exemple d’utilisation**
```sql title=Query theme={null}
SELECT parseDateTimeBestEffortOrNull('23/10/2025 12:12:57') AS valid,
parseDateTimeBestEffortOrNull('invalid') AS invalid
```
```response title=Response theme={null}
┌─valid───────────────┬─invalid─┐
│ 2025-10-23 12:12:57 │ ᴺᵁᴸᴸ │
└─────────────────────┴─────────┘
```
## parseDateTimeBestEffortOrZero
Introduit dans : v1.1.0
Identique à [`parseDateTimeBestEffort`](#parseDateTimeBestEffort), à ceci près qu'elle renvoie une date zéro ou une date-heure zéro lorsqu'elle rencontre un format de date qui ne peut pas être analysé.
La fonction analyse [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601), [RFC 1123 - 5.2.14 RFC-822 Date and Time Specification](https://tools.ietf.org/html/rfc1123#page-55), les formats de date et d'heure de ClickHouse, ainsi que certains autres formats.
Formats non standard pris en charge :
* Une chaîne contenant un Unix timestamp de 9 à 10 chiffres.
* Une chaîne avec une composante de date et une composante d'heure : `YYYYMMDDhhmmss`, `DD/MM/YYYY hh:mm:ss`, `DD-MM-YY hh:mm`, `YYYY-MM-DD hh:mm:ss`, etc.
* Une chaîne avec une date, mais sans composante d'heure : `YYYY`, `YYYYMM`, `YYYY*MM`, `DD/MM/YYYY`, `DD-MM-YY` etc.
* Une chaîne avec un jour et une heure : `DD`, `DD hh`, `DD hh:mm`. Dans ce cas, `MM` est remplacé par `01`.
* Une chaîne qui inclut la date et l'heure, ainsi que des informations de décalage de fuseau horaire : `YYYY-MM-DD hh:mm:ss ±h:mm`, etc.
* Un syslog timestamp : `Mmm dd hh:mm:ss`. Par exemple, `Jun 9 14:20:32`.
Pour tous les formats avec séparateur, la fonction analyse les noms de mois exprimés sous leur forme complète ou par les trois premières lettres du mois.
Si l'année n'est pas spécifiée, elle est considérée comme étant l'année en cours.
**Syntaxe**
```sql theme={null}
parseDateTimeBestEffortOrZero(time_string[, time_zone])
```
**Arguments**
* `time_string` — `String` contenant une date et une heure à convertir. [`String`](/fr/reference/data-types/string)
* `time_zone` — Facultatif. Fuseau horaire utilisé pour interpréter `time_string`. [`String`](/fr/reference/data-types/string)
**Valeur renvoyée**
Renvoie `time_string` sous forme de `DateTime`, ou la date/date-heure zéro (`1970-01-01` ou `1970-01-01 00:00:00`) si l'entrée ne peut pas être interprétée. [`DateTime`](/fr/reference/data-types/datetime)
**Exemples**
**Exemple d'utilisation**
```sql title=Query theme={null}
SELECT parseDateTimeBestEffortOrZero('23/10/2025 12:12:57') AS valid,
parseDateTimeBestEffortOrZero('invalid') AS invalid
```
```response title=Response theme={null}
┌─valid───────────────┬─invalid─────────────┐
│ 2025-10-23 12:12:57 │ 1970-01-01 00:00:00 │
└─────────────────────┴─────────────────────┘
```
## parseDateTimeBestEffortUS
Introduite dans : v1.1.0
Cette fonction se comporte comme [`parseDateTimeBestEffort`](#parseDateTimeBestEffort) pour les formats de date ISO, par ex. `YYYY-MM-DD hh:mm:ss`, ainsi que pour d'autres formats de date dont les composants mois et jour peuvent être extraits sans ambiguïté, par ex. `YYYYMMDDhhmmss`, `YYYY-MM`, `DD hh` ou `YYYY-MM-DD hh:mm:ss ±h:mm`.
Si les composants mois et jour ne peuvent pas être extraits sans ambiguïté, par ex. `MM/DD/YYYY`, `MM-DD-YYYY` ou `MM-DD-YY`, elle privilégie le format de date US plutôt que `DD/MM/YYYY`, `DD-MM-YYYY` ou `DD-MM-YY`.
Exception à ce qui précède : si le mois est supérieur à 12 et inférieur ou égal à 31, cette fonction revient au comportement de [`parseDateTimeBestEffort`](#parseDateTimeBestEffort) ; par ex. `15/08/2020` est interprété comme `2020-08-15`.
**Syntaxe**
```sql theme={null}
parseDateTimeBestEffortUS(time_string[, time_zone])
```
**Arguments**
* `time_string` — `String` contenant une date et une heure à convertir. [`String`](/fr/reference/data-types/string)
* `time_zone` — Facultatif. Fuseau horaire selon lequel `time_string` est interprétée. [`String`](/fr/reference/data-types/string)
**Valeur renvoyée**
Renvoie `time_string` sous forme de `DateTime`, en privilégiant le format de date américain dans les cas ambigus. [`DateTime`](/fr/reference/data-types/datetime)
**Exemples**
**Exemple d'utilisation**
```sql title=Query theme={null}
SELECT parseDateTimeBestEffortUS('02/10/2025') AS us_format,
parseDateTimeBestEffortUS('15/08/2025') AS fallback_to_standard
```
```response title=Response theme={null}
┌─us_format───────────┬─fallback_to_standard─┐
│ 2025-02-10 00:00:00 │ 2025-08-15 00:00:00 │
└─────────────────────┴──────────────────────┘
```
## parseDateTimeBestEffortUSOrNull
Introduite dans : v1.1.0
Identique à la fonction [`parseDateTimeBestEffortUS`](#parseDateTimeBestEffortUS), sauf qu'elle renvoie `NULL` lorsqu'elle rencontre un format de date qui ne peut pas être traité.
Cette fonction se comporte comme [`parseDateTimeBestEffort`](#parseDateTimeBestEffort) pour les formats de date ISO, mais privilégie le format de date américain dans les cas ambigus, et renvoie `NULL` en cas d'erreur d'analyse.
**Syntaxe**
```sql theme={null}
parseDateTimeBestEffortUSOrNull(time_string[, time_zone])
```
**Arguments**
* `time_string` — Chaîne contenant une date et une heure à convertir. [`String`](/fr/reference/data-types/string)
* `time_zone` — Facultatif. Fuseau horaire selon lequel `time_string` est analysé. [`String`](/fr/reference/data-types/string)
**Valeur renvoyée**
Renvoie `time_string` sous forme de DateTime en privilégiant le format américain, ou `NULL` si l’entrée ne peut pas être analysée. [`DateTime`](/fr/reference/data-types/datetime) ou [`NULL`](/fr/reference/syntax#null)
**Exemples**
**Exemple d'utilisation**
```sql title=Query theme={null}
SELECT parseDateTimeBestEffortUSOrNull('02/10/2025') AS valid_us,
parseDateTimeBestEffortUSOrNull('invalid') AS invalid
```
```response title=Response theme={null}
┌─valid_us────────────┬─invalid─┐
│ 2025-02-10 00:00:00 │ ᴺᵁᴸᴸ │
└─────────────────────┴─────────┘
```
## parseDateTimeBestEffortUSOrZero
Introduit dans : v1.1.0
Identique à la fonction [`parseDateTimeBestEffortUS`](#parseDateTimeBestEffortUS), sauf qu'elle renvoie la date zéro (`1970-01-01`) ou la date zéro avec heure (`1970-01-01 00:00:00`) lorsqu'elle rencontre un format de date qui ne peut pas être analysé.
Cette fonction se comporte comme [`parseDateTimeBestEffort`](#parseDateTimeBestEffort) pour les formats de date ISO, mais privilégie le format de date américain dans les cas ambigus, et renvoie zéro en cas d'erreur d'analyse.
**Syntaxe**
```sql theme={null}
parseDateTimeBestEffortUSOrZero(time_string[, time_zone])
```
**Arguments**
* `time_string` — `String` contenant une date et une heure à convertir. [`String`](/fr/reference/data-types/string)
* `time_zone` — Facultatif. Fuseau horaire selon lequel `time_string` est analysé. [`String`](/fr/reference/data-types/string)
**Valeur renvoyée**
Renvoie `time_string` sous forme de `DateTime`, avec priorité au format US, ou une date/DateTime zéro (`1970-01-01` ou `1970-01-01 00:00:00`) si l’entrée ne peut pas être analysée. [`DateTime`](/fr/reference/data-types/datetime)
**Exemples**
**Exemple d’utilisation**
```sql title=Query theme={null}
SELECT parseDateTimeBestEffortUSOrZero('02/10/2025') AS valid_us,
parseDateTimeBestEffortUSOrZero('invalid') AS invalid
```
```response title=Response theme={null}
┌─valid_us────────────┬─invalid─────────────┐
│ 2025-02-10 00:00:00 │ 1970-01-01 00:00:00 │
└─────────────────────┴─────────────────────┘
```
## parseDateTimeInJodaSyntax
Introduit dans : v23.3.0
Analyse une chaîne de date et d’heure selon une chaîne de format de date Joda.
Cette fonction est l’inverse de [`formatDateTimeInJodaSyntax`](/fr/reference/functions/regular-functions/date-time-functions#formatDateTimeInJodaSyntax).
Elle analyse un argument String à l’aide d’une chaîne de format String de style Joda. Elle renvoie un type DateTime.
Consultez la [documentation Joda Time](https://joda-time.sourceforge.net/apidocs/org/joda/time/format/DateTimeFormat.html) pour les modèles de format.
**Syntaxe**
```sql theme={null}
parseDateTimeInJodaSyntax(time_string, format[, timezone])
```
**Arguments**
* `time_string` — Chaîne à convertir en DateTime. [`String`](/fr/reference/data-types/string)
* `format` — Chaîne de format en syntaxe Joda indiquant comment interpréter time\_string. [`String`](/fr/reference/data-types/string)
* `timezone` — Facultatif. Fuseau horaire. [`String`](/fr/reference/data-types/string)
**Valeur renvoyée**
Renvoie un DateTime obtenu à partir de la chaîne d'entrée selon la chaîne de format au style Joda. [`DateTime`](/fr/reference/data-types/datetime)
**Exemples**
**Exemple d'utilisation**
```sql title=Query theme={null}
SELECT parseDateTimeInJodaSyntax('2025-01-04 23:00:00', 'yyyy-MM-dd HH:mm:ss')
```
```response title=Response theme={null}
┌─parseDateTimeInJodaSyntax('2025-01-04 23:00:00', 'yyyy-MM-dd HH:mm:ss')─┐
│ 2025-01-04 23:00:00 │
└──────────────────────────────────────────────────────────────────────────┘
```
## parseDateTimeInJodaSyntaxOrNull
Introduit dans : v23.3.0
Identique à [`parseDateTimeInJodaSyntax`](#parseDateTimeInJodaSyntax), mais renvoie `NULL` en présence d’un format de date impossible à analyser.
**Syntaxe**
```sql theme={null}
parseDateTimeInJodaSyntaxOrNull(time_string, format[, timezone])
```
**Arguments**
* `time_string` — Chaîne à analyser pour obtenir un DateTime. [`String`](/fr/reference/data-types/string)
* `format` — Chaîne de format en syntaxe Joda indiquant comment analyser time\_string. [`String`](/fr/reference/data-types/string)
* `timezone` — Facultatif. Fuseau horaire. [`String`](/fr/reference/data-types/string)
**Valeur renvoyée**
Renvoie la valeur DateTime obtenue à partir de la chaîne d’entrée, ou NULL si l’analyse échoue. [`Nullable(DateTime)`](/fr/reference/data-types/nullable)
**Exemples**
**Exemple d’utilisation**
```sql title=Query theme={null}
SELECT parseDateTimeInJodaSyntaxOrNull('2025-01-04 23:00:00', 'yyyy-MM-dd HH:mm:ss')
```
```response title=Response theme={null}
┌─parseDateTimeInJodaSyntaxOrNull('2025-01-04 23:00:00', 'yyyy-MM-dd HH:mm:ss')─┐
│ 2025-01-04 23:00:00 │
└────────────────────────────────────────────────────────────────────────────────┘
```
## parseDateTimeInJodaSyntaxOrZero
Introduit dans : v23.3.0
Identique à [`parseDateTimeInJodaSyntax`](#parseDateTimeInJodaSyntax), mais renvoie une date zéro en cas de format de date impossible à analyser.
**Syntaxe**
```sql theme={null}
parseDateTimeInJodaSyntaxOrZero(time_string, format[, timezone])
```
**Arguments**
* `time_string` — Chaîne à analyser pour obtenir un DateTime. [`String`](/fr/reference/data-types/string)
* `format` — Chaîne de format en syntaxe Joda indiquant comment analyser time\_string. [`String`](/fr/reference/data-types/string)
* `timezone` — Optionnel. Fuseau horaire. [`String`](/fr/reference/data-types/string)
**Valeur renvoyée**
Renvoie le DateTime obtenu à partir de la chaîne d'entrée, ou le DateTime zéro si l'analyse échoue. [`DateTime`](/fr/reference/data-types/datetime)
**Exemples**
**Exemple d'utilisation**
```sql title=Query theme={null}
SELECT parseDateTimeInJodaSyntaxOrZero('2025-01-04 23:00:00', 'yyyy-MM-dd HH:mm:ss')
```
```response title=Response theme={null}
┌─parseDateTimeInJodaSyntaxOrZero('2025-01-04 23:00:00', 'yyyy-MM-dd HH:mm:ss')─┐
│ 2025-01-04 23:00:00 │
└────────────────────────────────────────────────────────────────────────────────┘
```
## parseDateTimeOrNull
Introduit dans : v23.3.0
Identique à [`parseDateTime`](#parseDateTime), mais renvoie `NULL` lorsqu’il rencontre un format de date non analysable.
**Syntaxe**
```sql theme={null}
parseDateTimeOrNull(time_string, format[, timezone])
```
**Alias** : `str_to_date`
**Arguments**
* `time_string` — Chaîne à analyser pour la convertir en `DateTime`. [`String`](/fr/reference/data-types/string)
* `format` — Chaîne de format indiquant comment analyser time\_string. [`String`](/fr/reference/data-types/string)
* `timezone` — Facultatif. Fuseau horaire. [`String`](/fr/reference/data-types/string)
**Valeur renvoyée**
Renvoie le `DateTime` obtenu à partir de la chaîne d'entrée, ou NULL si l'analyse échoue. [`Nullable(DateTime)`](/fr/reference/data-types/nullable)
**Exemples**
**Exemple d'utilisation**
```sql title=Query theme={null}
SELECT parseDateTimeOrNull('2025-01-04+23:00:00', '%Y-%m-%d+%H:%i:%s')
```
```response title=Response theme={null}
┌─parseDateTimeOrNull('2025-01-04+23:00:00', '%Y-%m-%d+%H:%i:%s')─┐
│ 2025-01-04 23:00:00 │
└─────────────────────────────────────────────────────────────────┘
```
## parseDateTimeOrZero
Introduit dans : v23.3.0
Identique à [`parseDateTime`](#parseDateTime), mais renvoie une date zéro lorsqu’un format de date ne peut pas être analysé.
**Syntaxe**
```sql theme={null}
parseDateTimeOrZero(time_string, format[, timezone])
```
**Arguments**
* `time_string` — Chaîne à convertir en DateTime. [`String`](/fr/reference/data-types/string)
* `format` — Chaîne de format indiquant comment analyser time\_string. [`String`](/fr/reference/data-types/string)
* `timezone` — Facultatif. Fuseau horaire. [`String`](/fr/reference/data-types/string)
**Valeur renvoyée**
Renvoie le DateTime obtenu à partir de la chaîne d'entrée, ou le DateTime zéro si l'analyse échoue. [`DateTime`](/fr/reference/data-types/datetime)
**Exemples**
**Exemple d'utilisation**
```sql title=Query theme={null}
SELECT parseDateTimeOrZero('2025-01-04+23:00:00', '%Y-%m-%d+%H:%i:%s')
```
```response title=Response theme={null}
┌─parseDateTimeOrZero('2025-01-04+23:00:00', '%Y-%m-%d+%H:%i:%s')─┐
│ 2025-01-04 23:00:00 │
└─────────────────────────────────────────────────────────────────┘
```
## reinterpret
Introduit dans : v1.1.0
Utilise la même séquence d’octets source en mémoire pour la valeur `x` fournie et la réinterprète dans le type de destination.
**Syntaxe**
```sql theme={null}
reinterpret(x, type)
```
**Arguments**
* `x` — N'importe quel type. [`Any`](/fr/reference/data-types/index)
* `type` — Type de destination. S'il s'agit d'un tableau, le type des éléments du tableau doit être de longueur fixe. [`String`](/fr/reference/data-types/string)
**Valeur renvoyée**
Valeur du type de destination. [`Any`](/fr/reference/data-types/index)
**Exemples**
**Exemple d'utilisation**
```sql title=Query theme={null}
SELECT reinterpret(toInt8(-1), 'UInt8') AS int_to_uint,
reinterpret(toInt8(1), 'Float32') AS int_to_float,
reinterpret('1', 'UInt32') AS string_to_int
```
```response title=Response theme={null}
┌─int_to_uint─┬─int_to_float─┬─string_to_int─┐
│ 255 │ 1e-45 │ 49 │
└─────────────┴──────────────┴───────────────┘
```
**Exemple de type Array**
```sql title=Query theme={null}
SELECT reinterpret(x'3108b4403108d4403108b4403108d440', 'Array(Float32)') AS string_to_array_of_Float32
```
```response title=Response theme={null}
┌─string_to_array_of_Float32─┐
│ [5.626,6.626,5.626,6.626] │
└────────────────────────────┘
```
## reinterpretAsDate
Introduit dans : v1.1.0
Réinterprète la valeur d’entrée comme une valeur de type Date (en supposant l’ordre little endian), correspondant au nombre de jours écoulés depuis le début de l’époque Unix, le 1970-01-01
**Syntaxe**
```sql theme={null}
reinterpretAsDate(x)
```
**Arguments**
* `x` — Nombre de jours depuis le début de l’époque Unix. [`(U)Int*`](/fr/reference/data-types/int-uint) ou [`Float*`](/fr/reference/data-types/float) ou [`Date`](/fr/reference/data-types/date) ou [`DateTime`](/fr/reference/data-types/datetime) ou [`UUID`](/fr/reference/data-types/uuid) ou [`String`](/fr/reference/data-types/string) ou [`FixedString`](/fr/reference/data-types/fixedstring)
**Valeur renvoyée**
Date. [`Date`](/fr/reference/data-types/date)
**Exemples**
**Exemple d'utilisation**
```sql title=Query theme={null}
SELECT reinterpretAsDate(65), reinterpretAsDate('A')
```
```response title=Response theme={null}
┌─reinterpretAsDate(65)─┬─reinterpretAsDate('A')─┐
│ 1970-03-07 │ 1970-03-07 │
└───────────────────────┴────────────────────────┘
```
## reinterpretAsDateTime
Introduit dans : v1.1.0
Réinterprète la valeur d’entrée comme une valeur DateTime (en supposant l’ordre little endian), c’est-à-dire comme le nombre de jours écoulés depuis le début de l’époque Unix, le 1970-01-01
**Syntaxe**
```sql theme={null}
reinterpretAsDateTime(x)
```
**Arguments**
* `x` — Nombre de secondes écoulées depuis le début de l’époque Unix. [`(U)Int*`](/fr/reference/data-types/int-uint) ou [`Float*`](/fr/reference/data-types/float) ou [`Date`](/fr/reference/data-types/date) ou [`DateTime`](/fr/reference/data-types/datetime) ou [`UUID`](/fr/reference/data-types/uuid) ou [`String`](/fr/reference/data-types/string) ou [`FixedString`](/fr/reference/data-types/fixedstring)
**Valeur renvoyée**
Date et heure. [`DateTime`](/fr/reference/data-types/datetime)
**Exemples**
**Exemple d’utilisation**
```sql title=Query theme={null}
SELECT reinterpretAsDateTime(65), reinterpretAsDateTime('A')
```
```response title=Response theme={null}
┌─reinterpretAsDateTime(65)─┬─reinterpretAsDateTime('A')─┐
│ 1970-01-01 01:01:05 │ 1970-01-01 01:01:05 │
└───────────────────────────┴────────────────────────────┘
```
## reinterpretAsFixedString
Introduit dans : v1.1.0
Réinterprète la valeur d’entrée comme une chaîne de longueur fixe (en supposant l’ordre little endian).
Les octets nuls en fin de chaîne sont ignorés. Par exemple, pour la valeur UInt32 255, la fonction renvoie une chaîne contenant un seul caractère.
**Syntaxe**
```sql theme={null}
reinterpretAsFixedString(x)
```
**Arguments**
* `x` — Valeur à réinterpréter en chaîne de caractères. [`(U)Int*`](/fr/reference/data-types/int-uint) ou [`Float*`](/fr/reference/data-types/float) ou [`Date`](/fr/reference/data-types/date) ou [`DateTime`](/fr/reference/data-types/datetime)
**Valeur renvoyée**
Chaîne de longueur fixe contenant les octets représentant `x`. [`FixedString`](/fr/reference/data-types/fixedstring)
**Exemples**
**Exemple d'utilisation**
```sql title=Query theme={null}
SELECT
reinterpretAsFixedString(toDateTime('1970-01-01 01:01:05')),
reinterpretAsFixedString(toDate('1970-03-07'))
```
```response title=Response theme={null}
┌─reinterpretAsFixedString(toDateTime('1970-01-01 01:01:05'))─┬─reinterpretAsFixedString(toDate('1970-03-07'))─┐
│ A │ A │
└─────────────────────────────────────────────────────────────┴────────────────────────────────────────────────┘
```
## reinterpretAsFloat32
Introduit dans : v1.1.0
Réinterprète la valeur d’entrée comme une valeur de type Float32.
Contrairement à [`CAST`](#CAST), la fonction ne cherche pas à préserver la valeur d’origine : si le type cible ne peut pas représenter le type d’entrée, la valeur de sortie est indéfinie.
**Syntaxe**
```sql theme={null}
reinterpretAsFloat32(x)
```
**Arguments**
* `x` — Valeur à réinterpréter comme Float32. [`(U)Int*`](/fr/reference/data-types/int-uint) ou [`Float*`](/fr/reference/data-types/float) ou [`Date`](/fr/reference/data-types/date) ou [`DateTime`](/fr/reference/data-types/datetime) ou [`UUID`](/fr/reference/data-types/uuid) ou [`String`](/fr/reference/data-types/string) ou [`FixedString`](/fr/reference/data-types/fixedstring)
**Valeur renvoyée**
Renvoie la valeur `x` réinterprétée. [`Float32`](/fr/reference/data-types/float)
**Exemples**
**Exemple d'utilisation**
```sql title=Query theme={null}
SELECT reinterpretAsUInt32(toFloat32(0.2)) AS x, reinterpretAsFloat32(x)
```
```response title=Response theme={null}
┌──────────x─┬─reinterpretAsFloat32(x)─┐
│ 1045220557 │ 0.2 │
└────────────┴─────────────────────────┘
```
## reinterpretAsFloat64
Introduit dans : v1.1.0
Réinterprète la valeur d’entrée comme une valeur de type Float64.
Contrairement à [`CAST`](#CAST), la fonction ne cherche pas à préserver la valeur d’origine : si le type cible ne peut pas représenter le type d’entrée, le résultat est indéfini.
**Syntaxe**
```sql theme={null}
reinterpretAsFloat64(x)
```
**Arguments**
* `x` — Valeur à réinterpréter en Float64. [`(U)Int*`](/fr/reference/data-types/int-uint) ou [`Float*`](/fr/reference/data-types/float) ou [`Date`](/fr/reference/data-types/date) ou [`DateTime`](/fr/reference/data-types/datetime) ou [`UUID`](/fr/reference/data-types/uuid) ou [`String`](/fr/reference/data-types/string) ou [`FixedString`](/fr/reference/data-types/fixedstring)
**Valeur renvoyée**
Renvoie la valeur `x` réinterprétée. [`Float64`](/fr/reference/data-types/float)
**Exemples**
**Exemple d'utilisation**
```sql title=Query theme={null}
SELECT reinterpretAsUInt64(toFloat64(0.2)) AS x, reinterpretAsFloat64(x)
```
```response title=Response theme={null}
┌───────────────────x─┬─reinterpretAsFloat64(x)─┐
│ 4596373779694328218 │ 0.2 │
└─────────────────────┴─────────────────────────┘
```
## reinterpretAsInt128
Introduit dans : v1.1.0
Réinterprète la valeur d’entrée comme une valeur de type Int128.
Contrairement à [`CAST`](#CAST), la fonction ne cherche pas à préserver la valeur d’origine : si le type cible ne peut pas représenter le type d’entrée, la sortie est indéfinie.
**Syntaxe**
```sql theme={null}
reinterpretAsInt128(x)
```
**Arguments**
* `x` — Valeur à réinterpréter en Int128. [`(U)Int*`](/fr/reference/data-types/int-uint) ou [`Float*`](/fr/reference/data-types/float) ou [`Date`](/fr/reference/data-types/date) ou [`DateTime`](/fr/reference/data-types/datetime) ou [`UUID`](/fr/reference/data-types/uuid) ou [`String`](/fr/reference/data-types/string) ou [`FixedString`](/fr/reference/data-types/fixedstring)
**Valeur renvoyée**
Renvoie la valeur `x` réinterprétée. [`Int128`](/fr/reference/data-types/int-uint)
**Exemples**
**Exemple d'utilisation**
```sql title=Query theme={null}
SELECT
toInt64(257) AS x,
toTypeName(x),
reinterpretAsInt128(x) AS res,
toTypeName(res)
```
```response title=Response theme={null}
┌───x─┬─toTypeName(x)─┬─res─┬─toTypeName(res)─┐
│ 257 │ Int64 │ 257 │ Int128 │
└─────┴───────────────┴─────┴─────────────────┘
```
## reinterpretAsInt16
Introduit dans : v1.1.0
Réinterprète la valeur d’entrée comme une valeur de type Int16.
Contrairement à [`CAST`](#CAST), la fonction ne cherche pas à préserver la valeur d’origine : si le type cible ne peut pas représenter le type d’entrée, la valeur de sortie est indéfinie.
**Syntaxe**
```sql theme={null}
reinterpretAsInt16(x)
```
**Arguments**
* `x` — Valeur à réinterpréter en Int16. [`(U)Int*`](/fr/reference/data-types/int-uint) ou [`Float*`](/fr/reference/data-types/float) ou [`Date`](/fr/reference/data-types/date) ou [`DateTime`](/fr/reference/data-types/datetime) ou [`UUID`](/fr/reference/data-types/uuid) ou [`String`](/fr/reference/data-types/string) ou [`FixedString`](/fr/reference/data-types/fixedstring)
**Valeur renvoyée**
Renvoie la valeur `x` réinterprétée. [`Int16`](/fr/reference/data-types/int-uint)
**Exemples**
**Exemple d'utilisation**
```sql title=Query theme={null}
SELECT
toInt8(257) AS x,
toTypeName(x),
reinterpretAsInt16(x) AS res,
toTypeName(res)
```
```response title=Response theme={null}
┌─x─┬─toTypeName(x)─┬─res─┬─toTypeName(res)─┐
│ 1 │ Int8 │ 1 │ Int16 │
└───┴───────────────┴─────┴─────────────────┘
```
## reinterpretAsInt256
Introduit dans : v1.1.0
Réinterprète la valeur d’entrée comme une valeur de type Int256.
Contrairement à [`CAST`](#CAST), la fonction ne cherche pas à préserver la valeur d’origine ; si le type cible ne peut pas représenter le type d’entrée, le résultat est indéfini.
**Syntaxe**
```sql theme={null}
reinterpretAsInt256(x)
```
**Arguments**
* `x` — Valeur à réinterpréter en Int256. [`(U)Int*`](/fr/reference/data-types/int-uint) ou [`Float*`](/fr/reference/data-types/float) ou [`Date`](/fr/reference/data-types/date) ou [`DateTime`](/fr/reference/data-types/datetime) ou [`UUID`](/fr/reference/data-types/uuid) ou [`String`](/fr/reference/data-types/string) ou [`FixedString`](/fr/reference/data-types/fixedstring)
**Valeur renvoyée**
Renvoie la valeur `x` réinterprétée. [`Int256`](/fr/reference/data-types/int-uint)
**Exemples**
**Exemple d'utilisation**
```sql title=Query theme={null}
SELECT
toInt128(257) AS x,
toTypeName(x),
reinterpretAsInt256(x) AS res,
toTypeName(res)
```
```response title=Response theme={null}
┌───x─┬─toTypeName(x)─┬─res─┬─toTypeName(res)─┐
│ 257 │ Int128 │ 257 │ Int256 │
└─────┴───────────────┴─────┴─────────────────┘
```
## reinterpretAsInt32
Introduit dans : v1.1.0
Réinterprète la valeur d’entrée comme une valeur de type Int32.
Contrairement à [`CAST`](#CAST), la fonction ne cherche pas à préserver la valeur d’origine ; si le type cible ne peut pas représenter le type d’entrée, le résultat est indéfini.
**Syntaxe**
```sql theme={null}
reinterpretAsInt32(x)
```
**Arguments**
* `x` — Valeur à réinterpréter en Int32. [`(U)Int*`](/fr/reference/data-types/int-uint) ou [`Float*`](/fr/reference/data-types/float) ou [`Date`](/fr/reference/data-types/date) ou [`DateTime`](/fr/reference/data-types/datetime) ou [`UUID`](/fr/reference/data-types/uuid) ou [`String`](/fr/reference/data-types/string) ou [`FixedString`](/fr/reference/data-types/fixedstring)
**Valeur renvoyée**
Renvoie la valeur réinterprétée `x`. [`Int32`](/fr/reference/data-types/int-uint)
**Exemples**
**Exemple d'utilisation**
```sql title=Query theme={null}
SELECT
toInt16(257) AS x,
toTypeName(x),
reinterpretAsInt32(x) AS res,
toTypeName(res)
```
```response title=Response theme={null}
┌───x─┬─toTypeName(x)─┬─res─┬─toTypeName(res)─┐
│ 257 │ Int16 │ 257 │ Int32 │
└─────┴───────────────┴─────┴─────────────────┘
```
## reinterpretAsInt64
Introduite dans : v1.1.0
Réinterprète la valeur d'entrée comme une valeur de type Int64.
Contrairement à [`CAST`](#CAST), cette fonction ne cherche pas à préserver la valeur d'origine : si le type cible n'est pas capable de représenter le type d'entrée, la valeur de sortie est indéfinie.
**Syntaxe**
```sql theme={null}
reinterpretAsInt64(x)
```
**Arguments**
* `x` — Valeur à réinterpréter en Int64. [`(U)Int*`](/fr/reference/data-types/int-uint) ou [`Float*`](/fr/reference/data-types/float) ou [`Date`](/fr/reference/data-types/date) ou [`DateTime`](/fr/reference/data-types/datetime) ou [`UUID`](/fr/reference/data-types/uuid) ou [`String`](/fr/reference/data-types/string) ou [`FixedString`](/fr/reference/data-types/fixedstring)
**Valeur renvoyée**
Renvoie la valeur `x` réinterprétée. [`Int64`](/fr/reference/data-types/int-uint)
**Exemples**
**Exemple d'utilisation**
```sql title=Query theme={null}
SELECT
toInt32(257) AS x,
toTypeName(x),
reinterpretAsInt64(x) AS res,
toTypeName(res)
```
```response title=Response theme={null}
┌───x─┬─toTypeName(x)─┬─res─┬─toTypeName(res)─┐
│ 257 │ Int32 │ 257 │ Int64 │
└─────┴───────────────┴─────┴─────────────────┘
```
## reinterpretAsInt8
Introduit dans : v1.1.0
Réinterprète la valeur d'entrée comme une valeur de type Int8.
Contrairement à [`CAST`](#CAST), la fonction ne cherche pas à préserver la valeur d'origine : si le type cible ne peut pas représenter le type d'entrée, la sortie est indéfinie.
**Syntaxe**
```sql theme={null}
reinterpretAsInt8(x)
```
**Arguments**
* `x` — Valeur à réinterpréter en Int8. [`(U)Int*`](/fr/reference/data-types/int-uint) ou [`Float*`](/fr/reference/data-types/float) ou [`Date`](/fr/reference/data-types/date) ou [`DateTime`](/fr/reference/data-types/datetime) ou [`UUID`](/fr/reference/data-types/uuid) ou [`String`](/fr/reference/data-types/string) ou [`FixedString`](/fr/reference/data-types/fixedstring)
**Valeur renvoyée**
Renvoie la valeur réinterprétée `x`. [`Int8`](/fr/reference/data-types/int-uint)
**Exemples**
**Exemple d'utilisation**
```sql title=Query theme={null}
SELECT
toUInt8(257) AS x,
toTypeName(x),
reinterpretAsInt8(x) AS res,
toTypeName(res)
```
```response title=Response theme={null}
┌─x─┬─toTypeName(x)─┬─res─┬─toTypeName(res)─┐
│ 1 │ UInt8 │ 1 │ Int8 │
└───┴───────────────┴─────┴─────────────────┘
```
## reinterpretAsString
Introduit dans : v1.1.0
Réinterprète la valeur d’entrée comme une chaîne de caractères (en supposant l’ordre little endian).
Les octets nuls en fin de chaîne sont ignorés. Par exemple, pour la valeur UInt32 255, la fonction renvoie une chaîne ne contenant qu’un seul caractère.
**Syntaxe**
```sql theme={null}
reinterpretAsString(x)
```
**Arguments**
* `x` — Valeur à réinterpréter en chaîne de caractères. [`(U)Int*`](/fr/reference/data-types/int-uint) ou [`Float*`](/fr/reference/data-types/float) ou [`Date`](/fr/reference/data-types/date) ou [`DateTime`](/fr/reference/data-types/datetime)
**Valeur renvoyée**
Chaîne contenant les octets représentant `x`. [`String`](/fr/reference/data-types/string)
**Exemples**
**Exemple d'utilisation**
```sql title=Query theme={null}
SELECT
reinterpretAsString(toDateTime('1970-01-01 01:01:05')),
reinterpretAsString(toDate('1970-03-07'))
```
```response title=Response theme={null}
┌─reinterpretAsString(toDateTime('1970-01-01 01:01:05'))─┬─reinterpretAsString(toDate('1970-03-07'))─┐
│ A │ A │
└────────────────────────────────────────────────────────┴───────────────────────────────────────────┘
```
## reinterpretAsUInt128
Introduit dans : v1.1.0
Réinterprète la valeur d’entrée comme une valeur de type UInt128.
Contrairement à [`CAST`](#CAST), la fonction ne cherche pas à préserver la valeur d’origine : si le type cible n’est pas capable de représenter le type d’entrée, la valeur de sortie est indéfinie.
**Syntaxe**
```sql theme={null}
reinterpretAsUInt128(x)
```
**Arguments**
* `x` — Valeur à réinterpréter en UInt128. [`(U)Int*`](/fr/reference/data-types/int-uint) ou [`Float*`](/fr/reference/data-types/float) ou [`Date`](/fr/reference/data-types/date) ou [`DateTime`](/fr/reference/data-types/datetime) ou [`UUID`](/fr/reference/data-types/uuid) ou [`String`](/fr/reference/data-types/string) ou [`FixedString`](/fr/reference/data-types/fixedstring)
**Valeur renvoyée**
Renvoie la valeur `x` réinterprétée. [`UInt128`](/fr/reference/data-types/int-uint)
**Exemples**
**Exemple d'utilisation**
```sql title=Query theme={null}
SELECT
toUInt64(257) AS x,
toTypeName(x),
reinterpretAsUInt128(x) AS res,
toTypeName(res)
```
```response title=Response theme={null}
┌───x─┬─toTypeName(x)─┬─res─┬─toTypeName(res)─┐
│ 257 │ UInt64 │ 257 │ UInt128 │
└─────┴───────────────┴─────┴─────────────────┘
```
## reinterpretAsUInt16
Introduit dans : v1.1.0
Réinterprète la valeur d’entrée comme une valeur de type UInt16.
Contrairement à [`CAST`](#CAST), la fonction ne tente pas de préserver la valeur d’origine : si le type cible ne peut pas représenter le type d’entrée, le résultat est indéfini.
**Syntaxe**
```sql theme={null}
reinterpretAsUInt16(x)
```
**Arguments**
* `x` — Valeur à réinterpréter comme UInt16. [`(U)Int*`](/fr/reference/data-types/int-uint) ou [`Float*`](/fr/reference/data-types/float) ou [`Date`](/fr/reference/data-types/date) ou [`DateTime`](/fr/reference/data-types/datetime) ou [`UUID`](/fr/reference/data-types/uuid) ou [`String`](/fr/reference/data-types/string) ou [`FixedString`](/fr/reference/data-types/fixedstring)
**Valeur renvoyée**
Renvoie la valeur `x` réinterprétée. [`UInt16`](/fr/reference/data-types/int-uint)
**Exemples**
**Exemple d'utilisation**
```sql title=Query theme={null}
SELECT
toUInt8(257) AS x,
toTypeName(x),
reinterpretAsUInt16(x) AS res,
toTypeName(res)
```
```response title=Response theme={null}
┌─x─┬─toTypeName(x)─┬─res─┬─toTypeName(res)─┐
│ 1 │ UInt8 │ 1 │ UInt16 │
└───┴───────────────┴─────┴─────────────────┘
```
## reinterpretAsUInt256
Introduit dans : v1.1.0
Réinterprète la valeur d’entrée comme une valeur de type UInt256.
Contrairement à [`CAST`](#CAST), la fonction ne cherche pas à préserver la valeur d’origine : si le type cible ne peut pas représenter le type d’entrée, le résultat est indéfini.
**Syntaxe**
```sql theme={null}
reinterpretAsUInt256(x)
```
**Arguments**
* `x` — valeur à réinterpréter en UInt256. [`(U)Int*`](/fr/reference/data-types/int-uint) ou [`Float*`](/fr/reference/data-types/float) ou [`Date`](/fr/reference/data-types/date) ou [`DateTime`](/fr/reference/data-types/datetime) ou [`UUID`](/fr/reference/data-types/uuid) ou [`String`](/fr/reference/data-types/string) ou [`FixedString`](/fr/reference/data-types/fixedstring)
**Valeur renvoyée**
Renvoie la valeur `x` réinterprétée. [`UInt256`](/fr/reference/data-types/int-uint)
**Exemples**
**Exemple d'utilisation**
```sql title=Query theme={null}
SELECT
toUInt128(257) AS x,
toTypeName(x),
reinterpretAsUInt256(x) AS res,
toTypeName(res)
```
```response title=Response theme={null}
┌───x─┬─toTypeName(x)─┬─res─┬─toTypeName(res)─┐
│ 257 │ UInt128 │ 257 │ UInt256 │
└─────┴───────────────┴─────┴─────────────────┘
```
## reinterpretAsUInt32
Introduit dans : v1.1.0
Réinterprète la valeur d'entrée comme une valeur de type UInt32.
Contrairement à [`CAST`](#CAST), la fonction ne cherche pas à préserver la valeur d'origine : si le type cible ne peut pas représenter le type d'entrée, la sortie est indéfinie.
**Syntaxe**
```sql theme={null}
reinterpretAsUInt32(x)
```
**Arguments**
* `x` — Valeur à réinterpréter sous forme de UInt32. [`(U)Int*`](/fr/reference/data-types/int-uint) ou [`Float*`](/fr/reference/data-types/float) ou [`Date`](/fr/reference/data-types/date) ou [`DateTime`](/fr/reference/data-types/datetime) ou [`UUID`](/fr/reference/data-types/uuid) ou [`String`](/fr/reference/data-types/string) ou [`FixedString`](/fr/reference/data-types/fixedstring)
**Valeur renvoyée**
Renvoie la valeur `x` réinterprétée. [`UInt32`](/fr/reference/data-types/int-uint)
**Exemples**
**Exemple d’utilisation**
```sql title=Query theme={null}
SELECT
toUInt16(257) AS x,
toTypeName(x),
reinterpretAsUInt32(x) AS res,
toTypeName(res)
```
```response title=Response theme={null}
┌───x─┬─toTypeName(x)─┬─res─┬─toTypeName(res)─┐
│ 257 │ UInt16 │ 257 │ UInt32 │
└─────┴───────────────┴─────┴─────────────────┘
```
## reinterpretAsUInt64
Introduit dans : v1.1.0
Réinterprète la valeur d’entrée comme une valeur de type UInt64.
Contrairement à [`CAST`](#CAST), la fonction ne cherche pas à préserver la valeur d’origine : si le type cible ne peut pas représenter le type d’entrée, la sortie est indéfinie.
**Syntaxe**
```sql theme={null}
reinterpretAsUInt64(x)
```
**Arguments**
* `x` — Valeur à réinterpréter en UInt64. [`Int*`](/fr/reference/data-types/int-uint) ou [`UInt*`](/fr/reference/data-types/int-uint) ou [`Float*`](/fr/reference/data-types/float) ou [`Date`](/fr/reference/data-types/date) ou [`DateTime`](/fr/reference/data-types/datetime) ou [`UUID`](/fr/reference/data-types/uuid) ou [`String`](/fr/reference/data-types/string) ou [`FixedString`](/fr/reference/data-types/fixedstring)
**Valeur renvoyée**
Renvoie la valeur de `x` réinterprétée. [`UInt64`](/fr/reference/data-types/int-uint)
**Exemples**
**Exemple d'utilisation**
```sql title=Query theme={null}
SELECT
toUInt32(257) AS x,
toTypeName(x),
reinterpretAsUInt64(x) AS res,
toTypeName(res)
```
```response title=Response theme={null}
┌───x─┬─toTypeName(x)─┬─res─┬─toTypeName(res)─┐
│ 257 │ UInt32 │ 257 │ UInt64 │
└─────┴───────────────┴─────┴─────────────────┘
```
## reinterpretAsUInt8
Introduite dans : v1.1.0
Réinterprète la valeur d'entrée en valeur de type UInt8.
Contrairement à [`CAST`](#CAST), la fonction ne cherche pas à préserver la valeur d'origine : si le type cible ne peut pas représenter le type d'entrée, la valeur de sortie est indéfinie.
**Syntaxe**
```sql theme={null}
reinterpretAsUInt8(x)
```
**Arguments**
* `x` — Valeur à réinterpréter en UInt8. [`(U)Int*`](/fr/reference/data-types/int-uint) ou [`Float*`](/fr/reference/data-types/float) ou [`Date`](/fr/reference/data-types/date) ou [`DateTime`](/fr/reference/data-types/datetime) ou [`UUID`](/fr/reference/data-types/uuid) ou [`String`](/fr/reference/data-types/string) ou [`FixedString`](/fr/reference/data-types/fixedstring)
**Valeur renvoyée**
Renvoie la valeur `x` réinterprétée. [`UInt8`](/fr/reference/data-types/int-uint)
**Exemples**
**Exemple d'utilisation**
```sql title=Query theme={null}
SELECT
toInt8(-1) AS val,
toTypeName(val),
reinterpretAsUInt8(val) AS res,
toTypeName(res);
```
```response title=Response theme={null}
┌─val─┬─toTypeName(val)─┬─res─┬─toTypeName(res)─┐
│ -1 │ Int8 │ 255 │ UInt8 │
└─────┴─────────────────┴─────┴─────────────────┘
```
## reinterpretAsUUID
Introduit dans : v1.1.0
Accepte une chaîne de 16 octets et renvoie un UUID en interprétant chaque moitié de 8 octets selon l’ordre des octets little-endian. Si la chaîne n’est pas assez longue, la fonction se comporte comme si elle était complétée à la fin par le nombre nécessaire d’octets nuls. Si la chaîne dépasse 16 octets, les octets supplémentaires à la fin sont ignorés.
**Syntaxe**
```sql theme={null}
reinterpretAsUUID(fixed_string)
```
**Arguments**
* `fixed_string` — Chaîne d’octets au format big-endian. [`FixedString`](/fr/reference/data-types/fixedstring)
**Valeur renvoyée**
Valeur de type UUID. [`UUID`](/fr/reference/data-types/uuid)
**Exemples**
**Chaîne en UUID**
```sql title=Query theme={null}
SELECT reinterpretAsUUID(reverse(unhex('000102030405060708090a0b0c0d0e0f')))
```
```response title=Response theme={null}
┌─reinterpretAsUUID(reverse(unhex('000102030405060708090a0b0c0d0e0f')))─┐
│ 08090a0b-0c0d-0e0f-0001-020304050607 │
└───────────────────────────────────────────────────────────────────────┘
```
## toBFloat16
Introduit dans : v1.1.0
Convertit une valeur d’entrée en une valeur de type BFloat16.
Lève une exception en cas d’erreur.
Voir aussi :
* [`toBFloat16OrZero`](#toBFloat16OrZero).
* [`toBFloat16OrNull`](#toBFloat16OrNull).
**Syntaxe**
```sql theme={null}
toBFloat16(expr)
```
**Arguments**
* `expr` — Expression qui renvoie un nombre ou sa représentation sous forme de chaîne. [`Expression`](/fr/reference/data-types/special-data-types/expression)
**Valeur renvoyée**
Renvoie une valeur brain-float de 16 bits. [`BFloat16`](/fr/reference/data-types/float)
**Exemples**
**Exemple d’utilisation**
```sql title=Query theme={null}
SELECT
toBFloat16(toFloat32(42.7)),
toBFloat16(toFloat32('42.7')),
toBFloat16('42.7')
FORMAT Vertical;
```
```response title=Response theme={null}
toBFloat16(toFloat32(42.7)): 42.5
toBFloat16(t⋯32('42.7')): 42.5
toBFloat16('42.7'): 42.5
```
## toBFloat16OrNull
Introduite dans : v1.1.0
Convertit une valeur d'entrée de type String en une valeur de type BFloat16.
Si la chaîne ne représente pas une valeur à virgule flottante, la fonction renvoie NULL.
Arguments pris en charge :
* Représentations sous forme de chaîne de valeurs numériques.
Arguments non pris en charge (renvoient `NULL`) :
* Représentations sous forme de chaîne de valeurs binaires et hexadécimales.
* Valeurs numériques.
La fonction autorise une perte de précision silencieuse lors de la conversion depuis la représentation sous forme de chaîne.
Voir aussi :
* [`toBFloat16`](#toBFloat16).
* [`toBFloat16OrZero`](#toBFloat16OrZero).
**Syntaxe**
```sql theme={null}
toBFloat16OrNull(x)
```
**Arguments**
* `x` — Représentation sous forme de chaîne d’un nombre. [`String`](/fr/reference/data-types/string)
**Valeur renvoyée**
Renvoie une valeur brain-float de 16 bits, sinon `NULL`. [`BFloat16`](/fr/reference/data-types/float) ou [`NULL`](/fr/reference/syntax#null)
**Exemples**
**Exemple d’utilisation**
```sql title=Query theme={null}
SELECT toBFloat16OrNull('0x5E'), -- unsupported arguments
toBFloat16OrNull('12.3'), -- typical use
toBFloat16OrNull('12.3456789') -- silent loss of precision
```
```response title=Response theme={null}
\N
12.25
12.3125
```
## toBFloat16OrZero
Introduit dans : v1.1.0
Convertit une valeur d’entrée de type String en une valeur de type BFloat16.
Si la chaîne ne représente pas une valeur en virgule flottante, la fonction renvoie zéro.
Arguments pris en charge :
* Représentations String de valeurs numériques.
Arguments non pris en charge (renvoient `0`) :
* Représentations String de valeurs binaires et hexadécimales.
* Valeurs numériques.
La fonction autorise une perte de précision silencieuse lors de la conversion depuis une représentation String.
Voir aussi :
* [`toBFloat16`](#toBFloat16).
* [`toBFloat16OrNull`](#toBFloat16OrNull).
**Syntaxe**
```sql theme={null}
toBFloat16OrZero(x)
```
**Arguments**
* `x` — Représentation sous forme de chaîne d'un nombre. [`String`](/fr/reference/data-types/string)
**Valeur renvoyée**
Renvoie une valeur brain-float sur 16 bits, sinon `0`. [`BFloat16`](/fr/reference/data-types/float)
**Exemples**
**Exemple d'utilisation**
```sql title=Query theme={null}
SELECT toBFloat16OrZero('0x5E'), -- unsupported arguments
toBFloat16OrZero('12.3'), -- typical use
toBFloat16OrZero('12.3456789') -- silent loss of precision
```
```response title=Response theme={null}
0
12.25
12.3125
```
## toBool
Introduit dans : v22.2.0
Convertit une valeur d’entrée en valeur de type Bool.
**Syntaxe**
```sql theme={null}
toBool(expr)
```
**Arguments**
* `expr` — Expression renvoyant un nombre ou une chaîne de caractères. Pour les chaînes de caractères, accepte 'true' ou 'false' (insensible à la casse). [`(U)Int*`](/fr/reference/data-types/int-uint) ou [`Float*`](/fr/reference/data-types/float) ou [`String`](/fr/reference/data-types/string) ou [`Expression`](/fr/reference/data-types/special-data-types/expression)
**Valeur renvoyée**
Renvoie `true` ou `false` en fonction de l'évaluation de l'argument. [`Bool`](/fr/reference/data-types/boolean)
**Exemples**
**Exemple d'utilisation**
```sql title=Query theme={null}
SELECT
toBool(toUInt8(1)),
toBool(toInt8(-1)),
toBool(toFloat32(1.01)),
toBool('true'),
toBool('false'),
toBool('FALSE')
FORMAT Vertical
```
```response title=Response theme={null}
toBool(toUInt8(1)): true
toBool(toInt8(-1)): true
toBool(toFloat32(1.01)): true
toBool('true'): true
toBool('false'): false
toBool('FALSE'): false
```
## toDate
Introduit dans : v1.1.0
Convertit une valeur d’entrée au type [`Date`](/fr/reference/data-types/date).
Prend en charge la conversion à partir de String, FixedString, DateTime ou de types numériques.
**Syntaxe**
```sql theme={null}
toDate(x)
```
**Arguments**
* `x` — Valeur d’entrée à convertir. [`String`](/fr/reference/data-types/string) ou [`FixedString`](/fr/reference/data-types/fixedstring) ou [`DateTime`](/fr/reference/data-types/datetime) ou [`(U)Int*`](/fr/reference/data-types/int-uint) ou [`Float*`](/fr/reference/data-types/float)
**Valeur renvoyée**
Renvoie la valeur d’entrée convertie. [`Date`](/fr/reference/data-types/date)
**Exemples**
**Conversion de String en Date**
```sql title=Query theme={null}
SELECT toDate('2025-04-15')
```
```response title=Response theme={null}
2025-04-15
```
**Conversion de DateTime en Date**
```sql title=Query theme={null}
SELECT toDate(toDateTime('2025-04-15 10:30:00'))
```
```response title=Response theme={null}
2025-04-15
```
**Conversion d’un entier en Date**
```sql title=Query theme={null}
SELECT toDate(20297)
```
```response title=Response theme={null}
2025-07-28
```
## toDate32
Introduit dans : v21.9.0
Convertit l’argument en type de données [Date32](/fr/reference/data-types/date32).
Si la valeur est hors de la plage, `toDate32` renvoie les valeurs limites prises en charge par [Date32](/fr/reference/data-types/date32).
Si l’argument est de type [`Date`](/fr/reference/data-types/date), ses limites sont prises en compte.
**Syntaxe**
```sql theme={null}
toDate32(expr)
```
**Arguments**
* `expr` — La valeur à convertir. [`String`](/fr/reference/data-types/string) ou [`UInt32`](/fr/reference/data-types/int-uint) ou [`Date`](/fr/reference/data-types/date)
**Valeur renvoyée**
Renvoie une date calendaire. [`Date32`](/fr/reference/data-types/date32)
**Exemples**
**Dans la plage**
```sql title=Query theme={null}
SELECT toDate32('2025-01-01') AS value, toTypeName(value)
FORMAT Vertical
```
```response title=Response theme={null}
Row 1:
──────
value: 2025-01-01
toTypeName(value): Date32
```
**Hors limites**
```sql title=Query theme={null}
SELECT toDate32('1899-01-01') AS value, toTypeName(value)
FORMAT Vertical
```
```response title=Response theme={null}
Row 1:
──────
value: 1900-01-01
toTypeName(value): Date32
```
## toDate32OrDefault
Introduite dans : v21.11.0
Convertit l’argument en type de données [Date32](/fr/reference/data-types/date32). Si la valeur est hors plage, `toDate32OrDefault` renvoie la valeur de borne inférieure prise en charge par [Date32](/fr/reference/data-types/date32). Si l’argument est de type [Date](/fr/reference/data-types/date), ses bornes sont prises en compte. Renvoie la valeur par défaut si un argument invalide est fourni.
**Syntaxe**
```sql theme={null}
toDate32OrDefault(expr[, default])
```
**Arguments**
* `expr` — Expression qui renvoie un nombre ou la représentation textuelle d’un nombre. [`String`](/fr/reference/data-types/string) ou [`(U)Int*`](/fr/reference/data-types/int-uint) ou [`Float*`](/fr/reference/data-types/float)
* `default` — Facultatif. Valeur par défaut à renvoyer si l’analyse échoue. [`Date32`](/fr/reference/data-types/date32)
**Valeur renvoyée**
Une valeur de type Date32 en cas de succès ; sinon, renvoie la valeur par défaut si elle est fournie, ou 1900-01-01 dans le cas contraire. [`Date32`](/fr/reference/data-types/date32)
**Exemples**
**Conversion réussie**
```sql title=Query theme={null}
SELECT toDate32OrDefault('1930-01-01', toDate32('2020-01-01'))
```
```response title=Response theme={null}
1930-01-01
```
**Échec de la conversion**
```sql title=Query theme={null}
SELECT toDate32OrDefault('xx1930-01-01', toDate32('2020-01-01'))
```
```response title=Response theme={null}
2020-01-01
```
## toDate32OrNull
Introduit dans : v21.9.0
Convertit une valeur d’entrée en une valeur de type Date32, mais renvoie `NULL` si un argument invalide est fourni.
Identique à [`toDate32`](#toDate32), mais renvoie `NULL` si un argument invalide est fourni.
**Syntaxe**
```sql theme={null}
toDate32OrNull(x)
```
**Arguments**
* `x` — Une représentation sous forme de chaîne d’une date. [`String`](/fr/reference/data-types/string)
**Valeur renvoyée**
Renvoie une valeur Date32 en cas de succès, sinon `NULL`. [`Date32`](/fr/reference/data-types/date32) ou [`NULL`](/fr/reference/syntax#null)
**Exemples**
**Exemple d’utilisation**
```sql title=Query theme={null}
SELECT toDate32OrNull('2025-01-01'), toDate32OrNull('invalid')
```
```response title=Response theme={null}
┌─toDate32OrNull('2025-01-01')─┬─toDate32OrNull('invalid')─┐
│ 2025-01-01 │ ᴺᵁᴸᴸ │
└──────────────────────────────┴───────────────────────────┘
```
## toDate32OrZero
Introduit dans : v21.9.0
Convertit une valeur d’entrée en une valeur de type [Date32](/fr/reference/data-types/date32), mais renvoie la borne inférieure de [Date32](/fr/reference/data-types/date32) si l’argument n’est pas valide.
Identique à [toDate32](#toDate32), mais renvoie la borne inférieure de [Date32](/fr/reference/data-types/date32) si l’argument n’est pas valide.
Voir aussi :
* [`toDate32`](#toDate32)
* [`toDate32OrNull`](#toDate32OrNull)
* [`toDate32OrDefault`](#toDate32OrDefault)
**Syntaxe**
```sql theme={null}
toDate32OrZero(x)
```
**Arguments**
* `x` — Une représentation textuelle d'une date. [`String`](/fr/reference/data-types/string)
**Valeur renvoyée**
Renvoie une valeur `Date32` en cas de réussite ; sinon, la borne inférieure de `Date32` (`1900-01-01`). [`Date32`](/fr/reference/data-types/date32)
**Exemples**
**Exemple d'utilisation**
```sql title=Query theme={null}
SELECT toDate32OrZero('2025-01-01'), toDate32OrZero('')
```
```response title=Response theme={null}
┌─toDate32OrZero('2025-01-01')─┬─toDate32OrZero('')─┐
│ 2025-01-01 │ 1900-01-01 │
└──────────────────────────────┴────────────────────┘
```
## toDateOrDefault
Introduit dans : v21.11.0
Comme [toDate](#toDate), mais en cas d'échec, renvoie une valeur par défaut : le deuxième argument (s'il est spécifié) ou, à défaut, la borne inférieure de [Date](/fr/reference/data-types/date).
**Syntaxe**
```sql theme={null}
toDateOrDefault(expr[, default])
```
**Arguments**
* `expr` — Expression renvoyant un nombre ou une représentation textuelle d'un nombre. [`String`](/fr/reference/data-types/string) ou [`(U)Int*`](/fr/reference/data-types/int-uint) ou [`Float*`](/fr/reference/data-types/float)
* `default` — Facultatif. Valeur par défaut à renvoyer si l'analyse échoue. [`Date`](/fr/reference/data-types/date)
**Valeur renvoyée**
Une valeur de type Date en cas de réussite ; sinon, renvoie la valeur par défaut si elle est fournie, ou 1970-01-01 dans le cas contraire. [`Date`](/fr/reference/data-types/date)
**Exemples**
**Conversion réussie**
```sql title=Query theme={null}
SELECT toDateOrDefault('2022-12-30')
```
```response title=Response theme={null}
2022-12-30
```
**Échec de la conversion**
```sql title=Query theme={null}
SELECT toDateOrDefault('', CAST('2023-01-01', 'Date'))
```
```response title=Response theme={null}
2023-01-01
```
## toDateOrNull
Introduit dans : v1.1.0
Convertit une valeur d’entrée en une valeur de type `Date`, mais renvoie `NULL` si un argument invalide est fourni.
Identique à [`toDate`](#toDate), mais renvoie `NULL` si un argument invalide est fourni.
**Syntaxe**
```sql theme={null}
toDateOrNull(x)
```
**Arguments**
* `x` — Une date sous forme de chaîne de caractères. [`String`](/fr/reference/data-types/string)
**Valeur renvoyée**
Renvoie une valeur `Date` en cas de succès, sinon `NULL`. [`Date`](/fr/reference/data-types/date) ou [`NULL`](/fr/reference/syntax#null)
**Exemples**
**Exemple d’utilisation**
```sql title=Query theme={null}
SELECT toDateOrNull('2025-12-30'), toDateOrNull('invalid')
```
```response title=Response theme={null}
┌─toDateOrNull('2025-12-30')─┬─toDateOrNull('invalid')─┐
│ 2025-12-30 │ ᴺᵁᴸᴸ │
└────────────────────────────┴────────────────────────┘
```
## toDateOrZero
Introduit dans : v1.1.0
Convertit une valeur d'entrée en une valeur de type [`Date`](/fr/reference/data-types/date), mais renvoie la borne inférieure de [`Date`](/fr/reference/data-types/date) en cas d'argument invalide.
Identique à [toDate](#toDate), mais renvoie la borne inférieure de [`Date`](/fr/reference/data-types/date) en cas d'argument invalide.
Voir aussi :
* [`toDate`](#toDate)
* [`toDateOrNull`](#toDateOrNull)
* [`toDateOrDefault`](#toDateOrDefault)
**Syntaxe**
```sql theme={null}
toDateOrZero(x)
```
**Arguments**
* `x` — Une représentation sous forme de chaîne de caractères d’une date. [`String`](/fr/reference/data-types/string)
**Valeur renvoyée**
Renvoie une valeur Date en cas de succès, sinon la borne inférieure de Date (`1970-01-01`). [`Date`](/fr/reference/data-types/date)
**Exemples**
**Exemple d’utilisation**
```sql title=Query theme={null}
SELECT toDateOrZero('2025-12-30'), toDateOrZero('')
```
```response title=Response theme={null}
┌─toDateOrZero('2025-12-30')─┬─toDateOrZero('')─┐
│ 2025-12-30 │ 1970-01-01 │
└────────────────────────────┴──────────────────┘
```
## toDateTime
Introduit dans : v1.1.0
Convertit une valeur d'entrée en type [DateTime](/fr/reference/data-types/datetime).
Si `expr` est un nombre, il est interprété comme le nombre de secondes écoulées depuis le début de l'époque Unix (c'est-à-dire comme un timestamp Unix).
Si `expr` est une [String](/fr/reference/data-types/string), elle peut être interprétée soit comme un timestamp Unix, soit comme la représentation sous forme de chaîne d'une date / date avec heure.
Par conséquent, l'analyse des représentations sous forme de chaîne de nombres courts (jusqu'à 4 chiffres) est explicitement désactivée en raison de cette ambiguïté. Par exemple, la chaîne `'1999'` peut représenter soit une année (une représentation sous forme de chaîne incomplète de Date / DateTime), soit un timestamp Unix. Les chaînes numériques plus longues sont autorisées.
**Syntaxe**
```sql theme={null}
toDateTime(expr[, time_zone])
```
**Arguments**
* `expr` — La valeur. [`String`](/fr/reference/data-types/string) ou [`Int`](/fr/reference/data-types/int-uint) ou [`Date`](/fr/reference/data-types/date) ou [`DateTime`](/fr/reference/data-types/datetime)
* `time_zone` — Fuseau horaire. [`String`](/fr/reference/data-types/string)
**Valeur renvoyée**
Renvoie une date et une heure. [`DateTime`](/fr/reference/data-types/datetime)
**Exemples**
**Exemple d'utilisation**
```sql title=Query theme={null}
SELECT toDateTime('2025-01-01 00:00:00'), toDateTime(1735689600, 'UTC')
FORMAT Vertical
```
```response title=Response theme={null}
Row 1:
──────
toDateTime('2025-01-01 00:00:00'): 2025-01-01 00:00:00
toDateTime(1735689600, 'UTC'): 2025-01-01 00:00:00
```
## toDateTime32
Introduit dans : v20.9.0
Convertit une valeur d’entrée en type `DateTime`.
Prend en charge la conversion depuis `String`, `FixedString`, `Date`, `Date32`, `DateTime` ou des types numériques (`(U)Int*`, `Float*`, `Decimal`).
DateTime32 offre une plage étendue par rapport à `DateTime` et prend en charge des dates allant de `1900-01-01` à `2299-12-31`.
**Syntaxe**
```sql theme={null}
toDateTime32(x[, timezone])
```
**Arguments**
* `x` — Valeur d’entrée à convertir. [`String`](/fr/reference/data-types/string) ou [`FixedString`](/fr/reference/data-types/fixedstring) ou [`UInt*`](/fr/reference/data-types/int-uint) ou [`Float*`](/fr/reference/data-types/float) ou [`Date`](/fr/reference/data-types/date) ou [`DateTime`](/fr/reference/data-types/datetime) ou [`DateTime64`](/fr/reference/data-types/datetime64)
* `timezone` — Facultatif. Fuseau horaire de la valeur `DateTime` renvoyée. [`String`](/fr/reference/data-types/string)
**Valeur renvoyée**
Renvoie la valeur d’entrée convertie. [`DateTime`](/fr/reference/data-types/datetime)
**Exemples**
**La valeur est comprise dans la plage**
```sql title=Query theme={null}
SELECT toDateTime64('2025-01-01 00:00:00.000', 3) AS value, toTypeName(value);
```
```response title=Response theme={null}
┌───────────────────value─┬─toTypeName(toDateTime64('20255-01-01 00:00:00.000', 3))─┐
│ 2025-01-01 00:00:00.000 │ DateTime64(3) │
└─────────────────────────┴────────────────────────────────────────────────────────┘
```
**Sous forme de Decimal, avec précision**
```sql title=Query theme={null}
SELECT toDateTime64(1735689600.000, 3) AS value, toTypeName(value);
-- without the decimal point the value is still treated as Unix Timestamp in seconds
SELECT toDateTime64(1546300800000, 3) AS value, toTypeName(value);
```
```response title=Response theme={null}
┌───────────────────value─┬─toTypeName(toDateTime64(1735689600.000, 3))─┐
│ 2025-01-01 00:00:00.000 │ DateTime64(3) │
└─────────────────────────┴──────────────────────────────────────────┘
┌───────────────────value─┬─toTypeName(toDateTime64(1546300800000, 3))─┐
│ 2282-12-31 00:00:00.000 │ DateTime64(3) │
└─────────────────────────┴────────────────────────────────────────────┘
```
**Avec un fuseau horaire**
```sql title=Query theme={null}
SELECT toDateTime64('2025-01-01 00:00:00', 3, 'Asia/Istanbul') AS value, toTypeName(value);
```
```response title=Response theme={null}
┌───────────────────value─┬─toTypeName(toDateTime64('2025-01-01 00:00:00', 3, 'Asia/Istanbul'))─┐
│ 2025-01-01 00:00:00.000 │ DateTime64(3, 'Asia/Istanbul') │
└─────────────────────────┴─────────────────────────────────────────────────────────────────────┘
```
## toDateTime64
Introduit dans : v20.1.0
Convertit une valeur d’entrée en une valeur de type [`DateTime64`](/fr/reference/data-types/datetime64).
**Syntaxe**
```sql theme={null}
toDateTime64(expr, scale[, timezone])
```
**Arguments**
* `expr` — Expression renvoyant un nombre ou une représentation sous forme de chaîne d’un nombre. [`Expression`](/fr/reference/data-types/special-data-types/expression)
* `scale` — Taille du tick (précision) : 10^(-scale) secondes. [`UInt8`](/fr/reference/data-types/int-uint)
* `timezone` — Facultatif. Fuseau horaire de l’objet `DateTime64` spécifié. [`String`](/fr/reference/data-types/string)
**Valeur renvoyée**
Renvoie une date calendaire et une heure de la journée, avec une précision inférieure à la seconde. [`DateTime64`](/fr/reference/data-types/datetime64)
**Exemples**
**La valeur se situe dans la plage**
```sql title=Query theme={null}
SELECT toDateTime64('2025-01-01 00:00:00.000', 3) AS value, toTypeName(value);
```
```response title=Response theme={null}
┌───────────────────value─┬─toTypeName(toDateTime64('2025-01-01 00:00:00.000', 3))─┐
│ 2025-01-01 00:00:00.000 │ DateTime64(3) │
└─────────────────────────┴────────────────────────────────────────────────────────┘
```
**Sous forme de Decimal avec précision**
```sql title=Query theme={null}
SELECT toDateTime64(1546300800.000, 3) AS value, toTypeName(value);
-- Without the decimal point the value is still treated as Unix Timestamp in seconds
SELECT toDateTime64(1546300800000, 3) AS value, toTypeName(value);
```
```response title=Response theme={null}
┌───────────────────value─┬─toTypeName(toDateTime64(1546300800000, 3))─┐
│ 2282-12-31 00:00:00.000 │ DateTime64(3) │
└─────────────────────────┴────────────────────────────────────────────┘
```
**Avec fuseau horaire**
```sql title=Query theme={null}
SELECT toDateTime64('2025-01-01 00:00:00', 3, 'Asia/Istanbul') AS value, toTypeName(value);
```
```response title=Response theme={null}
┌───────────────────value─┬─toTypeName(toDateTime64('2025-01-01 00:00:00', 3, 'Asia/Istanbul'))─┐
│ 2025-01-01 00:00:00.000 │ DateTime64(3, 'Asia/Istanbul') │
└─────────────────────────┴─────────────────────────────────────────────────────────────────────┘
```
## toDateTime64OrDefault
Introduit dans : v21.11.0
Comme [toDateTime64](#toDateTime64), cette fonction convertit une valeur d'entrée en une valeur de type [DateTime64](/fr/reference/data-types/datetime64),
mais renvoie soit la valeur par défaut de [DateTime64](/fr/reference/data-types/datetime64),
soit la valeur par défaut fournie si un argument invalide est reçu.
**Syntaxe**
```sql theme={null}
toDateTime64OrDefault(expr, scale[, timezone, default])
```
**Arguments**
* `expr` — Expression renvoyant un nombre ou la représentation sous forme de chaîne d'un nombre. [`String`](/fr/reference/data-types/string) ou [`(U)Int*`](/fr/reference/data-types/int-uint) ou [`Float*`](/fr/reference/data-types/float)
* `scale` — Taille du tick (précision) : 10^-precision secondes. [`UInt8`](/fr/reference/data-types/int-uint)
* `timezone` — Facultatif. Fuseau horaire. [`String`](/fr/reference/data-types/string)
* `default` — Facultatif. La valeur par défaut à renvoyer si l'analyse échoue. [`DateTime64`](/fr/reference/data-types/datetime64)
**Valeur renvoyée**
Valeur de type DateTime64 en cas de succès, sinon renvoie la valeur par défaut si elle est fournie, ou 1970-01-01 00:00:00.000 dans le cas contraire. [`DateTime64`](/fr/reference/data-types/datetime64)
**Exemples**
**Conversion réussie**
```sql title=Query theme={null}
SELECT toDateTime64OrDefault('1976-10-18 00:00:00.30', 3)
```
```response title=Response theme={null}
1976-10-18 00:00:00.300
```
**Échec de la conversion**
```sql title=Query theme={null}
SELECT toDateTime64OrDefault('1976-10-18 00:00:00 30', 3, 'UTC', toDateTime64('2001-01-01 00:00:00.00',3))
```
```response title=Response theme={null}
2000-12-31 23:00:00.000
```
## toDateTime64OrNull
Introduit dans : v20.1.0
Convertit une valeur d'entrée en une valeur de type `DateTime64`, mais renvoie `NULL` si l'argument reçu n'est pas valide.
Identique à `toDateTime64`, mais renvoie `NULL` si l'argument reçu n'est pas valide.
**Syntaxe**
```sql theme={null}
toDateTime64OrNull(x)
```
**Arguments**
* `x` — Une représentation sous forme de chaîne d’une date et heure avec une précision sous-seconde. [`String`](/fr/reference/data-types/string)
**Valeur renvoyée**
Renvoie une valeur `DateTime64` en cas de succès, sinon `NULL`. [`DateTime64`](/fr/reference/data-types/datetime64) ou [`NULL`](/fr/reference/syntax#null)
**Exemples**
**Exemple d’utilisation**
```sql title=Query theme={null}
SELECT toDateTime64OrNull('2025-12-30 13:44:17.123'), toDateTime64OrNull('invalid')
```
```response title=Response theme={null}
┌─toDateTime64OrNull('2025-12-30 13:44:17.123')─┬─toDateTime64OrNull('invalid')─┐
│ 2025-12-30 13:44:17.123 │ ᴺᵁᴸᴸ │
└─────────────────────────────────────────────────┴───────────────────────────────┘
```
## toDateTime64OrZero
Introduit dans : v20.1.0
Convertit une valeur d’entrée en une valeur de type [DateTime64](/fr/reference/data-types/datetime64), mais renvoie la borne inférieure de [DateTime64](/fr/reference/data-types/datetime64) si l’argument est invalide.
Identique à [toDateTime64](#toDateTime64), mais renvoie la borne inférieure de [DateTime64](/fr/reference/data-types/datetime64) si l’argument est invalide.
Voir aussi :
* [toDateTime64](#toDateTime64).
* [toDateTime64OrNull](#toDateTime64OrNull).
* [toDateTime64OrDefault](#toDateTime64OrDefault).
**Syntaxe**
```sql theme={null}
toDateTime64OrZero(x)
```
**Arguments**
* `x` — Une représentation sous forme de chaîne d’une date et heure avec une précision sous-seconde. [`String`](/fr/reference/data-types/string)
**Valeur renvoyée**
Renvoie une valeur de type DateTime64 en cas de succès, sinon la borne inférieure de DateTime64 (`1970-01-01 00:00:00.000`). [`DateTime64`](/fr/reference/data-types/datetime64)
**Exemples**
**Exemple d’utilisation**
```sql title=Query theme={null}
SELECT toDateTime64OrZero('2025-12-30 13:44:17.123'), toDateTime64OrZero('invalid')
```
```response title=Response theme={null}
┌─toDateTime64OrZero('2025-12-30 13:44:17.123')─┬─toDateTime64OrZero('invalid')─┐
│ 2025-12-30 13:44:17.123 │ 1970-01-01 00:00:00.000 │
└─────────────────────────────────────────────────┴─────────────────────────────────────┘
```
## toDateTimeOrDefault
Introduit dans : v21.11.0
Comme [toDateTime](#toDateTime), mais en cas d'échec, renvoie une valeur par défaut : soit le troisième argument (s'il est spécifié), soit, à défaut, la borne inférieure de [DateTime](/fr/reference/data-types/datetime).
**Syntaxe**
```sql theme={null}
toDateTimeOrDefault(expr[, timezone, default])
```
**Arguments**
* `expr` — Expression renvoyant un nombre ou la représentation sous forme de chaîne d’un nombre. [`String`](/fr/reference/data-types/string) ou [`(U)Int*`](/fr/reference/data-types/int-uint) ou [`Float*`](/fr/reference/data-types/float)
* `timezone` — Facultatif. Fuseau horaire. [`String`](/fr/reference/data-types/string)
* `default` — Facultatif. La valeur par défaut à renvoyer si l’analyse échoue. [`DateTime`](/fr/reference/data-types/datetime)
**Valeur renvoyée**
Une valeur de type DateTime en cas de succès ; sinon, la valeur par défaut si elle est fournie, ou 1970-01-01 00:00:00 dans le cas contraire. [`DateTime`](/fr/reference/data-types/datetime)
**Exemples**
**Conversion réussie**
```sql title=Query theme={null}
SELECT toDateTimeOrDefault('2022-12-30 13:44:17')
```
```response title=Response theme={null}
2022-12-30 13:44:17
```
**Conversion échouée**
```sql title=Query theme={null}
SELECT toDateTimeOrDefault('', 'UTC', CAST('2023-01-01', 'DateTime(\'UTC\')'))
```
```response title=Response theme={null}
2023-01-01 00:00:00
```
## toDateTimeOrNull
Introduit dans : v1.1.0
Convertit une valeur d'entrée en valeur de type `DateTime`, mais renvoie `NULL` si l'argument n'est pas valide.
Identique à [`toDateTime`](#toDateTime), mais renvoie `NULL` si l'argument n'est pas valide.
**Syntaxe**
```sql theme={null}
toDateTimeOrNull(x)
```
**Arguments**
* `x` — Une représentation sous forme de chaîne d'une date et d'une heure. [`String`](/fr/reference/data-types/string)
**Valeur renvoyée**
Renvoie une valeur `DateTime` en cas de réussite, sinon `NULL`. [`DateTime`](/fr/reference/data-types/datetime) ou [`NULL`](/fr/reference/syntax#null)
**Exemples**
**Exemple d'utilisation**
```sql title=Query theme={null}
SELECT toDateTimeOrNull('2025-12-30 13:44:17'), toDateTimeOrNull('invalid')
```
```response title=Response theme={null}
┌─toDateTimeOrNull('2025-12-30 13:44:17')─┬─toDateTimeOrNull('invalid')─┐
│ 2025-12-30 13:44:17 │ ᴺᵁᴸᴸ │
└─────────────────────────────────────────┴─────────────────────────────┘
```
## toDateTimeOrZero
Introduit dans : v1.1.0
Convertit une valeur d’entrée en une valeur de type [DateTime](/fr/reference/data-types/datetime), mais renvoie la borne inférieure de [DateTime](/fr/reference/data-types/datetime) si un argument invalide est fourni.
Identique à [toDateTime](#toDateTime), mais renvoie la borne inférieure de [DateTime](/fr/reference/data-types/datetime) si un argument invalide est fourni.
**Syntaxe**
```sql theme={null}
toDateTimeOrZero(x)
```
**Arguments**
* `x` — Une représentation sous forme de chaîne d’une date et heure. [`String`](/fr/reference/data-types/string)
**Valeur renvoyée**
Renvoie une valeur DateTime en cas de succès ; sinon, la borne inférieure de DateTime (`1970-01-01 00:00:00`). [`DateTime`](/fr/reference/data-types/datetime)
**Exemples**
**Exemple d’utilisation**
```sql title=Query theme={null}
SELECT toDateTimeOrZero('2025-12-30 13:44:17'), toDateTimeOrZero('invalid')
```
```response title=Response theme={null}
┌─toDateTimeOrZero('2025-12-30 13:44:17')─┬─toDateTimeOrZero('invalid')─┐
│ 2025-12-30 13:44:17 │ 1970-01-01 00:00:00 │
└─────────────────────────────────────────┴─────────────────────────────┘
```
## toDecimal128
Introduit dans : v18.12.0
Convertit une valeur d'entrée en une valeur de type [`Decimal(38, S)`](/fr/reference/data-types/decimal) avec une échelle de `S`.
Lève une exception en cas d'erreur.
Arguments pris en charge :
* Valeurs ou représentations sous forme de chaîne de type (U)Int\*.
* Valeurs ou représentations sous forme de chaîne de type Float\*.
Arguments non pris en charge :
* Valeurs Float\* `NaN` et `Inf`, ou leurs représentations sous forme de chaîne (insensible à la casse).
* Représentations sous forme de chaîne de valeurs binaires et hexadécimales, par exemple `SELECT toDecimal128('0xc0fe', 1);`.
Un dépassement de capacité peut se produire si la valeur de `expr` dépasse les bornes de `Decimal128` :`(-1*10^(38 - S), 1*10^(38 - S))`.
Les chiffres excédentaires de la partie fractionnaire sont ignorés (sans arrondi).
Les chiffres excédentaires de la partie entière entraîneront une exception.
Les conversions tronquent les chiffres supplémentaires et peuvent se comporter de manière inattendue avec des entrées Float32/Float64, car les opérations sont effectuées à l'aide d'instructions en virgule flottante.
Par exemple : `toDecimal128(1.15, 2)` est égal à `1.14` parce que 1.15 \* 100 en virgule flottante vaut 114.99.
Vous pouvez utiliser une entrée de type String afin que les opérations utilisent le type entier sous-jacent : `toDecimal128('1.15', 2) = 1.15`
**Syntaxe**
```sql theme={null}
toDecimal128(expr, S)
```
**Arguments**
* `expr` — Expression renvoyant un nombre ou sa représentation sous forme de chaîne. [`Expression`](/fr/reference/data-types/special-data-types/expression)
* `S` — Paramètre d’échelle compris entre 0 et 38, qui indique le nombre de chiffres que peut comporter la partie fractionnaire d’un nombre. [`UInt8`](/fr/reference/data-types/int-uint)
**Valeur renvoyée**
Renvoie une valeur de type `Decimal(38, S)` [`Decimal128(S)`](/fr/reference/data-types/decimal)
**Exemples**
**Exemple d’utilisation**
```sql title=Query theme={null}
SELECT
toDecimal128(99, 1) AS a, toTypeName(a) AS type_a,
toDecimal128(99.67, 2) AS b, toTypeName(b) AS type_b,
toDecimal128('99.67', 3) AS c, toTypeName(c) AS type_c
FORMAT Vertical
```
```response title=Response theme={null}
Row 1:
──────
a: 99
type_a: Decimal(38, 1)
b: 99.67
type_b: Decimal(38, 2)
c: 99.67
type_c: Decimal(38, 3)
```
## toDecimal128OrDefault
Introduit dans : v21.11.0
Comme [`toDecimal128`](#toDecimal128), cette fonction convertit une valeur d’entrée en une valeur de type [Decimal(38, S)](/fr/reference/data-types/decimal), mais renvoie une valeur par défaut en cas d’erreur.
**Syntaxe**
```sql theme={null}
toDecimal128OrDefault(expr, S[, default])
```
**Arguments**
* `expr` — Représentation sous forme de chaîne d’un nombre. [`String`](/fr/reference/data-types/string)
* `S` — Paramètre d’échelle compris entre 0 et 38, qui spécifie le nombre de chiffres que la partie fractionnaire d’un nombre peut contenir. [`UInt8`](/fr/reference/data-types/int-uint)
* `default` — Facultatif. Valeur par défaut à renvoyer si la conversion en type Decimal128(S) échoue. [`Decimal128(S)`](/fr/reference/data-types/decimal)
**Valeur renvoyée**
Valeur de type Decimal(38, S) en cas de réussite ; sinon, renvoie la valeur par défaut si elle est fournie, ou 0 dans le cas contraire. [`Decimal128(S)`](/fr/reference/data-types/decimal)
**Exemples**
**Conversion réussie**
```sql title=Query theme={null}
SELECT toDecimal128OrDefault(toString(1/42), 18)
```
```response title=Response theme={null}
0.023809523809523808
```
**Échec de la conversion**
```sql title=Query theme={null}
SELECT toDecimal128OrDefault('Inf', 0, CAST('-1', 'Decimal128(0)'))
```
```response title=Response theme={null}
-1
```
## toDecimal128OrNull
Introduit dans : v20.1.0
Convertit une valeur d’entrée en une valeur de type [`Decimal(38, S)`](/fr/reference/data-types/decimal), mais renvoie `NULL` en cas d’erreur.
Comme [`toDecimal128`](#toDecimal128), mais renvoie `NULL` au lieu de lever une exception en cas d’erreur de conversion.
Arguments pris en charge :
* Valeurs ou représentations sous forme de chaîne de type (U)Int\*.
* Valeurs ou représentations sous forme de chaîne de type Float\*.
Arguments non pris en charge (renvoient `NULL`) :
* Valeurs Float\* `NaN` et `Inf`, ou leurs représentations sous forme de chaîne (insensible à la casse).
* Représentations sous forme de chaîne de valeurs binaires et hexadécimales.
* Valeurs qui dépassent les limites de `Decimal128` : `(-1*10^(38 - S), 1*10^(38 - S))`.
Voir aussi :
* [`toDecimal128`](#toDecimal128).
* [`toDecimal128OrZero`](#toDecimal128OrZero).
* [`toDecimal128OrDefault`](#toDecimal128OrDefault).
**Syntaxe**
```sql theme={null}
toDecimal128OrNull(expr, S)
```
**Arguments**
* `expr` — Expression renvoyant un nombre ou une représentation sous forme de chaîne d'un nombre. [`Expression`](/fr/reference/data-types/special-data-types/expression)
* `S` — Paramètre d'échelle compris entre 0 et 38, indiquant le nombre de chiffres que la partie fractionnaire d'un nombre peut comporter. [`UInt8`](/fr/reference/data-types/int-uint)
**Valeur renvoyée**
Renvoie une valeur Decimal(38, S) en cas de réussite, sinon `NULL`. [`Decimal128(S)`](/fr/reference/data-types/decimal) ou [`NULL`](/fr/reference/syntax#null)
**Exemples**
**Exemple d'utilisation**
```sql title=Query theme={null}
SELECT toDecimal128OrNull('42.7', 2), toDecimal128OrNull('invalid', 2)
```
```response title=Response theme={null}
┌─toDecimal128OrNull('42.7', 2)─┬─toDecimal128OrNull('invalid', 2)─┐
│ 42.70 │ ᴺᵁᴸᴸ │
└───────────────────────────────┴──────────────────────────────────┘
```
## toDecimal128OrZero
Introduit dans : v20.1.0
Convertit une valeur d’entrée en une valeur de type [Decimal(38, S)](/fr/reference/data-types/decimal), mais renvoie `0` en cas d’erreur.
Comme [`toDecimal128`](#toDecimal128), mais renvoie `0` au lieu de lever une exception en cas d’erreur de conversion.
Arguments pris en charge :
* Valeurs ou représentations sous forme de chaîne de type (U)Int\*.
* Valeurs ou représentations sous forme de chaîne de type Float\*.
Arguments non pris en charge (renvoient `0`) :
* Valeurs ou représentations sous forme de chaîne des valeurs Float\* `NaN` et `Inf` (insensible à la casse).
* Représentations sous forme de chaîne de valeurs binaires et hexadécimales.
Si la valeur d’entrée dépasse les limites de `Decimal128` :`(-1*10^(38 - S), 1*10^(38 - S))`, la fonction renvoie `0`.
**Syntaxe**
```sql theme={null}
toDecimal128OrZero(expr, S)
```
**Arguments**
* `expr` — Expression renvoyant un nombre ou la représentation sous forme de chaîne d’un nombre. [`Expression`](/fr/reference/data-types/special-data-types/expression)
* `S` — Paramètre d’échelle compris entre 0 et 38, indiquant le nombre de chiffres que la partie fractionnaire d’un nombre peut comporter. [`UInt8`](/fr/reference/data-types/int-uint)
**Valeur renvoyée**
Renvoie une valeur Decimal(38, S) en cas de succès, sinon `0`. [`Decimal128(S)`](/fr/reference/data-types/decimal)
**Exemples**
**Utilisation de base**
```sql title=Query theme={null}
SELECT toDecimal128OrZero('42.7', 2), toDecimal128OrZero('invalid', 2)
```
```response title=Response theme={null}
┌─toDecimal128OrZero('42.7', 2)─┬─toDecimal128OrZero('invalid', 2)─┐
│ 42.70 │ 0.00 │
└───────────────────────────────┴──────────────────────────────────┘
```
## toDecimal256
Introduit dans : v20.8.0
Convertit une valeur d’entrée en une valeur de type [`Decimal(76, S)`](/fr/reference/data-types/decimal) avec une échelle de `S`. Lève une exception en cas d’erreur.
Arguments pris en charge :
* Valeurs ou représentations sous forme de chaîne de type (U)Int\*.
* Valeurs ou représentations sous forme de chaîne de type Float\*.
Arguments non pris en charge :
* Valeurs ou représentations sous forme de chaîne de valeurs Float\* `NaN` et `Inf` (insensible à la casse).
* Représentations sous forme de chaîne de valeurs en binaire et en hexadécimal, par exemple `SELECT toDecimal256('0xc0fe', 1);`.
Un dépassement de capacité peut se produire si la valeur de `expr` dépasse les bornes de `Decimal256` : `(-1*10^(76 - S), 1*10^(76 - S))`.
Les chiffres en trop dans la partie fractionnaire sont ignorés (sans arrondi).
Les chiffres en trop dans la partie entière entraîneront une exception.
Les conversions tronquent les chiffres supplémentaires et peuvent se comporter de manière inattendue avec des entrées Float32/Float64, car les opérations sont effectuées à l’aide d’instructions en virgule flottante.
Par exemple : `toDecimal256(1.15, 2)` est égal à `1.14`, car 1.15 \* 100 en virgule flottante donne 114.99.
Vous pouvez utiliser une entrée de type String afin que les opérations utilisent le type entier sous-jacent : `toDecimal256('1.15', 2) = 1.15`
**Syntaxe**
```sql theme={null}
toDecimal256(expr, S)
```
**Arguments**
* `expr` — Expression renvoyant un nombre ou la représentation sous forme de chaîne d’un nombre. [`Expression`](/fr/reference/data-types/special-data-types/expression)
* `S` — Paramètre d’échelle compris entre 0 et 76, indiquant le nombre de chiffres que la partie fractionnaire d’un nombre peut comporter. [`UInt8`](/fr/reference/data-types/int-uint)
**Valeur renvoyée**
Renvoie une valeur de type `Decimal(76, S)`. [`Decimal256(S)`](/fr/reference/data-types/decimal)
**Exemples**
**Exemple d’utilisation**
```sql title=Query theme={null}
SELECT
toDecimal256(99, 1) AS a, toTypeName(a) AS type_a,
toDecimal256(99.67, 2) AS b, toTypeName(b) AS type_b,
toDecimal256('99.67', 3) AS c, toTypeName(c) AS type_c
FORMAT Vertical
```
```response title=Response theme={null}
Row 1:
──────
a: 99
type_a: Decimal(76, 1)
b: 99.67
type_b: Decimal(76, 2)
c: 99.67
type_c: Decimal(76, 3)
```
## toDecimal256OrDefault
Introduit dans : v21.11.0
Comme [`toDecimal256`](#toDecimal256), cette fonction convertit une valeur d’entrée en valeur de type [Decimal(76, S)](/fr/reference/data-types/decimal), mais renvoie la valeur par défaut en cas d’erreur.
**Syntaxe**
```sql theme={null}
toDecimal256OrDefault(expr, S[, default])
```
**Arguments**
* `expr` — Une représentation sous forme de chaîne d’un nombre. [`String`](/fr/reference/data-types/string)
* `S` — Paramètre d’échelle compris entre 0 et 76, qui indique le nombre de chiffres que la partie fractionnaire d’un nombre peut contenir. [`UInt8`](/fr/reference/data-types/int-uint)
* `default` — Facultatif. Valeur par défaut à renvoyer si la conversion vers le type Decimal256(S) échoue. [`Decimal256(S)`](/fr/reference/data-types/decimal)
**Valeur renvoyée**
Une valeur de type Decimal(76, S) en cas de réussite ; sinon, la valeur par défaut si elle est fournie, ou 0 dans le cas contraire. [`Decimal256(S)`](/fr/reference/data-types/decimal)
**Exemples**
**Conversion réussie**
```sql title=Query theme={null}
SELECT toDecimal256OrDefault(toString(1/42), 76)
```
```response title=Response theme={null}
0.023809523809523808
```
**Échec de conversion**
```sql title=Query theme={null}
SELECT toDecimal256OrDefault('Inf', 0, CAST('-1', 'Decimal256(0)'))
```
```response title=Response theme={null}
-1
```
## toDecimal256OrNull
Introduit dans : v20.8.0
Convertit une valeur d'entrée en une valeur de type [`Decimal(76, S)`](/fr/reference/data-types/decimal), mais renvoie `NULL` en cas d'erreur.
Comme [`toDecimal256`](#toDecimal256), mais renvoie `NULL` au lieu de lever une exception en cas d'erreur de conversion.
Arguments pris en charge :
* Valeurs ou représentations sous forme de chaîne de type (U)Int\*.
* Valeurs ou représentations sous forme de chaîne de type Float\*.
Arguments non pris en charge (renvoient `NULL`) :
* Valeurs ou représentations sous forme de chaîne des valeurs Float\* `NaN` et `Inf` (insensible à la casse).
* Représentations sous forme de chaîne de valeurs en binaire et en hexadécimal.
* Valeurs qui dépassent les limites de `Decimal256` : `(-1 * 10^(76 - S), 1 * 10^(76 - S))`.
Voir aussi :
* [`toDecimal256`](#toDecimal256).
* [`toDecimal256OrZero`](#toDecimal256OrZero).
* [`toDecimal256OrDefault`](#toDecimal256OrDefault).
**Syntaxe**
```sql theme={null}
toDecimal256OrNull(expr, S)
```
**Arguments**
* `expr` — Expression renvoyant un nombre ou sa représentation sous forme de chaîne. [`Expression`](/fr/reference/data-types/special-data-types/expression)
* `S` — Paramètre d’échelle compris entre 0 et 76, indiquant le nombre de chiffres que peut contenir la partie fractionnaire d’un nombre. [`UInt8`](/fr/reference/data-types/int-uint)
**Valeur renvoyée**
Renvoie une valeur Decimal(76, S) en cas de succès, sinon `NULL`. [`Decimal256(S)`](/fr/reference/data-types/decimal) ou [`NULL`](/fr/reference/syntax#null)
**Exemples**
**Exemple d’utilisation**
```sql title=Query theme={null}
SELECT toDecimal256OrNull('42.7', 2), toDecimal256OrNull('invalid', 2)
```
```response title=Response theme={null}
┌─toDecimal256OrNull('42.7', 2)─┬─toDecimal256OrNull('invalid', 2)─┐
│ 42.70 │ ᴺᵁᴸᴸ │
└───────────────────────────────┴──────────────────────────────────┘
```
## toDecimal256OrZero
Introduit dans : v20.8.0
Convertit une valeur d’entrée en valeur de type [Decimal(76, S)](/fr/reference/data-types/decimal), mais renvoie `0` en cas d’erreur.
Comme [`toDecimal256`](#toDecimal256), mais renvoie `0` au lieu de lever une exception en cas d’erreur de conversion.
Arguments pris en charge :
* Valeurs ou représentations sous forme de chaîne de type (U)Int\*.
* Valeurs ou représentations sous forme de chaîne de type Float\*.
Arguments non pris en charge (renvoient `0`) :
* Valeurs ou représentations sous forme de chaîne de caractères de valeurs Float\* `NaN` et `Inf` (insensible à la casse).
* Représentations sous forme de chaîne de valeurs binaires et hexadécimales.
Si la valeur d’entrée dépasse les limites de `Decimal256` : `(-1*10^(76 - S), 1*10^(76 - S))`, la fonction renvoie `0`.
Voir aussi :
* [`toDecimal256`](#toDecimal256).
* [`toDecimal256OrNull`](#toDecimal256OrNull).
* [`toDecimal256OrDefault`](#toDecimal256OrDefault).
**Syntaxe**
```sql theme={null}
toDecimal256OrZero(expr, S)
```
**Arguments**
* `expr` — Expression renvoyant un nombre ou la représentation sous forme de chaîne d’un nombre. [`Expression`](/fr/reference/data-types/special-data-types/expression)
* `S` — Paramètre d’échelle compris entre 0 et 76, indiquant combien de chiffres peut comporter la partie fractionnaire d’un nombre. [`UInt8`](/fr/reference/data-types/int-uint)
**Valeur renvoyée**
Renvoie une valeur Decimal(76, S) en cas de succès, sinon `0`. [`Decimal256(S)`](/fr/reference/data-types/decimal)
**Exemples**
**Exemple d’utilisation**
```sql title=Query theme={null}
SELECT toDecimal256OrZero('42.7', 2), toDecimal256OrZero('invalid', 2)
```
```response title=Response theme={null}
┌─toDecimal256OrZero('42.7', 2)─┬─toDecimal256OrZero('invalid', 2)─┐
│ 42.70 │ 0.00 │
└───────────────────────────────┴──────────────────────────────────┘
```
## toDecimal32
Introduit dans : v18.12.0
Convertit une valeur d’entrée en une valeur de type [`Decimal(9, S)`](/fr/reference/data-types/decimal) avec une échelle de `S`. Lève une exception en cas d’erreur.
Arguments pris en charge :
* Valeurs ou représentations sous forme de chaîne de type (U)Int\*.
* Valeurs ou représentations sous forme de chaîne de type Float\*.
Arguments non pris en charge :
* Valeurs ou représentations sous forme de chaîne des valeurs Float\* `NaN` et `Inf` (insensible à la casse).
* Représentations sous forme de chaîne de valeurs binaires et hexadécimales, par ex. `SELECT toDecimal32('0xc0fe', 1);`.
Un dépassement de capacité peut se produire si la valeur de `expr` dépasse les limites de `Decimal32` :`(-1*10^(9 - S), 1*10^(9 - S))`.
Les chiffres en trop dans la partie fractionnaire sont supprimés (sans arrondi).
Les chiffres en trop dans la partie entière entraînent une exception.
Les conversions suppriment les chiffres en trop et peuvent produire un résultat inattendu avec des entrées Float32/Float64, car les opérations sont effectuées à l’aide d’instructions en virgule flottante.
Par exemple : `toDecimal32(1.15, 2)` est égal à `1.14` parce que 1.15 \* 100 en virgule flottante vaut 114.99.
Vous pouvez utiliser une entrée String afin que les opérations utilisent le type entier sous-jacent : `toDecimal32('1.15', 2) = 1.15`
**Syntaxe**
```sql theme={null}
toDecimal32(expr, S)
```
**Arguments**
* `expr` — Expression renvoyant un nombre ou une représentation d’un nombre sous forme de chaîne. [`Expression`](/fr/reference/data-types/special-data-types/expression)
* `S` — Paramètre d’échelle compris entre 0 et 9, indiquant le nombre de chiffres que peut comporter la partie fractionnaire d’un nombre. [`UInt8`](/fr/reference/data-types/int-uint)
**Valeur renvoyée**
Renvoie une valeur de type `Decimal(9, S)` [`Decimal32(S)`](/fr/reference/data-types/decimal)
**Exemples**
**Exemple d’utilisation**
```sql title=Query theme={null}
SELECT
toDecimal32(2, 1) AS a, toTypeName(a) AS type_a,
toDecimal32(4.2, 2) AS b, toTypeName(b) AS type_b,
toDecimal32('4.2', 3) AS c, toTypeName(c) AS type_c
FORMAT Vertical
```
```response title=Response theme={null}
Row 1:
──────
a: 2
type_a: Decimal(9, 1)
b: 4.2
type_b: Decimal(9, 2)
c: 4.2
type_c: Decimal(9, 3)
```
## toDecimal32OrDefault
Introduit dans : v21.11.0
À l’instar de [`toDecimal32`](#toDecimal32), cette fonction convertit une valeur d’entrée en une valeur de type [Decimal(9, S)](/fr/reference/data-types/decimal), mais renvoie la valeur par défaut en cas d’erreur.
**Syntaxe**
```sql theme={null}
toDecimal32OrDefault(expr, S[, default])
```
**Arguments**
* `expr` — Une représentation sous forme de chaîne d’un nombre. [`String`](/fr/reference/data-types/string)
* `S` — Paramètre d’échelle compris entre 0 et 9, qui spécifie le nombre de chiffres que la partie fractionnaire d’un nombre peut contenir. [`UInt8`](/fr/reference/data-types/int-uint)
* `default` — Facultatif. La valeur par défaut à renvoyer si la conversion en type Decimal32(S) échoue. [`Decimal32(S)`](/fr/reference/data-types/decimal)
**Valeur renvoyée**
Une valeur de type Decimal(9, S) en cas de réussite ; sinon, la valeur par défaut si elle est fournie, ou 0 dans le cas contraire. [`Decimal32(S)`](/fr/reference/data-types/decimal)
**Exemples**
**Conversion réussie**
```sql title=Query theme={null}
SELECT toDecimal32OrDefault(toString(0.0001), 5)
```
```response title=Response theme={null}
0.0001
```
**Échec de conversion**
```sql title=Query theme={null}
SELECT toDecimal32OrDefault('Inf', 0, CAST('-1', 'Decimal32(0)'))
```
```response title=Response theme={null}
-1
```
## toDecimal32OrNull
Introduit dans : v20.1.0
Convertit une valeur d’entrée en une valeur de type [`Decimal(9, S)`](/fr/reference/data-types/decimal), mais renvoie `NULL` en cas d’erreur.
Comme [`toDecimal32`](#toDecimal32), mais renvoie `NULL` au lieu de lever une exception en cas d’erreur de conversion.
Arguments pris en charge :
* Valeurs ou représentations sous forme de chaîne de type (U)Int\*.
* Valeurs ou représentations sous forme de chaîne de type Float\*.
Arguments non pris en charge (renvoient `NULL`) :
* Valeurs ou représentations sous forme de chaîne des valeurs Float\* `NaN` et `Inf` (insensible à la casse).
* Représentations sous forme de chaîne de valeurs binaires et hexadécimales.
* Valeurs qui dépassent les limites de `Decimal32` :`(-1*10^(9 - S), 1*10^(9 - S))`.
Voir aussi :
* [`toDecimal32`](#toDecimal32).
* [`toDecimal32OrZero`](#toDecimal32OrZero).
* [`toDecimal32OrDefault`](#toDecimal32OrDefault).
**Syntaxe**
```sql theme={null}
toDecimal32OrNull(expr, S)
```
**Arguments**
* `expr` — Expression renvoyant un nombre ou une représentation sous forme de chaîne d’un nombre. [`Expression`](/fr/reference/data-types/special-data-types/expression)
* `S` — Paramètre d’échelle compris entre 0 et 9, indiquant le nombre de chiffres que peut comporter la partie fractionnaire d’un nombre. [`UInt8`](/fr/reference/data-types/int-uint)
**Valeur renvoyée**
Renvoie une valeur Decimal(9, S) en cas de succès, sinon `NULL`. [`Decimal32(S)`](/fr/reference/data-types/decimal) ou [`NULL`](/fr/reference/syntax#null)
**Exemples**
**Exemple d’utilisation**
```sql title=Query theme={null}
SELECT toDecimal32OrNull('42.7', 2), toDecimal32OrNull('invalid', 2)
```
```response title=Response theme={null}
┌─toDecimal32OrNull('42.7', 2)─┬─toDecimal32OrNull('invalid', 2)─┐
│ 42.70 │ ᴺᵁᴸᴸ │
└──────────────────────────────┴─────────────────────────────────┘
```
## toDecimal32OrZero
Introduit dans : v20.1.0
Convertit une valeur d'entrée en une valeur de type [Decimal(9, S)](/fr/reference/data-types/decimal), mais renvoie `0` en cas d'erreur.
Comme [`toDecimal32`](#toDecimal32), mais renvoie `0` au lieu de lever une exception en cas d'erreur de conversion.
Arguments pris en charge :
* Valeurs ou représentations sous forme de chaîne du type (U)Int\*.
* Valeurs ou représentations sous forme de chaîne du type Float\*.
Arguments non pris en charge (renvoient `0`) :
* Valeurs Float\* `NaN` et `Inf`, ou leurs représentations sous forme de chaîne (insensible à la casse).
* Représentations sous forme de chaîne de valeurs binaires et hexadécimales.
Si la valeur d'entrée dépasse les limites de `Decimal32` :`(-1*10^(9 - S), 1*10^(9 - S))`, la fonction renvoie `0`.
**Syntaxe**
```sql theme={null}
toDecimal32OrZero(expr, S)
```
**Arguments**
* `expr` — Expression renvoyant un nombre ou sa représentation sous forme de chaîne. [`Expression`](/fr/reference/data-types/special-data-types/expression)
* `S` — Paramètre d’échelle compris entre 0 et 9, indiquant le nombre de chiffres que peut comporter la partie fractionnaire d’un nombre. [`UInt8`](/fr/reference/data-types/int-uint)
**Valeur renvoyée**
Renvoie une valeur Decimal(9, S) en cas de réussite, sinon `0`. [`Decimal32(S)`](/fr/reference/data-types/decimal)
**Exemples**
**Exemple d’utilisation**
```sql title=Query theme={null}
SELECT toDecimal32OrZero('42.7', 2), toDecimal32OrZero('invalid', 2)
```
```response title=Response theme={null}
┌─toDecimal32OrZero('42.7', 2)─┬─toDecimal32OrZero('invalid', 2)─┐
│ 42.70 │ 0.00 │
└──────────────────────────────┴─────────────────────────────────┘
```
## toDecimal64
Introduit dans : v18.12.0
Convertit une valeur d’entrée en une valeur de type [`Decimal(18, S)`](/fr/reference/data-types/decimal) avec une échelle de `S`.
Lève une exception en cas d’erreur.
Arguments pris en charge :
* Valeurs ou représentations sous forme de chaîne de type (U)Int\*.
* Valeurs ou représentations sous forme de chaîne de type Float\*.
Arguments non pris en charge :
* Valeurs ou représentations sous forme de chaîne des valeurs Float\* `NaN` et `Inf` (insensible à la casse).
* Représentations sous forme de chaîne de valeurs binaires ou hexadécimales, par ex. `SELECT toDecimal64('0xc0fe', 1);`.
Un dépassement peut se produire si la valeur de `expr` dépasse les limites de `Decimal64` :`(-1*10^(18 - S), 1*10^(18 - S))`.
Les chiffres en trop dans la partie fractionnaire sont ignorés (sans arrondi).
Les chiffres en trop dans la partie entière entraînent une exception.
Les conversions suppriment les chiffres en trop et peuvent produire des résultats inattendus avec des entrées Float32/Float64, car les opérations sont effectuées à l’aide d’instructions en virgule flottante.
Par exemple : `toDecimal64(1.15, 2)` est égal à `1.14` parce que 1.15 \* 100 en virgule flottante vaut 114.99.
Vous pouvez utiliser une entrée String pour que les opérations utilisent le type entier sous-jacent : `toDecimal64('1.15', 2) = 1.15`
**Syntaxe**
```sql theme={null}
toDecimal64(expr, S)
```
**Arguments**
* `expr` — Expression renvoyant un nombre ou la représentation sous forme de chaîne d’un nombre. [`Expression`](/fr/reference/data-types/special-data-types/expression)
* `S` — Paramètre d’échelle compris entre 0 et 18, indiquant le nombre de chiffres que peut comporter la partie fractionnaire d’un nombre. [`UInt8`](/fr/reference/data-types/int-uint)
**Valeur renvoyée**
Renvoie une valeur de type décimal. [`Decimal(18, S)`](/fr/reference/data-types/decimal)
**Exemples**
**Exemple d’utilisation**
```sql title=Query theme={null}
SELECT
toDecimal64(2, 1) AS a, toTypeName(a) AS type_a,
toDecimal64(4.2, 2) AS b, toTypeName(b) AS type_b,
toDecimal64('4.2', 3) AS c, toTypeName(c) AS type_c
FORMAT Vertical
```
```response title=Response theme={null}
Row 1:
──────
a: 2.0
type_a: Decimal(18, 1)
b: 4.20
type_b: Decimal(18, 2)
c: 4.200
type_c: Decimal(18, 3)
```
## toDecimal64OrDefault
Introduit dans : v21.11.0
Comme [`toDecimal64`](#toDecimal64), cette fonction convertit une valeur d’entrée en une valeur de type [Decimal(18, S)](/fr/reference/data-types/decimal), mais renvoie la valeur par défaut en cas d’erreur.
**Syntaxe**
```sql theme={null}
toDecimal64OrDefault(expr, S[, default])
```
**Arguments**
* `expr` — Une représentation d’un nombre sous forme de chaîne. [`String`](/fr/reference/data-types/string)
* `S` — Paramètre d’échelle compris entre 0 et 18, indiquant le nombre de chiffres que peut contenir la partie fractionnaire d’un nombre. [`UInt8`](/fr/reference/data-types/int-uint)
* `default` — Facultatif. Valeur par défaut à renvoyer si la conversion vers le type Decimal64(S) échoue. [`Decimal64(S)`](/fr/reference/data-types/decimal)
**Valeur renvoyée**
Une valeur de type Decimal(18, S) en cas de réussite ; sinon, la valeur par défaut si elle est fournie, ou 0 dans le cas contraire. [`Decimal64(S)`](/fr/reference/data-types/decimal)
**Exemples**
**Conversion réussie**
```sql title=Query theme={null}
SELECT toDecimal64OrDefault(toString(0.0001), 18)
```
```response title=Response theme={null}
0.0001
```
**Échec de la conversion**
```sql title=Query theme={null}
SELECT toDecimal64OrDefault('Inf', 0, CAST('-1', 'Decimal64(0)'))
```
```response title=Response theme={null}
-1
```
## toDecimal64OrNull
Introduit dans : v20.1.0
Convertit une valeur d’entrée en une valeur de type [Decimal(18, S)](/fr/reference/data-types/decimal), mais renvoie `NULL` en cas d’erreur.
Comme [`toDecimal64`](#toDecimal64), mais renvoie `NULL` au lieu de lever une exception en cas d’erreur de conversion.
Arguments pris en charge :
* Valeurs ou représentations sous forme de chaîne de type (U)Int\*.
* Valeurs ou représentations sous forme de chaîne de type Float\*.
Arguments non pris en charge (renvoient `NULL`) :
* Valeurs ou représentations sous forme de chaîne des valeurs Float\* `NaN` et `Inf` (insensible à la casse).
* Représentations sous forme de chaîne de valeurs binaires et hexadécimales.
* Valeurs qui dépassent les limites de `Decimal64` : `(-1*10^(18 - S), 1*10^(18 - S))`.
Voir aussi :
* [`toDecimal64`](#toDecimal64).
* [`toDecimal64OrZero`](#toDecimal64OrZero).
* [`toDecimal64OrDefault`](#toDecimal64OrDefault).
**Syntaxe**
```sql theme={null}
toDecimal64OrNull(expr, S)
```
**Arguments**
* `expr` — Expression renvoyant un nombre ou une représentation sous forme de chaîne d'un nombre. [`Expression`](/fr/reference/data-types/special-data-types/expression)
* `S` — Paramètre d'échelle compris entre 0 et 18, indiquant le nombre de chiffres que peut comporter la partie fractionnaire d'un nombre. [`UInt8`](/fr/reference/data-types/int-uint)
**Valeur renvoyée**
Renvoie une valeur Decimal(18, S) en cas de réussite, sinon `NULL`. [`Decimal64(S)`](/fr/reference/data-types/decimal) ou [`NULL`](/fr/reference/syntax#null)
**Exemples**
**Exemple d'utilisation**
```sql title=Query theme={null}
SELECT toDecimal64OrNull('42.7', 2), toDecimal64OrNull('invalid', 2)
```
```response title=Response theme={null}
┌─toDecimal64OrNull('42.7', 2)─┬─toDecimal64OrNull('invalid', 2)─┐
│ 42.70 │ ᴺᵁᴸᴸ │
└──────────────────────────────┴─────────────────────────────────┘
```
## toDecimal64OrZero
Introduit dans : v20.1.0
Convertit une valeur d'entrée en une valeur de type [Decimal(18, S)](/fr/reference/data-types/decimal), mais renvoie `0` en cas d'erreur.
Comme [`toDecimal64`](#toDecimal64), mais renvoie `0` au lieu de générer une exception en cas d'erreur de conversion.
Arguments pris en charge :
* Valeurs ou représentations sous forme de chaîne de type (U)Int\*.
* Valeurs ou représentations sous forme de chaîne de type Float\*.
Arguments non pris en charge (renvoient `0`) :
* Valeurs ou représentations sous forme de chaîne des valeurs Float\* `NaN` et `Inf` (insensible à la casse).
* Représentations sous forme de chaîne de valeurs binaires et hexadécimales.
Si la valeur d'entrée dépasse les limites de `Decimal64` : `(-1*10^(18 - S), 1*10^(18 - S))`, la fonction renvoie `0`.
Voir aussi :
* [`toDecimal64`](#toDecimal64).
* [`toDecimal64OrNull`](#toDecimal64OrNull).
* [`toDecimal64OrDefault`](#toDecimal64OrDefault).
**Syntaxe**
```sql theme={null}
toDecimal64OrZero(expr, S)
```
**Arguments**
* `expr` — Expression renvoyant un nombre ou la représentation sous forme de chaîne d’un nombre. [`Expression`](/fr/reference/data-types/special-data-types/expression)
* `S` — Paramètre d’échelle compris entre 0 et 18, indiquant le nombre de chiffres que peut contenir la partie fractionnaire d’un nombre. [`UInt8`](/fr/reference/data-types/int-uint)
**Valeur renvoyée**
Renvoie une valeur Decimal(18, S) en cas de réussite, sinon `0`. [`Decimal64(S)`](/fr/reference/data-types/decimal)
**Exemples**
**Exemple d’utilisation**
```sql title=Query theme={null}
SELECT toDecimal64OrZero('42.7', 2), toDecimal64OrZero('invalid', 2)
```
```response title=Response theme={null}
┌─toDecimal64OrZero('42.7', 2)─┬─toDecimal64OrZero('invalid', 2)─┐
│ 42.70 │ 0.00 │
└──────────────────────────────┴─────────────────────────────────┘
```
## toDecimalString
Introduit dans : v23.3.0
Convertit une valeur numérique en String avec le nombre spécifié de chiffres fractionnaires.
La fonction arrondit la valeur d'entrée au nombre spécifié de décimales. Si la valeur d'entrée comporte moins de chiffres fractionnaires
que demandé, le résultat est complété par des zéros afin d'obtenir exactement le nombre de chiffres fractionnaires spécifié.
**Syntaxe**
```sql theme={null}
toDecimalString(number, scale)
```
**Arguments**
* `number` — Valeur numérique à convertir en chaîne. Peut être de n’importe quel type numérique (Int, UInt, Float, Decimal). [`Int8`](/fr/reference/data-types/int-uint) ou [`Int16`](/fr/reference/data-types/int-uint) ou [`Int32`](/fr/reference/data-types/int-uint) ou [`Int64`](/fr/reference/data-types/int-uint) ou [`UInt8`](/fr/reference/data-types/int-uint) ou [`UInt16`](/fr/reference/data-types/int-uint) ou [`UInt32`](/fr/reference/data-types/int-uint) ou [`UInt64`](/fr/reference/data-types/int-uint) ou [`Float32`](/fr/reference/data-types/float) ou [`Float64`](/fr/reference/data-types/float) ou [`Decimal`](/fr/reference/data-types/decimal)
* `scale` — Le nombre de chiffres à afficher après la virgule. Le résultat sera arrondi si nécessaire. [`UInt8`](/fr/reference/data-types/int-uint)
**Valeur renvoyée**
Renvoie une représentation String du nombre avec exactement le nombre spécifié de chiffres après la virgule. [`String`](/fr/reference/data-types/string)
**Exemples**
**Arrondir et formater un nombre**
```sql title=Query theme={null}
SELECT toDecimalString(2.1456, 2)
```
```response title=Response theme={null}
┌─toDecimalString(2.1456, 2)─┐
│ 2.15 │
└────────────────────────────┘
```
**Remplir avec des zéros**
```sql title=Query theme={null}
SELECT toDecimalString(5, 3)
```
```response title=Response theme={null}
┌─toDecimalString(5, 3)─┐
│ 5.000 │
└───────────────────────┘
```
**Différents types numériques**
```sql title=Query theme={null}
SELECT toDecimalString(CAST(123.456 AS Decimal(10,3)), 2) AS decimal_val,
toDecimalString(CAST(42.7 AS Float32), 4) AS float_val
```
```response title=Response theme={null}
┌─decimal_val─┬─float_val─┐
│ 123.46 │ 42.7000 │
└─────────────┴───────────┘
```
## toFixedString
Introduit dans : v1.1.0
Convertit un argument [`String`](/fr/reference/data-types/string) en [`FixedString(N)`](/fr/reference/data-types/fixedstring) (une chaîne de longueur fixe N).
Si la chaîne comporte moins d’octets que N, elle est remplie à droite avec des octets nuls.
Si la chaîne comporte plus d’octets que N, une exception est levée.
**Syntaxe**
```sql theme={null}
toFixedString(s, N)
```
**Arguments**
* `s` — Chaîne à convertir. [`String`](/fr/reference/data-types/string)
* `N` — Longueur de la `FixedString` obtenue. [`const UInt*`](/fr/reference/data-types/int-uint)
**Valeur renvoyée**
Renvoie une `FixedString` de longueur N. [`FixedString(N)`](/fr/reference/data-types/fixedstring)
**Exemples**
**Exemple d'utilisation**
```sql title=Query theme={null}
SELECT toFixedString('foo', 8) AS s;
```
```response title=Response theme={null}
┌─s─────────────┐
│ foo\0\0\0\0\0 │
└───────────────┘
```
## toFloat32
Introduit dans : v1.1.0
Convertit une valeur d’entrée en valeur de type [Float32](/fr/reference/data-types/float).
Lève une exception en cas d’erreur.
Arguments pris en charge :
* Valeurs de type (U)Int\*.
* Représentations sous forme de chaîne de (U)Int8/16/32/128/256.
* Valeurs de type Float\*, y compris `NaN` et `Inf`.
* Représentations sous forme de chaîne de Float\*, y compris `NaN` et `Inf` (insensibles à la casse).
Arguments non pris en charge :
* Représentations sous forme de chaîne de valeurs binaires et hexadécimales, par exemple `SELECT toFloat32('0xc0fe');`.
Voir aussi :
* [`toFloat32OrZero`](#toFloat32OrZero).
* [`toFloat32OrNull`](#toFloat32OrNull).
* [`toFloat32OrDefault`](#toFloat32OrDefault).
**Syntaxe**
```sql theme={null}
toFloat32(expr)
```
**Arguments**
* `expr` — Expression renvoyant un nombre ou la représentation sous forme de chaîne d'un nombre. [`Expression`](/fr/reference/data-types/special-data-types/expression)
**Valeur renvoyée**
Renvoie une valeur à virgule flottante 32 bits. [`Float32`](/fr/reference/data-types/float)
**Exemples**
**Exemple d'utilisation**
```sql title=Query theme={null}
SELECT
toFloat32(42.7),
toFloat32('42.7'),
toFloat32('NaN')
FORMAT Vertical
```
```response title=Response theme={null}
Row 1:
──────
toFloat32(42.7): 42.7
toFloat32('42.7'): 42.7
toFloat32('NaN'): nan
```
## toFloat32OrDefault
Introduit dans : v21.11.0
Comme [`toFloat32`](#toFloat32), cette fonction convertit une valeur d'entrée en une valeur de type [Float32](/fr/reference/data-types/float), mais renvoie la valeur par défaut en cas d'erreur.
Si aucune valeur `default` n'est fournie, `0` est renvoyé en cas d'erreur.
**Syntaxe**
```sql theme={null}
toFloat32OrDefault(expr[, default])
```
**Arguments**
* `expr` — Expression qui renvoie un nombre ou la représentation sous forme de chaîne d’un nombre. [`String`](/fr/reference/data-types/string) ou [`(U)Int*`](/fr/reference/data-types/int-uint) ou [`Float*`](/fr/reference/data-types/float)
* `default` — Facultatif. La valeur par défaut à renvoyer si l’interprétation échoue. [`Float32`](/fr/reference/data-types/float)
**Valeur renvoyée**
Renvoie une valeur de type Float32 en cas de réussite ; sinon, renvoie la valeur par défaut si elle est fournie, ou 0 dans le cas contraire. [`Float32`](/fr/reference/data-types/float)
**Exemples**
**Conversion réussie**
```sql title=Query theme={null}
SELECT toFloat32OrDefault('8', CAST('0', 'Float32'))
```
```response title=Response theme={null}
8
```
**Échec de conversion**
```sql title=Query theme={null}
SELECT toFloat32OrDefault('abc', CAST('0', 'Float32'))
```
```response title=Response theme={null}
0
```
## toFloat32OrNull
Introduit dans : v1.1.0
Convertit une valeur d’entrée en valeur de type [Float32](/fr/reference/data-types/float), mais renvoie `NULL` en cas d’erreur.
Comme [`toFloat32`](#toFloat32), mais renvoie `NULL` au lieu de lever une exception en cas d’erreur de conversion.
Arguments pris en charge :
* Valeurs de type (U)Int\*.
* Représentations sous forme de chaîne de (U)Int8/16/32/128/256.
* Valeurs de type Float\*, y compris `NaN` et `Inf`.
* Représentations sous forme de chaîne de Float\*, y compris `NaN` et `Inf` (insensibles à la casse).
Arguments non pris en charge (renvoie `NULL`) :
* Représentations sous forme de chaîne de valeurs binaires et hexadécimales, par ex. `SELECT toFloat32OrNull('0xc0fe');`.
* Formats de chaîne non valides.
Voir aussi :
* [`toFloat32`](#toFloat32).
* [`toFloat32OrZero`](#toFloat32OrZero).
* [`toFloat32OrDefault`](#toFloat32OrDefault).
**Syntaxe**
```sql theme={null}
toFloat32OrNull(x)
```
**Arguments**
* `x` — Une représentation sous forme de chaîne d’un nombre. [`String`](/fr/reference/data-types/string)
**Valeur renvoyée**
Renvoie une valeur `Float32` en cas de réussite, sinon `NULL`. [`Float32`](/fr/reference/data-types/float) ou [`NULL`](/fr/reference/syntax#null)
**Exemples**
**Exemple d’utilisation**
```sql title=Query theme={null}
SELECT
toFloat32OrNull('42.7'),
toFloat32OrNull('NaN'),
toFloat32OrNull('abc')
FORMAT Vertical
```
```response title=Response theme={null}
Row 1:
──────
toFloat32OrNull('42.7'): 42.7
toFloat32OrNull('NaN'): nan
toFloat32OrNull('abc'): \N
```
## toFloat32OrZero
Introduit dans : v1.1.0
Convertit une valeur d'entrée en valeur de type [Float32](/fr/reference/data-types/float), mais renvoie `0` en cas d'erreur.
Comme [`toFloat32`](#toFloat32), mais renvoie `0` au lieu de lever une exception en cas d'erreur de conversion.
Voir aussi :
* [`toFloat32`](#toFloat32).
* [`toFloat32OrNull`](#toFloat32OrNull).
* [`toFloat32OrDefault`](#toFloat32OrDefault).
**Syntaxe**
```sql theme={null}
toFloat32OrZero(x)
```
**Arguments**
* `x` — Une représentation sous forme de chaîne d’un nombre. [`String`](/fr/reference/data-types/string)
**Valeur renvoyée**
Renvoie une valeur de type `Float32` en cas de succès, sinon `0`. [`Float32`](/fr/reference/data-types/float)
**Exemples**
**Exemple d'utilisation**
```sql title=Query theme={null}
SELECT
toFloat32OrZero('42.7'),
toFloat32OrZero('abc')
FORMAT Vertical
```
```response title=Response theme={null}
Row 1:
──────
toFloat32OrZero('42.7'): 42.7
toFloat32OrZero('abc'): 0
```
## toFloat64
Introduit dans : v1.1.0
Convertit une valeur d’entrée en une valeur de type [`Float64`](/fr/reference/data-types/float).
Lève une exception en cas d’erreur.
Arguments pris en charge :
* Valeurs de type (U)Int\*.
* Représentations sous forme de chaîne de (U)Int8/16/32/128/256.
* Valeurs de type Float\*, y compris `NaN` et `Inf`.
* Représentations sous forme de chaîne de type Float\*, y compris `NaN` et `Inf` (insensible à la casse).
Arguments non pris en charge :
* Représentations sous forme de chaîne de valeurs binaires et hexadécimales, par exemple `SELECT toFloat64('0xc0fe');`.
Voir aussi :
* [`toFloat64OrZero`](#toFloat64OrZero).
* [`toFloat64OrNull`](#toFloat64OrNull).
* [`toFloat64OrDefault`](#toFloat64OrDefault).
**Syntaxe**
```sql theme={null}
toFloat64(expr)
```
**Arguments**
* `expr` — Expression renvoyant un nombre ou la représentation sous forme de chaîne d'un nombre. [`Expression`](/fr/reference/data-types/special-data-types/expression)
**Valeur renvoyée**
Renvoie une valeur en virgule flottante sur 64 bits. [`Float64`](/fr/reference/data-types/float)
**Exemples**
**Exemple d'utilisation**
```sql title=Query theme={null}
SELECT
toFloat64(42.7),
toFloat64('42.7'),
toFloat64('NaN')
FORMAT Vertical
```
```response title=Response theme={null}
Row 1:
──────
toFloat64(42.7): 42.7
toFloat64('42.7'): 42.7
toFloat64('NaN'): nan
```
## toFloat64OrDefault
Introduit dans : v21.11.0
Comme [`toFloat64`](#toFloat64), cette fonction convertit une valeur d'entrée en valeur de type [Float64](/fr/reference/data-types/float), mais renvoie la valeur par défaut en cas d'erreur.
Si aucune valeur `default` n'est fournie, `0` est renvoyé en cas d'erreur.
**Syntaxe**
```sql theme={null}
toFloat64OrDefault(expr[, default])
```
**Arguments**
* `expr` — Expression renvoyant un nombre ou une représentation sous forme de chaîne d'un nombre. [`String`](/fr/reference/data-types/string) ou [`(U)Int*`](/fr/reference/data-types/int-uint) ou [`Float*`](/fr/reference/data-types/float)
* `default` — Facultatif. La valeur par défaut à renvoyer si l'analyse échoue. [`Float64`](/fr/reference/data-types/float)
**Valeur renvoyée**
Renvoie une valeur de type Float64 en cas de réussite ; sinon, renvoie la valeur par défaut si elle est fournie, ou 0 dans le cas contraire. [`Float64`](/fr/reference/data-types/float)
**Exemples**
**Conversion réussie**
```sql title=Query theme={null}
SELECT toFloat64OrDefault('8', CAST('0', 'Float64'))
```
```response title=Response theme={null}
8
```
**Échec de la conversion**
```sql title=Query theme={null}
SELECT toFloat64OrDefault('abc', CAST('0', 'Float64'))
```
```response title=Response theme={null}
0
```
## toFloat64OrNull
Introduit dans : v1.1.0
Convertit une valeur d'entrée en valeur de type [Float64](/fr/reference/data-types/float), mais renvoie `NULL` en cas d'erreur.
Comme [`toFloat64`](#toFloat64), mais renvoie `NULL` au lieu de lever une exception en cas d'erreur de conversion.
Arguments pris en charge :
* Valeurs de type (U)Int\*.
* Représentations sous forme de chaîne de (U)Int8/16/32/128/256.
* Valeurs de type Float\*, y compris `NaN` et `Inf`.
* Représentations sous forme de chaîne du type Float\*, y compris `NaN` et `Inf` (insensible à la casse).
Arguments non pris en charge (renvoient `NULL`) :
* Représentations sous forme de chaîne de valeurs binaires et hexadécimales, par ex. `SELECT toFloat64OrNull('0xc0fe');`.
* Formats de chaîne non valides.
Voir aussi :
* [`toFloat64`](#toFloat64).
* [`toFloat64OrZero`](#toFloat64OrZero).
* [`toFloat64OrDefault`](#toFloat64OrDefault).
**Syntaxe**
```sql theme={null}
toFloat64OrNull(x)
```
**Arguments**
* `x` — La représentation sous forme de chaîne d’un nombre. [`String`](/fr/reference/data-types/string)
**Valeur renvoyée**
Renvoie une valeur de type `Float64` en cas de réussite, sinon `NULL`. [`Float64`](/fr/reference/data-types/float) ou [`NULL`](/fr/reference/syntax#null)
**Exemples**
**Exemple d’utilisation**
```sql title=Query theme={null}
SELECT
toFloat64OrNull('42.7'),
toFloat64OrNull('NaN'),
toFloat64OrNull('abc')
FORMAT Vertical
```
```response title=Response theme={null}
Row 1:
──────
toFloat64OrNull('42.7'): 42.7
toFloat64OrNull('NaN'): nan
toFloat64OrNull('abc'): \N
```
## toFloat64OrZero
Introduit dans : v1.1.0
Convertit une valeur d'entrée en une valeur de type [Float64](/fr/reference/data-types/float), mais renvoie `0` en cas d'erreur.
Comme [`toFloat64`](#toFloat64), mais renvoie `0` au lieu de lever une exception en cas d'erreur de conversion.
Voir aussi :
* [`toFloat64`](#toFloat64).
* [`toFloat64OrNull`](#toFloat64OrNull).
* [`toFloat64OrDefault`](#toFloat64OrDefault).
**Syntaxe**
```sql theme={null}
toFloat64OrZero(x)
```
**Arguments**
* `x` — Une représentation sous forme de chaîne d’un nombre. [`String`](/fr/reference/data-types/string)
**Valeur renvoyée**
Renvoie une valeur de type `Float64` en cas de réussite, sinon `0`. [`Float64`](/fr/reference/data-types/float)
**Exemples**
**Exemple d'utilisation**
```sql title=Query theme={null}
SELECT
toFloat64OrZero('42.7'),
toFloat64OrZero('abc')
FORMAT Vertical
```
```response title=Response theme={null}
Row 1:
──────
toFloat64OrZero('42.7'): 42.7
toFloat64OrZero('abc'): 0
```
## toInt128
Introduit dans : v1.1.0
Convertit une valeur d’entrée en une valeur de type [Int128](/fr/reference/data-types/int-uint).
Lève une exception en cas d’erreur.
La fonction utilise un arrondi vers zéro, c’est-à-dire qu’elle tronque la partie fractionnaire des nombres.
Arguments pris en charge :
* Valeurs ou représentations sous forme de chaîne de type (U)Int\*.
* Valeurs de type Float\*.
Arguments non pris en charge :
* Représentations sous forme de chaîne de valeurs de type Float\*, y compris `NaN` et `Inf`.
* Représentations sous forme de chaîne de valeurs binaires et hexadécimales, par ex. `SELECT toInt128('0xc0fe');`.
Si la valeur d’entrée ne peut pas être représentée dans les limites de Int128, le résultat déborde par excès ou par défaut.
Cela n’est pas considéré comme une erreur.
Voir aussi :
* [`toInt128OrZero`](#toInt128OrZero).
* [`toInt128OrNull`](#toInt128OrNull).
* [`toInt128OrDefault`](#toInt128OrDefault).
**Syntaxe**
```sql theme={null}
toInt128(expr)
```
**Arguments**
* `expr` — Expression renvoyant un nombre ou une représentation sous forme de chaîne d’un nombre. [`Expression`](/fr/reference/data-types/special-data-types/expression)
**Valeur renvoyée**
Renvoie une valeur entière sur 128 bits. [`Int128`](/fr/reference/data-types/int-uint)
**Exemples**
**Exemple d’utilisation**
```sql title=Query theme={null}
SELECT
toInt128(-128),
toInt128(-128.8),
toInt128('-128')
FORMAT Vertical
```
```response title=Response theme={null}
Row 1:
──────
toInt128(-128): -128
toInt128(-128.8): -128
toInt128('-128'): -128
```
## toInt128OrDefault
Introduit dans : v21.11.0
Comme [`toInt128`](#toInt128), cette fonction convertit une valeur d'entrée en une valeur de type [Int128](/fr/reference/data-types/int-uint), mais renvoie la valeur par défaut en cas d'erreur.
Si aucune valeur `default` n'est fournie, `0` est renvoyé en cas d'erreur.
**Syntaxe**
```sql theme={null}
toInt128OrDefault(expr[, default])
```
**Arguments**
* `expr` — Expression renvoyant un nombre ou la représentation sous forme de chaîne d’un nombre. [`String`](/fr/reference/data-types/string) ou [`(U)Int*`](/fr/reference/data-types/int-uint) ou [`Float*`](/fr/reference/data-types/float)
* `default` — Facultatif. La valeur par défaut à renvoyer si l’analyse échoue. [`Int128`](/fr/reference/data-types/int-uint)
**Valeur renvoyée**
Renvoie une valeur de type Int128 en cas de réussite ; sinon, renvoie la valeur par défaut si elle est fournie, ou 0 dans le cas contraire. [`Int128`](/fr/reference/data-types/int-uint)
**Exemples**
**Conversion réussie**
```sql title=Query theme={null}
SELECT toInt128OrDefault('-128', CAST('-1', 'Int128'))
```
```response title=Response theme={null}
-128
```
**Échec de la conversion**
```sql title=Query theme={null}
SELECT toInt128OrDefault('abc', CAST('-1', 'Int128'))
```
```response title=Response theme={null}
-1
```
## toInt128OrNull
Introduit dans : v20.8.0
Comme [`toInt128`](#toInt128), cette fonction convertit une valeur d’entrée en une valeur de type [Int128](/fr/reference/data-types/int-uint), mais renvoie `NULL` en cas d'erreur.
Arguments pris en charge :
* Représentations sous forme de chaîne de (U)Int\*.
Arguments non pris en charge (renvoient `NULL`) :
* Représentations sous forme de chaîne de valeurs Float\*, y compris `NaN` et `Inf`.
* Représentations sous forme de chaîne de valeurs binaires et hexadécimales, par exemple `SELECT toInt128OrNull('0xc0fe');`.
Si la valeur d’entrée ne peut pas être représentée dans les limites de [Int128](/fr/reference/data-types/int-uint), un dépassement de capacité du résultat se produit, par valeur supérieure ou inférieure.
Cela n'est pas considéré comme une erreur.
Voir aussi :
* [`toInt128`](#toInt128).
* [`toInt128OrZero`](#toInt128OrZero).
* [`toInt128OrDefault`](#toInt128OrDefault).
**Syntaxe**
```sql theme={null}
toInt128OrNull(x)
```
**Arguments**
* `x` — Représentation d’un nombre sous forme de chaîne de caractères. [`String`](/fr/reference/data-types/string)
**Valeur renvoyée**
Renvoie une valeur de type Int128, ou `NULL` si la conversion échoue. [`Int128`](/fr/reference/data-types/int-uint) ou [`NULL`](/fr/reference/syntax#null)
**Exemples**
**Exemple d’utilisation**
```sql title=Query theme={null}
SELECT
toInt128OrNull('-128'),
toInt128OrNull('abc')
FORMAT Vertical
```
```response title=Response theme={null}
Row 1:
──────
toInt128OrNull('-128'): -128
toInt128OrNull('abc'): \N
```
## toInt128OrZero
Introduit dans : v20.8.0
Convertit une valeur d'entrée en [Int128](/fr/reference/data-types/int-uint), mais renvoie `0` en cas d'erreur.
Comme [`toInt128`](#toInt128), mais renvoie `0` au lieu de lever une exception.
Voir aussi :
* [`toInt128`](#toInt128).
* [`toInt128OrNull`](#toInt128OrNull).
* [`toInt128OrDefault`](#toInt128OrDefault).
**Syntaxe**
```sql theme={null}
toInt128OrZero(x)
```
**Arguments**
* `x` — Valeur d'entrée à convertir. [`String`](/fr/reference/data-types/string) ou [`FixedString`](/fr/reference/data-types/fixedstring) ou [`Float*`](/fr/reference/data-types/float) ou [`Decimal`](/fr/reference/data-types/decimal) ou [`(U)Int*`](/fr/reference/data-types/int-uint) ou [`Date`](/fr/reference/data-types/date) ou [`DateTime`](/fr/reference/data-types/datetime)
**Valeur renvoyée**
Renvoie la valeur d'entrée convertie, ou `0` si la conversion échoue. [`Int128`](/fr/reference/data-types/int-uint)
**Exemples**
**Exemple d'utilisation**
```sql title=Query theme={null}
SELECT toInt128OrZero('123')
```
```response title=Response theme={null}
123
```
**En cas d’échec, la conversion renvoie zéro**
```sql title=Query theme={null}
SELECT toInt128OrZero('abc')
```
```response title=Response theme={null}
0
```
## toInt16
Introduit dans : v1.1.0
Convertit une valeur d'entrée en valeur de type [`Int16`](/fr/reference/data-types/int-uint).
Lève une exception en cas d'erreur.
Arguments pris en charge :
* Valeurs ou représentations sous forme de chaîne de type (U)Int\*.
* Valeurs de type Float\*.
Arguments non pris en charge :
* Représentations sous forme de chaîne de valeurs Float\*, y compris `NaN` et `Inf`.
* Représentations sous forme de chaîne de valeurs binaires et hexadécimales, par exemple `SELECT toInt16('0xc0fe');`.
Si la valeur d'entrée ne peut pas être représentée dans les bornes de [Int16](/fr/reference/data-types/int-uint), un dépassement inférieur ou supérieur se produit dans le résultat.
Cela n'est pas considéré comme une erreur.
Par exemple : `SELECT toInt16(32768) == -32768;`.
La fonction utilise l'[arrondi vers zéro](https://en.wikipedia.org/wiki/Rounding#Rounding_towards_zero), c'est-à-dire qu'elle tronque les chiffres après la virgule.
Voir aussi :
* [`toInt16OrZero`](#toInt16OrZero).
* [`toInt16OrNull`](#toInt16OrNull).
* [`toInt16OrDefault`](#toInt16OrDefault).
**Syntaxe**
```sql theme={null}
toInt16(expr)
```
**Arguments**
* `expr` — Expression renvoyant un nombre ou une représentation sous forme de chaîne d'un nombre. [`Expression`](/fr/reference/data-types/special-data-types/expression)
**Valeur renvoyée**
Renvoie une valeur entière de 16 bits. [`Int16`](/fr/reference/data-types/int-uint)
**Exemples**
**Exemple d’utilisation**
```sql title=Query theme={null}
SELECT
toInt16(-16),
toInt16(-16.16),
toInt16('-16')
FORMAT Vertical
```
```response title=Response theme={null}
Row 1:
──────
toInt16(-16): -16
toInt16(-16.16): -16
toInt16('-16'): -16
```
## toInt16OrDefault
Introduite dans : v21.11.0
Comme [`toInt16`](#toInt16), cette fonction convertit une valeur d'entrée en valeur de type [Int16](/fr/reference/data-types/int-uint), mais renvoie la valeur par défaut en cas d'erreur.
Si aucune valeur `default` n'est fournie, `0` est renvoyé en cas d'erreur.
**Syntaxe**
```sql theme={null}
toInt16OrDefault(expr[, default])
```
**Arguments**
* `expr` — Expression renvoyant un nombre ou la représentation sous forme de chaîne d'un nombre. [`String`](/fr/reference/data-types/string) ou [`(U)Int*`](/fr/reference/data-types/int-uint) ou [`Float*`](/fr/reference/data-types/float)
* `default` — Facultatif. Valeur par défaut à renvoyer si l'analyse échoue. [`Int16`](/fr/reference/data-types/int-uint)
**Valeur renvoyée**
Renvoyé une valeur de type Int16 en cas de succès ; sinon, renvoie la valeur par défaut si elle est fournie, ou 0 dans le cas contraire. [`Int16`](/fr/reference/data-types/int-uint)
**Exemples**
**Conversion réussie**
```sql title=Query theme={null}
SELECT toInt16OrDefault('-16', CAST('-1', 'Int16'))
```
```response title=Response theme={null}
-16
```
**Conversion échouée**
```sql title=Query theme={null}
SELECT toInt16OrDefault('abc', CAST('-1', 'Int16'))
```
```response title=Response theme={null}
-1
```
## toInt16OrNull
Introduit dans : v1.1.0
Comme [`toInt16`](#toInt16), cette fonction convertit une valeur d'entrée en une valeur de type [Int16](/fr/reference/data-types/int-uint), mais renvoie `NULL` en cas d'erreur.
Arguments pris en charge :
* Représentations sous forme de chaînes de caractères de (U)Int\*.
Arguments non pris en charge (renvoient `NULL`) :
* Représentations sous forme de chaînes de caractères de valeurs Float\*, y compris `NaN` et `Inf`.
* Représentations sous forme de chaînes de caractères de valeurs binaires et hexadécimales, par exemple `SELECT toInt16OrNull('0xc0fe');`.
Si la valeur d'entrée ne peut pas être représentée dans les limites de [Int16](/fr/reference/data-types/int-uint), un dépassement de capacité ou sous-dépassement du résultat se produit.
Cela n'est pas considéré comme une erreur.
Voir aussi :
* [`toInt16`](#toInt16).
* [`toInt16OrZero`](#toInt16OrZero).
* [`toInt16OrDefault`](#toInt16OrDefault).
**Syntaxe**
```sql theme={null}
toInt16OrNull(x)
```
**Arguments**
* `x` — Une représentation sous forme de chaîne d'un nombre. [`String`](/fr/reference/data-types/string)
**Valeur renvoyée**
Renvoie une valeur de type `Int16`, ou `NULL` si la conversion échoue. [`Int16`](/fr/reference/data-types/int-uint) ou [`NULL`](/fr/reference/syntax#null)
**Exemples**
**Exemple d'utilisation**
```sql title=Query theme={null}
SELECT
toInt16OrNull('-16'),
toInt16OrNull('abc')
FORMAT Vertical
```
```response title=Response theme={null}
Row 1:
──────
toInt16OrNull('-16'): -16
toInt16OrNull('abc'): \N
```
## toInt16OrZero
Introduit dans : v1.1.0
Comme [`toInt16`](#toInt16), cette fonction convertit une valeur d'entrée en une valeur de type [Int16](/fr/reference/data-types/int-uint), mais renvoie `0` en cas d'erreur.
Arguments pris en charge :
* représentation sous forme de chaîne de caractères de (U)Int\*.
Arguments non pris en charge (renvoient `0`) :
* représentation sous forme de chaîne de caractères de valeurs Float\*, y compris `NaN` et `Inf`.
* représentation sous forme de chaîne de caractères de valeurs binaires et hexadécimales, par exemple `SELECT toInt16OrZero('0xc0fe');`.
Si la valeur d'entrée ne peut pas être représentée dans les limites de [Int16](/fr/reference/data-types/int-uint), le résultat subit un dépassement de capacité ou sous-dépassement.
Cela n'est pas considéré comme une erreur.
Voir aussi :
* [`toInt16`](#toInt16).
* [`toInt16OrNull`](#toInt16OrNull).
* [`toInt16OrDefault`](#toInt16OrDefault).
**Syntaxe**
```sql theme={null}
toInt16OrZero(x)
```
**Arguments**
* `x` — Une représentation sous forme de chaîne d’un nombre. [`String`](/fr/reference/data-types/string)
**Valeur renvoyée**
Renvoie une valeur de type Int16, ou `0` si la conversion échoue. [`Int16`](/fr/reference/data-types/int-uint)
**Exemples**
**Exemple d’utilisation**
```sql title=Query theme={null}
SELECT
toInt16OrZero('16'),
toInt16OrZero('abc')
FORMAT Vertical
```
```response title=Response theme={null}
Row 1:
──────
toInt16OrZero('16'): 16
toInt16OrZero('abc'): 0
```
## toInt256
Introduit dans : v1.1.0
Convertit une valeur d'entrée en une valeur de type [Int256](/fr/reference/data-types/int-uint).
Lève une exception en cas d'erreur.
La fonction utilise l'arrondi vers zéro, ce qui signifie qu'elle tronque les chiffres après la virgule.
Arguments pris en charge :
* Valeurs ou représentations sous forme de chaîne de type (U)Int\*.
* Valeurs de type Float\*.
Arguments non pris en charge :
* Représentations sous forme de chaîne de valeurs Float\*, y compris `NaN` et `Inf`.
* Représentations sous forme de chaîne de valeurs binaires et hexadécimales, par ex. `SELECT toInt256('0xc0fe');`.
Si la valeur d'entrée ne peut pas être représentée dans les limites d'Int256, le résultat déborde.
Cela n'est pas considéré comme une erreur.
Voir aussi :
* [`toInt256OrZero`](#toInt256OrZero).
* [`toInt256OrNull`](#toInt256OrNull).
* [`toInt256OrDefault`](#toInt256OrDefault).
**Syntaxe**
```sql theme={null}
toInt256(expr)
```
**Arguments**
* `expr` — Expression renvoyant un nombre ou la représentation sous forme de chaîne d’un nombre. [`Expression`](/fr/reference/data-types/special-data-types/expression)
**Valeur renvoyée**
Renvoie une valeur entière de 256 bits. [`Int256`](/fr/reference/data-types/int-uint)
**Exemples**
**Exemple d’utilisation**
```sql title=Query theme={null}
SELECT
toInt256(-256),
toInt256(-256.256),
toInt256('-256')
FORMAT Vertical
```
```response title=Response theme={null}
Row 1:
──────
toInt256(-256): -256
toInt256(-256.256): -256
toInt256('-256'): -256
```
## toInt256OrDefault
Introduit dans : v21.11.0
Comme [`toInt256`](#toInt256), cette fonction convertit une valeur d'entrée en valeur de type [Int256](/fr/reference/data-types/int-uint), mais renvoie la valeur par défaut en cas d'erreur.
Si aucune valeur `default` n'est fournie, `0` est renvoyé en cas d'erreur.
**Syntaxe**
```sql theme={null}
toInt256OrDefault(expr[, default])
```
**Arguments**
* `expr` — Expression renvoyant un nombre ou une représentation sous forme de chaîne d’un nombre. [`String`](/fr/reference/data-types/string) ou [`(U)Int*`](/fr/reference/data-types/int-uint) ou [`Float*`](/fr/reference/data-types/float)
* `default` — Facultatif. Valeur par défaut à renvoyer si l’analyse échoue. [`Int256`](/fr/reference/data-types/int-uint)
**Valeur renvoyée**
Renvoie une valeur de type Int256 en cas de réussite ; sinon, renvoie la valeur par défaut si elle est fournie, ou 0 dans le cas contraire. [`Int256`](/fr/reference/data-types/int-uint)
**Exemples**
**Conversion réussie**
```sql title=Query theme={null}
SELECT toInt256OrDefault('-256', CAST('-1', 'Int256'))
```
```response title=Response theme={null}
-256
```
**Échec de la conversion**
```sql title=Query theme={null}
SELECT toInt256OrDefault('abc', CAST('-1', 'Int256'))
```
```response title=Response theme={null}
-1
```
## toInt256OrNull
Introduit dans : v20.8.0
Comme [`toInt256`](#toInt256), cette fonction convertit une valeur d’entrée en une valeur de type [Int256](/fr/reference/data-types/int-uint), mais renvoie `NULL` en cas d’erreur.
Arguments pris en charge :
* Représentations sous forme de chaîne de caractères de (U)Int\*.
Arguments non pris en charge (renvoient `NULL`) :
* Représentations sous forme de chaîne de caractères de valeurs Float\*, y compris `NaN` et `Inf`.
* Représentations sous forme de chaîne de caractères de valeurs binaires et hexadécimales, par exemple `SELECT toInt256OrNull('0xc0fe');`.
Si la valeur d’entrée ne peut pas être représentée dans les limites de [Int256](/fr/reference/data-types/int-uint), un dépassement de capacité ou un sous-dépassement du résultat se produit.
Cela n’est pas considéré comme une erreur.
Voir aussi :
* [`toInt256`](#toInt256).
* [`toInt256OrZero`](#toInt256OrZero).
* [`toInt256OrDefault`](#toInt256OrDefault).
**Syntaxe**
```sql theme={null}
toInt256OrNull(x)
```
**Arguments**
* `x` — Une représentation sous forme de chaîne d’un nombre. [`String`](/fr/reference/data-types/string)
**Valeur renvoyée**
Renvoie une valeur de type Int256, ou `NULL` si la conversion échoue. [`Int256`](/fr/reference/data-types/int-uint) ou [`NULL`](/fr/reference/syntax#null)
**Exemples**
**Exemple d’utilisation**
```sql title=Query theme={null}
SELECT
toInt256OrNull('-256'),
toInt256OrNull('abc')
FORMAT Vertical
```
```response title=Response theme={null}
Row 1:
──────
toInt256OrNull('-256'): -256
toInt256OrNull('abc'): \N
```
## toInt256OrZero
Introduit dans : v20.8.0
Convertit une valeur d’entrée en [Int256](/fr/reference/data-types/int-uint), mais renvoie `0` en cas d’erreur.
Comme [`toInt256`](#toInt256), mais renvoie `0` au lieu de lever une exception.
Voir aussi :
* [`toInt256`](#toInt256).
* [`toInt256OrNull`](#toInt256OrNull).
* [`toInt256OrDefault`](#toInt256OrDefault).
**Syntaxe**
```sql theme={null}
toInt256OrZero(x)
```
**Arguments**
* `x` — Valeur d'entrée à convertir. [`String`](/fr/reference/data-types/string) ou [`FixedString`](/fr/reference/data-types/fixedstring) ou [`Float*`](/fr/reference/data-types/float) ou [`Decimal`](/fr/reference/data-types/decimal) ou [`(U)Int*`](/fr/reference/data-types/int-uint) ou [`Date`](/fr/reference/data-types/date) ou [`DateTime`](/fr/reference/data-types/datetime)
**Valeur renvoyée**
Renvoie la valeur d'entrée convertie, ou `0` si la conversion échoue. [`Int256`](/fr/reference/data-types/int-uint)
**Exemples**
**Exemple d'utilisation**
```sql title=Query theme={null}
SELECT toInt256OrZero('123')
```
```response title=Response theme={null}
123
```
**Renvoie zéro en cas d’échec de la conversion**
```sql title=Query theme={null}
SELECT toInt256OrZero('abc')
```
```response title=Response theme={null}
0
```
## toInt32
Introduit dans : v1.1.0
Convertit une valeur d'entrée en valeur de type [`Int32`](/fr/reference/data-types/int-uint).
Lève une exception en cas d'erreur.
Arguments pris en charge :
* Valeurs ou représentations sous forme de chaîne de type (U)Int\*.
* Valeurs de type Float\*.
Arguments non pris en charge :
* Représentations sous forme de chaîne de valeurs Float\*, y compris `NaN` et `Inf`.
* Représentations sous forme de chaîne de valeurs binaires et hexadécimales, par exemple `SELECT toInt32('0xc0fe');`.
Si la valeur d'entrée ne peut pas être représentée dans les limites de [Int32](/fr/reference/data-types/int-uint), le résultat déborde, par excès ou par défaut.
Cela n'est pas considéré comme une erreur.
Par exemple : `SELECT toInt32(2147483648) == -2147483648;`
La fonction utilise l'[arrondi vers zéro](https://en.wikipedia.org/wiki/Rounding#Rounding_towards_zero), ce qui signifie qu'elle tronque la partie fractionnaire des nombres.
Voir aussi :
* [`toInt32OrZero`](#toInt32OrZero).
* [`toInt32OrNull`](#toInt32OrNull).
* [`toInt32OrDefault`](#toInt32OrDefault).
**Syntaxe**
```sql theme={null}
toInt32(expr)
```
**Arguments**
* `expr` — Expression renvoyant un nombre ou la représentation sous forme de chaîne d’un nombre. [`Expression`](/fr/reference/data-types/special-data-types/expression)
**Valeur renvoyée**
Renvoie une valeur entière sur 32 bits. [`Int32`](/fr/reference/data-types/int-uint)
**Exemples**
**Exemple d'utilisation**
```sql title=Query theme={null}
SELECT
toInt32(-32),
toInt32(-32.32),
toInt32('-32')
FORMAT Vertical
```
```response title=Response theme={null}
Row 1:
──────
toInt32(-32): -32
toInt32(-32.32): -32
toInt32('-32'): -32
```
## toInt32OrDefault
Introduit dans : v21.11.0
Comme [`toInt32`](#toInt32), cette fonction convertit une valeur d’entrée en valeur de type [Int32](/fr/reference/data-types/int-uint), mais renvoie la valeur par défaut en cas d’erreur.
Si aucune valeur `default` n’est fournie, `0` est renvoyé en cas d’erreur.
**Syntaxe**
```sql theme={null}
toInt32OrDefault(expr[, default])
```
**Arguments**
* `expr` — Expression renvoyant un nombre ou la représentation sous forme de chaîne d'un nombre. [`String`](/fr/reference/data-types/string) ou [`(U)Int*`](/fr/reference/data-types/int-uint) ou [`Float*`](/fr/reference/data-types/float)
* `default` — Facultatif. Valeur par défaut à renvoyer si l'analyse échoue. [`Int32`](/fr/reference/data-types/int-uint)
**Valeur renvoyée**
Renvoie une valeur de type Int32 en cas de réussite ; sinon, renvoie la valeur par défaut si elle est fournie, ou 0 dans le cas contraire. [`Int32`](/fr/reference/data-types/int-uint)
**Exemples**
**Conversion réussie**
```sql title=Query theme={null}
SELECT toInt32OrDefault('-32', CAST('-1', 'Int32'))
```
```response title=Response theme={null}
-32
```
**Échec de conversion**
```sql title=Query theme={null}
SELECT toInt32OrDefault('abc', CAST('-1', 'Int32'))
```
```response title=Response theme={null}
-1
```
## toInt32OrNull
Introduit dans : v1.1.0
Comme [`toInt32`](#toInt32), cette fonction convertit une valeur d'entrée en une valeur de type [Int32](/fr/reference/data-types/int-uint), mais renvoie `NULL` en cas d'erreur.
Arguments pris en charge :
* représentation sous forme de chaîne de caractères de (U)Int\*.
Arguments non pris en charge (renvoient `NULL`) :
* représentation sous forme de chaîne de caractères de valeurs Float\*, y compris `NaN` et `Inf`.
* représentation sous forme de chaîne de caractères de valeurs binaires et hexadécimales, par exemple `SELECT toInt32OrNull('0xc0fe');`.
Si la valeur d'entrée ne peut pas être représentée dans les limites de [Int32](/fr/reference/data-types/int-uint), un dépassement de capacité du résultat, par excès ou par défaut, se produit.
Cela n'est pas considéré comme une erreur.
Voir aussi :
* [`toInt32`](#toInt32).
* [`toInt32OrZero`](#toInt32OrZero).
* [`toInt32OrDefault`](#toInt32OrDefault).
**Syntaxe**
```sql theme={null}
toInt32OrNull(x)
```
**Arguments**
* `x` — Une représentation sous forme de chaîne d'un nombre. [`String`](/fr/reference/data-types/string)
**Valeur renvoyée**
Renvoie une valeur de type Int32, ou `NULL` si la conversion échoue. [`Int32`](/fr/reference/data-types/int-uint) ou [`NULL`](/fr/reference/syntax#null)
**Exemples**
**Exemple d'utilisation**
```sql title=Query theme={null}
SELECT
toInt32OrNull('-32'),
toInt32OrNull('abc')
FORMAT Vertical
```
```response title=Response theme={null}
Row 1:
──────
toInt32OrNull('-32'): -32
toInt32OrNull('abc'): \N
```
## toInt32OrZero
Introduit dans : v1.1.0
Comme [`toInt32`](#toInt32), cette fonction convertit une valeur en entrée en une valeur de type [Int32](/fr/reference/data-types/int-uint), mais renvoie `0` en cas d'erreur.
Arguments pris en charge :
* Représentations sous forme de chaîne de caractères de (U)Int\*.
Arguments non pris en charge (renvoient `0`) :
* Représentations sous forme de chaîne de caractères de valeurs Float\*, y compris `NaN` et `Inf`.
* Représentations sous forme de chaîne de caractères de valeurs binaires et hexadécimales, par exemple `SELECT toInt32OrZero('0xc0fe');`.
Si la valeur en entrée ne peut pas être représentée dans les limites de [Int32](/fr/reference/data-types/int-uint), un dépassement de capacité du résultat, par excès ou par défaut, se produit.
Cela n'est pas considéré comme une erreur.
Voir aussi :
* [`toInt32`](#toInt32).
* [`toInt32OrNull`](#toInt32OrNull).
* [`toInt32OrDefault`](#toInt32OrDefault).
**Syntaxe**
```sql theme={null}
toInt32OrZero(x)
```
**Arguments**
* `x` — Une représentation sous forme de chaîne de caractères d’un nombre. [`String`](/fr/reference/data-types/string)
**Valeur renvoyée**
Renvoie une valeur de type Int32, ou `0` si la conversion échoue. [`Int32`](/fr/reference/data-types/int-uint)
**Exemples**
**Exemple d'utilisation**
```sql title=Query theme={null}
SELECT
toInt32OrZero('32'),
toInt32OrZero('abc')
FORMAT Vertical
```
```response title=Response theme={null}
Row 1:
──────
toInt32OrZero('32'): 32
toInt32OrZero('abc'): 0
```
## toInt64
Introduit dans : v1.1.0
Convertit une valeur d'entrée en une valeur de type [`Int64`](/fr/reference/data-types/int-uint).
Lève une exception en cas d'erreur.
Arguments pris en charge :
* Valeurs ou représentation sous forme de chaîne de caractères de type (U)Int\*.
* Valeurs de type Float\*.
Arguments non pris en charge :
* représentation sous forme de chaîne de caractères de valeurs Float\*, y compris `NaN` et `Inf`.
* représentation sous forme de chaîne de caractères de valeurs binaires et hexadécimales, par exemple `SELECT toInt64('0xc0fe');`.
Si la valeur d'entrée ne peut pas être représentée dans les limites de [Int64](/fr/reference/data-types/int-uint), le résultat déborde.
Cela n'est pas considéré comme une erreur.
Par exemple : `SELECT toInt64(9223372036854775808) == -9223372036854775808;`
La fonction utilise l'[arrondi vers zéro](https://en.wikipedia.org/wiki/Rounding#Rounding_towards_zero), ce qui signifie qu'elle tronque la partie fractionnaire des nombres.
Voir aussi :
* [`toInt64OrZero`](#toInt64OrZero).
* [`toInt64OrNull`](#toInt64OrNull).
* [`toInt64OrDefault`](#toInt64OrDefault).
**Syntaxe**
```sql theme={null}
toInt64(expr)
```
**Arguments**
* `expr` — Expression renvoyant un nombre ou une représentation sous forme de chaîne d’un nombre. Pris en charge : valeurs ou représentation sous forme de chaîne de caractères de type (U)Int\*, valeurs de type Float\*. Non pris en charge : représentation sous forme de chaîne de caractères de valeurs Float\*, y compris NaN et Inf, représentation sous forme de chaîne de caractères de valeurs binaires et hexadécimales. [`Expression`](/fr/reference/data-types/special-data-types/expression)
**Valeur renvoyée**
Renvoie une valeur entière sur 64 bits. [`Int64`](/fr/reference/data-types/int-uint)
**Exemples**
**Exemple d’utilisation**
```sql title=Query theme={null}
SELECT
toInt64(-64),
toInt64(-64.64),
toInt64('-64')
FORMAT Vertical
```
```response title=Response theme={null}
Row 1:
──────
toInt64(-64): -64
toInt64(-64.64): -64
toInt64('-64'): -64
```
## toInt64OrDefault
Introduit dans : v21.11.0
Comme [`toInt64`](#toInt64), cette fonction convertit une valeur d'entrée en une valeur de type [Int64](/fr/reference/data-types/int-uint), mais renvoie la valeur par défaut en cas d'erreur.
Si aucune valeur `default` n'est fournie, `0` est renvoyé en cas d'erreur.
**Syntaxe**
```sql theme={null}
toInt64OrDefault(expr[, default])
```
**Arguments**
* `expr` — Expression renvoyant un nombre ou la représentation sous forme de chaîne d'un nombre. [`String`](/fr/reference/data-types/string) ou [`(U)Int*`](/fr/reference/data-types/int-uint) ou [`Float*`](/fr/reference/data-types/float)
* `default` — Facultatif. La valeur par défaut à renvoyer si l'analyse échoue. [`Int64`](/fr/reference/data-types/int-uint)
**Valeur renvoyée**
Renvoie une valeur de type Int64 en cas de succès ; sinon, renvoie la valeur par défaut si elle est fournie, ou 0 dans le cas contraire. [`Int64`](/fr/reference/data-types/int-uint)
**Exemples**
**Conversion réussie**
```sql title=Query theme={null}
SELECT toInt64OrDefault('-64', CAST('-1', 'Int64'))
```
```response title=Response theme={null}
-64
```
**Échec de conversion**
```sql title=Query theme={null}
SELECT toInt64OrDefault('abc', CAST('-1', 'Int64'))
```
```response title=Response theme={null}
-1
```
## toInt64OrNull
Introduit dans : v1.1.0
Comme [`toInt64`](#toInt64), cette fonction convertit une valeur d'entrée en une valeur de type [Int64](/fr/reference/data-types/int-uint), mais renvoie `NULL` en cas d'erreur.
Arguments pris en charge :
* Représentations sous forme de chaîne de (U)Int\*.
Arguments non pris en charge (renvoient `NULL`) :
* Représentations sous forme de chaîne de valeurs Float\*, y compris `NaN` et `Inf`.
* Représentations sous forme de chaîne de valeurs binaires et hexadécimales, par exemple `SELECT toInt64OrNull('0xc0fe');`.
Si la valeur d'entrée ne peut pas être représentée dans les limites de [Int64](/fr/reference/data-types/int-uint), un dépassement de capacité ou sous-dépassement du résultat se produit.
Cela n'est pas considéré comme une erreur.
Voir aussi :
* [`toInt64`](#toInt64).
* [`toInt64OrZero`](#toInt64OrZero).
* [`toInt64OrDefault`](#toInt64OrDefault).
**Syntaxe**
```sql theme={null}
toInt64OrNull(x)
```
**Arguments**
* `x` — La représentation sous forme de chaîne d’un nombre. [`String`](/fr/reference/data-types/string)
**Valeur renvoyée**
Renvoie une valeur de type Int64, ou `NULL` si la conversion échoue. [`Int64`](/fr/reference/data-types/int-uint) ou [`NULL`](/fr/reference/syntax#null)
**Exemples**
**Exemple d’utilisation**
```sql title=Query theme={null}
SELECT
toInt64OrNull('-64'),
toInt64OrNull('abc')
FORMAT Vertical
```
```response title=Response theme={null}
Row 1:
──────
toInt64OrNull('-64'): -64
toInt64OrNull('abc'): \N
```
## toInt64OrZero
Introduit dans : v1.1.0
Convertit une valeur d'entrée en [Int64](/fr/reference/data-types/int-uint), mais renvoie `0` en cas d'erreur.
Comme [`toInt64`](#toInt64), mais renvoie `0` au lieu de générer une exception.
Voir aussi :
* [`toInt64`](#toInt64).
* [`toInt64OrNull`](#toInt64OrNull).
* [`toInt64OrDefault`](#toInt64OrDefault).
**Syntaxe**
```sql theme={null}
toInt64OrZero(x)
```
**Arguments**
* `x` — Valeur d'entrée à convertir. [`String`](/fr/reference/data-types/string) ou [`FixedString`](/fr/reference/data-types/fixedstring) ou [`Float*`](/fr/reference/data-types/float) ou [`Decimal`](/fr/reference/data-types/decimal) ou [`(U)Int*`](/fr/reference/data-types/int-uint) ou [`Date`](/fr/reference/data-types/date) ou [`DateTime`](/fr/reference/data-types/datetime)
**Valeur renvoyée**
Renvoie la valeur d'entrée convertie, ou `0` si la conversion échoue. [`Int64`](/fr/reference/data-types/int-uint)
**Exemples**
**Exemple d'utilisation**
```sql title=Query theme={null}
SELECT toInt64OrZero('123')
```
```response title=Response theme={null}
123
```
**En cas d'échec de la conversion, zéro est renvoyé**
```sql title=Query theme={null}
SELECT toInt64OrZero('abc')
```
```response title=Response theme={null}
0
```
## toInt8
Introduit dans : v1.1.0
Convertit une valeur d'entrée en une valeur de type [`Int8`](/fr/reference/data-types/int-uint).
Déclenche une exception en cas d'erreur.
Arguments pris en charge :
* Valeurs ou représentations sous forme de chaîne de type (U)Int\*.
* Valeurs de type Float\*.
Arguments non pris en charge :
* Représentations sous forme de chaîne de valeurs Float\*, y compris `NaN` et `Inf`.
* Représentations sous forme de chaîne de valeurs binaires et hexadécimales, par ex. `SELECT toInt8('0xc0fe');`.
Si la valeur d'entrée ne peut pas être représentée dans l'intervalle de [Int8](/fr/reference/data-types/int-uint), le résultat subit un dépassement de capacité ou sous-dépassement.
Cela n'est pas considéré comme une erreur.
Par exemple : `SELECT toInt8(128) == -128;`.
La fonction utilise l'[arrondi vers zéro](https://en.wikipedia.org/wiki/Rounding#Rounding_towards_zero), ce qui signifie qu'elle tronque la partie fractionnaire des nombres.
Voir aussi :
* [`toInt8OrZero`](#toInt8OrZero).
* [`toInt8OrNull`](#toInt8OrNull).
* [`toInt8OrDefault`](#toInt8OrDefault).
**Syntaxe**
```sql theme={null}
toInt8(expr)
```
**Arguments**
* `expr` — Expression renvoyant un nombre ou la représentation sous forme de chaîne d'un nombre. [`Expression`](/fr/reference/data-types/special-data-types/expression)
**Valeur renvoyée**
Renvoie une valeur entière signée sur 8 bits. [`Int8`](/fr/reference/data-types/int-uint)
**Exemples**
**Exemple d'utilisation**
```sql title=Query theme={null}
SELECT
toInt8(-8),
toInt8(-8.8),
toInt8('-8')
FORMAT Vertical
```
```response title=Response theme={null}
Row 1:
──────
toInt8(-8): -8
toInt8(-8.8): -8
toInt8('-8'): -8
```
## toInt8OrDefault
Introduit dans : v21.11.0
Comme [`toInt8`](#toInt8), cette fonction convertit une valeur d'entrée en une valeur de type [Int8](/fr/reference/data-types/int-uint), mais renvoie la valeur par défaut en cas d'erreur.
Si aucune valeur `default` n'est fournie, `0` est renvoyé en cas d'erreur.
**Syntaxe**
```sql theme={null}
toInt8OrDefault(expr[, default])
```
**Arguments**
* `expr` — Expression qui renvoie un nombre ou la représentation sous forme de chaîne d’un nombre. [`String`](/fr/reference/data-types/string) ou [`(U)Int*`](/fr/reference/data-types/int-uint) ou [`Float*`](/fr/reference/data-types/float)
* `default` — Facultatif. Valeur par défaut à renvoyer si l’analyse échoue. [`Int8`](/fr/reference/data-types/int-uint)
**Valeur renvoyée**
Renvoie une valeur de type Int8 en cas de réussite ; sinon, renvoie la valeur par défaut si elle est fournie, ou 0 dans le cas contraire. [`Int8`](/fr/reference/data-types/int-uint)
**Exemples**
**Conversion réussie**
```sql title=Query theme={null}
SELECT toInt8OrDefault('-8', CAST('-1', 'Int8'))
```
```response title=Response theme={null}
-8
```
**Conversion échouée**
```sql title=Query theme={null}
SELECT toInt8OrDefault('abc', CAST('-1', 'Int8'))
```
```response title=Response theme={null}
-1
```
## toInt8OrNull
Introduit dans : v1.1.0
Comme [`toInt8`](#toInt8), cette fonction convertit une valeur d'entrée en une valeur de type [Int8](/fr/reference/data-types/int-uint), mais renvoie `NULL` en cas d'erreur.
Arguments pris en charge :
* Représentations sous forme de chaîne de (U)Int\*.
Arguments non pris en charge (renvoient `NULL`) :
* Représentations sous forme de chaîne de valeurs Float\*, y compris `NaN` et `Inf`.
* Représentations sous forme de chaîne de valeurs binaires et hexadécimales, par exemple `SELECT toInt8OrNull('0xc0fe');`.
Si la valeur d'entrée ne peut pas être représentée dans les limites de [Int8](/fr/reference/data-types/int-uint), il se produit un dépassement de capacité ou sous-dépassement.
Cela n'est pas considéré comme une erreur.
Voir aussi :
* [`toInt8`](#toInt8).
* [`toInt8OrZero`](#toInt8OrZero).
* [`toInt8OrDefault`](#toInt8OrDefault).
**Syntaxe**
```sql theme={null}
toInt8OrNull(x)
```
**Arguments**
* `x` — Une représentation sous forme de chaîne d’un nombre. [`String`](/fr/reference/data-types/string)
**Valeur renvoyée**
Renvoie une valeur de type Int8, ou `NULL` si la conversion échoue. [`Int8`](/fr/reference/data-types/int-uint) ou [`NULL`](/fr/reference/syntax#null)
**Exemples**
**Exemple d’utilisation**
```sql title=Query theme={null}
SELECT
toInt8OrNull('-8'),
toInt8OrNull('abc')
FORMAT Vertical
```
```response title=Response theme={null}
Row 1:
──────
toInt8OrNull('-8'): -8
toInt8OrNull('abc'): \N
```
## toInt8OrZero
Introduit dans : v1.1.0
Comme [`toInt8`](#toInt8), cette fonction convertit une valeur d’entrée en une valeur de type [Int8](/fr/reference/data-types/int-uint), mais renvoie `0` en cas d’erreur.
Arguments pris en charge :
* Représentations sous forme de chaîne de (U)Int\*.
Arguments non pris en charge (renvoient `0`) :
* Représentations sous forme de chaîne de valeurs Float\*, y compris `NaN` et `Inf`.
* Représentations sous forme de chaîne de valeurs binaires et hexadécimales, par exemple `SELECT toInt8OrZero('0xc0fe');`.
Si la valeur d’entrée ne peut pas être représentée dans les limites de [Int8](/fr/reference/data-types/int-uint), un dépassement de capacité ou sous-dépassement du résultat se produit.
Cela n’est pas considéré comme une erreur.
Voir aussi :
* [`toInt8`](#toInt8).
* [`toInt8OrNull`](#toInt8OrNull).
* [`toInt8OrDefault`](#toInt8OrDefault).
**Syntaxe**
```sql theme={null}
toInt8OrZero(x)
```
**Arguments**
* `x` — Une représentation sous forme de chaîne d’un nombre. [`String`](/fr/reference/data-types/string)
**Valeur renvoyée**
Renvoie une valeur de type Int8, sinon `0` si la conversion échoue. [`Int8`](/fr/reference/data-types/int-uint)
**Exemples**
**Exemple d’utilisation**
```sql title=Query theme={null}
SELECT
toInt8OrZero('8'),
toInt8OrZero('abc')
FORMAT Vertical
```
```response title=Response theme={null}
Row 1:
──────
toInt8OrZero('8'): 8
toInt8OrZero('abc'): 0
```
## toInterval
Introduit dans : v25.4.0
Crée une valeur Interval à partir d'une valeur numérique et d'une chaîne représentant l'unité.
Cette fonction offre un moyen unifié de créer des intervalles de différents types (secondes, minutes, heures, jours, semaines, mois, trimestres, années)
à l'aide d'une seule fonction, en spécifiant l'unité sous forme d'argument String. La chaîne d'unité est insensible à la casse.
Cela équivaut à appeler des fonctions spécifiques à chaque type, comme `toIntervalSecond`, `toIntervalMinute`, `toIntervalDay`, etc.,
mais permet de spécifier l'unité dynamiquement sous forme de paramètre de chaîne.
**Syntaxe**
```sql theme={null}
toInterval(value, unit)
```
**Arguments**
* `value` — La valeur numérique représentant le nombre d’unités. Peut être de n’importe quel type numérique. [`Int8`](/fr/reference/data-types/int-uint) ou [`Int16`](/fr/reference/data-types/int-uint) ou [`Int32`](/fr/reference/data-types/int-uint) ou [`Int64`](/fr/reference/data-types/int-uint) ou [`UInt8`](/fr/reference/data-types/int-uint) ou [`UInt16`](/fr/reference/data-types/int-uint) ou [`UInt32`](/fr/reference/data-types/int-uint) ou [`UInt64`](/fr/reference/data-types/int-uint) ou [`Float32`](/fr/reference/data-types/float) ou [`Float64`](/fr/reference/data-types/float)
* `unit` — L’unité de temps. Doit être une chaîne constante. Valeurs valides : 'nanosecond', 'microsecond', 'millisecond', 'second', 'minute', 'hour', 'day', 'week', 'month', 'quarter', 'year'. [`String`](/fr/reference/data-types/string)
**Valeur renvoyée**
Renvoie une valeur Interval du type spécifié. Le type de résultat dépend de l’unité : IntervalNanosecond, IntervalMicrosecond, IntervalMillisecond, IntervalSecond, IntervalMinute, IntervalHour, IntervalDay, IntervalWeek, IntervalMonth, IntervalQuarter ou IntervalYear. [`Interval`](/fr/reference/data-types/int-uint)
**Exemples**
**Créer des intervalles avec des unités différentes**
```sql title=Query theme={null}
SELECT
toInterval(5, 'second') AS seconds,
toInterval(3, 'day') AS days,
toInterval(2, 'month') AS months
```
```response title=Response theme={null}
┌─seconds─┬─days─┬─months─┐
│ 5 │ 3 │ 2 │
└─────────┴──────┴────────┘
```
**Utiliser des intervalles dans les calculs sur les dates**
```sql title=Query theme={null}
SELECT
now() AS current_time,
now() + toInterval(1, 'hour') AS one_hour_later,
now() - toInterval(7, 'day') AS week_ago
```
```response title=Response theme={null}
┌─────────current_time─┬──one_hour_later─────┬────────────week_ago─┐
│ 2025-01-04 10:30:00 │ 2025-01-04 11:30:00 │ 2024-12-28 10:30:00 │
└──────────────────────┴─────────────────────┴─────────────────────┘
```
**Création dynamique d’intervalles**
```sql title=Query theme={null}
SELECT toDate('2025-01-01') + toInterval(number, 'day') AS dates
FROM numbers(5)
```
```response title=Response theme={null}
┌──────dates─┐
│ 2025-01-01 │
│ 2025-01-02 │
│ 2025-01-03 │
│ 2025-01-04 │
│ 2025-01-05 │
└────────────┘
```
## toIntervalDay
Introduit dans : v1.1.0
Renvoie un intervalle de `n` jours, de type de données [`IntervalDay`](/fr/reference/data-types/special-data-types/interval).
**Syntaxe**
```sql theme={null}
toIntervalDay(n)
```
**Arguments**
* `n` — Nombre de jours. Nombres entiers ou leur représentation sous forme de chaîne, ainsi que les nombres à virgule flottante. [`(U)Int*`](/fr/reference/data-types/int-uint) ou [`Float*`](/fr/reference/data-types/float) ou [`String`](/fr/reference/data-types/string)
**Valeur renvoyée**
Renvoie un intervalle de `n` jours. [`Interval`](/fr/reference/data-types/int-uint)
**Exemples**
**Exemple d'utilisation**
```sql title=Query theme={null}
WITH
toDate('2025-06-15') AS date,
toIntervalDay(5) AS interval_to_days
SELECT date + interval_to_days AS result
```
```response title=Response theme={null}
┌─────result─┐
│ 2025-06-20 │
└────────────┘
```
## toIntervalHour
Introduit dans : v1.1.0
Renvoie un intervalle de `n` heures, de type [`IntervalHour`](/fr/reference/data-types/special-data-types/interval).
**Syntaxe**
```sql theme={null}
toIntervalHour(n)
```
**Arguments**
* `n` — Nombre d’heures. Nombres entiers ou leur représentation sous forme de chaîne, ainsi que nombres à virgule flottante. [`Int*`](/fr/reference/data-types/int-uint) or [`UInt*`](/fr/reference/data-types/int-uint) or [`Float*`](/fr/reference/data-types/float) or [`String`](/fr/reference/data-types/string)
**Valeur renvoyée**
Renvoie un intervalle de `n` heures. [`Interval`](/fr/reference/data-types/int-uint)
**Exemples**
**Exemple d’utilisation**
```sql title=Query theme={null}
WITH
toDate('2025-06-15') AS date,
toIntervalHour(12) AS interval_to_hours
SELECT date + interval_to_hours AS result
```
```response title=Response theme={null}
┌──────────────result─┐
│ 2025-06-15 12:00:00 │
└─────────────────────┘
```
## toIntervalMicrosecond
Introduit dans : v22.6.0
Renvoie un intervalle de `n` microsecondes, de type de données [`IntervalMicrosecond`](/fr/reference/data-types/special-data-types/interval).
**Syntaxe**
```sql theme={null}
toIntervalMicrosecond(n)
```
**Arguments**
* `n` — Nombre de microsecondes. [`(U)Int*`](/fr/reference/data-types/int-uint) ou [`Float*`](/fr/reference/data-types/float) ou [`String`](/fr/reference/data-types/string)
**Valeur renvoyée**
Renvoie un intervalle de `n` microsecondes. [`Interval`](/fr/reference/data-types/int-uint)
**Exemples**
**Exemple d'utilisation**
```sql title=Query theme={null}
WITH
toDateTime('2025-06-15') AS date,
toIntervalMicrosecond(30) AS interval_to_microseconds
SELECT date + interval_to_microseconds AS result
```
```response title=Response theme={null}
┌─────────────────────result─┐
│ 2025-06-15 00:00:00.000030 │
└────────────────────────────┘
```
## toIntervalMillisecond
Introduit dans : v22.6.0
Renvoie un intervalle de `n` millisecondes du type de données [IntervalMillisecond](/fr/reference/data-types/special-data-types/interval).
**Syntaxe**
```sql theme={null}
toIntervalMillisecond(n)
```
**Arguments**
* `n` — Nombre de millisecondes. [`(U)Int*`](/fr/reference/data-types/int-uint) ou [`Float*`](/fr/reference/data-types/float) ou [`String`](/fr/reference/data-types/string)
**Valeur renvoyée**
Renvoie un intervalle de `n` millisecondes. [`Interval`](/fr/reference/data-types/int-uint)
**Exemples**
**Exemple d'utilisation**
```sql title=Query theme={null}
WITH
toDateTime('2025-06-15') AS date,
toIntervalMillisecond(30) AS interval_to_milliseconds
SELECT date + interval_to_milliseconds AS result
```
```response title=Response theme={null}
┌──────────────────result─┐
│ 2025-06-15 00:00:00.030 │
└─────────────────────────┘
```
## toIntervalMinute
Introduit dans : v1.1.0
Renvoie un intervalle de `n` minutes du type de données [`IntervalMinute`](/fr/reference/data-types/special-data-types/interval).
**Syntaxe**
```sql theme={null}
toIntervalMinute(n)
```
**Arguments**
* `n` — Nombre de minutes. Nombres entiers ou leurs représentations sous forme de chaînes, ainsi que nombres à virgule flottante. [`(U)Int*`](/fr/reference/data-types/int-uint) ou [`Float*`](/fr/reference/data-types/float) ou [`String`](/fr/reference/data-types/string)
**Valeur renvoyée**
Renvoie un intervalle de `n` minutes. [`Interval`](/fr/reference/data-types/int-uint)
**Exemples**
**Exemple d'utilisation**
```sql title=Query theme={null}
WITH
toDate('2025-06-15') AS date,
toIntervalMinute(12) AS interval_to_minutes
SELECT date + interval_to_minutes AS result
```
```response title=Response theme={null}
┌──────────────result─┐
│ 2025-06-15 00:12:00 │
└─────────────────────┘
```
## toIntervalMonth
Introduit dans : v1.1.0
Renvoie un intervalle de `n` mois, de type de données [`IntervalMonth`](/fr/reference/data-types/special-data-types/interval).
**Syntaxe**
```sql theme={null}
toIntervalMonth(n)
```
**Arguments**
* `n` — Nombre de mois. [`(U)Int*`](/fr/reference/data-types/int-uint) ou [`Float*`](/fr/reference/data-types/float) ou [`String`](/fr/reference/data-types/string)
**Valeur renvoyée**
Renvoie un intervalle de `n` mois. [`Interval`](/fr/reference/data-types/int-uint)
**Exemples**
**Exemple d’utilisation**
```sql title=Query theme={null}
WITH
toDate('2025-06-15') AS date,
toIntervalMonth(1) AS interval_to_month
SELECT date + interval_to_month AS result
```
```response title=Response theme={null}
┌─────result─┐
│ 2025-07-15 │
└────────────┘
```
## toIntervalNanosecond
Introduit dans : v22.6.0
Renvoie un intervalle de `n` nanosecondes, de type de données [`IntervalNanosecond`](/fr/reference/data-types/special-data-types/interval).
**Syntaxe**
```sql theme={null}
toIntervalNanosecond(n)
```
**Arguments**
* `n` — Nombre de nanosecondes. [`(U)Int*`](/fr/reference/data-types/int-uint) ou [`Float*`](/fr/reference/data-types/float) ou [`String`](/fr/reference/data-types/string)
**Valeur renvoyée**
Renvoie un intervalle de `n` nanosecondes. [`Interval`](/fr/reference/data-types/int-uint)
**Exemples**
**Exemple d'utilisation**
```sql title=Query theme={null}
WITH
toDateTime('2025-06-15') AS date,
toIntervalNanosecond(30) AS interval_to_nanoseconds
SELECT date + interval_to_nanoseconds AS result
```
```response title=Response theme={null}
┌────────────────────────result─┐
│ 2025-06-15 00:00:00.000000030 │
└───────────────────────────────┘
```
## toIntervalQuarter
Introduit dans : v1.1.0
Renvoie un intervalle de `n` trimestres, de type de données [`IntervalQuarter`](/fr/reference/data-types/special-data-types/interval).
**Syntaxe**
```sql theme={null}
toIntervalQuarter(n)
```
**Arguments**
* `n` — Nombre de trimestres. [`(U)Int*`](/fr/reference/data-types/int-uint) ou [`Float*`](/fr/reference/data-types/float) ou [`String`](/fr/reference/data-types/string)
**Valeur renvoyée**
Renvoie un intervalle de `n` trimestres. [`Interval`](/fr/reference/data-types/int-uint)
**Exemples**
**Exemple d'utilisation**
```sql title=Query theme={null}
WITH
toDate('2025-06-15') AS date,
toIntervalQuarter(1) AS interval_to_quarter
SELECT date + interval_to_quarter AS result
```
```response title=Response theme={null}
┌─────result─┐
│ 2025-09-15 │
└────────────┘
```
## toIntervalSecond
Introduit dans : v1.1.0
Renvoie un intervalle de `n` secondes du type de données [`IntervalSecond`](/fr/reference/data-types/special-data-types/interval).
**Syntaxe**
```sql theme={null}
toIntervalSecond(n)
```
**Arguments**
* `n` — Nombre de secondes. Nombres entiers ou leurs représentations sous forme de chaîne, ainsi que nombres à virgule flottante. [`(U)Int*`](/fr/reference/data-types/int-uint) ou [`Float*`](/fr/reference/data-types/float) ou [`String`](/fr/reference/data-types/string)
**Valeur renvoyée**
Renvoie un intervalle de `n` secondes. [`Interval`](/fr/reference/data-types/int-uint)
**Exemples**
**Exemple d’utilisation**
```sql title=Query theme={null}
WITH
toDate('2025-06-15') AS date,
toIntervalSecond(30) AS interval_to_seconds
SELECT date + interval_to_seconds AS result
```
```response title=Response theme={null}
┌──────────────result─┐
│ 2025-06-15 00:00:30 │
└─────────────────────┘
```
## toIntervalWeek
Introduit dans : v1.1.0
Renvoie un intervalle de `n` semaines de type de données [`IntervalWeek`](/fr/reference/data-types/special-data-types/interval).
**Syntaxe**
```sql theme={null}
toIntervalWeek(n)
```
**Arguments**
* `n` — Nombre de semaines. [`(U)Int*`](/fr/reference/data-types/int-uint) ou [`Float*`](/fr/reference/data-types/float) ou [`String`](/fr/reference/data-types/string)
**Valeur renvoyée**
Renvoie un intervalle de `n` semaines. [`Interval`](/fr/reference/data-types/int-uint)
**Exemples**
**Exemple d'utilisation**
```sql title=Query theme={null}
WITH
toDate('2025-06-15') AS date,
toIntervalWeek(1) AS interval_to_week
SELECT date + interval_to_week AS result
```
```response title=Response theme={null}
┌─────result─┐
│ 2025-06-22 │
└────────────┘
```
## toIntervalYear
Introduit dans : v1.1.0
Renvoie un intervalle de `n` ans de type de données [`IntervalYear`](/fr/reference/data-types/special-data-types/interval).
**Syntaxe**
```sql theme={null}
toIntervalYear(n)
```
**Arguments**
* `n` — Nombre d’années. [`(U)Int*`](/fr/reference/data-types/int-uint) ou [`Float*`](/fr/reference/data-types/float) ou [`String`](/fr/reference/data-types/string)
**Valeur renvoyée**
Renvoie un intervalle de `n` ans. [`Interval`](/fr/reference/data-types/int-uint)
**Exemples**
**Exemple d’utilisation**
```sql title=Query theme={null}
WITH
toDate('2024-06-15') AS date,
toIntervalYear(1) AS interval_to_year
SELECT date + interval_to_year AS result
```
```response title=Response theme={null}
┌─────result─┐
│ 2025-06-15 │
└────────────┘
```
## toLowCardinality
Introduit dans : v18.12.0
Convertit l'argument d'entrée en une version [LowCardinality](/fr/reference/data-types/lowcardinality) du même type de données.
Pour convertir le type de données `LowCardinality` en type de données classique, utilisez la fonction [CAST](#CAST).
Par exemple : `CAST(x AS String)`.
**Syntaxe**
```sql theme={null}
toLowCardinality(expr)
```
**Arguments**
* `expr` — Expression produisant l’un des types de données pris en charge. [`String`](/fr/reference/data-types/string) ou [`FixedString`](/fr/reference/data-types/fixedstring) ou [`Date`](/fr/reference/data-types/date) ou [`DateTime`](/fr/reference/data-types/datetime) ou [`(U)Int*`](/fr/reference/data-types/int-uint) ou [`Float*`](/fr/reference/data-types/float)
**Valeur renvoyée**
Renvoie la valeur d’entrée convertie en type de données `LowCardinality`. [`LowCardinality`](/fr/reference/data-types/lowcardinality)
**Exemples**
**Exemple d’utilisation**
```sql title=Query theme={null}
SELECT toLowCardinality('1')
```
```response title=Response theme={null}
┌─toLowCardinality('1')─┐
│ 1 │
└───────────────────────┘
```
## toString
Introduit dans : v1.1.0
Convertit des valeurs en représentation sous forme de chaîne.
Pour les arguments DateTime, la fonction peut accepter un second argument String contenant le nom du fuseau horaire.
**Syntaxe**
```sql theme={null}
toString(value[, timezone])
```
**Arguments**
* `value` — Valeur à convertir en chaîne de caractères. [`Any`](/fr/reference/data-types/index)
* `timezone` — Facultatif. Nom du fuseau horaire pour la conversion de DateTime. [`String`](/fr/reference/data-types/string)
**Valeur renvoyée**
Renvoie une représentation sous forme de chaîne de caractères de la valeur d’entrée. [`String`](/fr/reference/data-types/string)
**Exemples**
**Exemple d’utilisation**
```sql title=Query theme={null}
SELECT
now() AS ts,
time_zone,
toString(ts, time_zone) AS str_tz_datetime
FROM system.time_zones
WHERE time_zone LIKE 'Europe%'
LIMIT 10
```
```response title=Response theme={null}
┌──────────────────ts─┬─time_zone─────────┬─str_tz_datetime─────┐
│ 2023-09-08 19:14:59 │ Europe/Amsterdam │ 2023-09-08 21:14:59 │
│ 2023-09-08 19:14:59 │ Europe/Andorra │ 2023-09-08 21:14:59 │
│ 2023-09-08 19:14:59 │ Europe/Astrakhan │ 2023-09-08 23:14:59 │
│ 2023-09-08 19:14:59 │ Europe/Athens │ 2023-09-08 22:14:59 │
│ 2023-09-08 19:14:59 │ Europe/Belfast │ 2023-09-08 20:14:59 │
└─────────────────────┴───────────────────┴─────────────────────┘
```
## toStringCutToZero
Introduit dans : v1.1.0
Accepte un argument [String](/fr/reference/data-types/string) ou [FixedString](/fr/reference/data-types/fixedstring) et renvoie une String contenant une copie de la chaîne d’origine tronquée au premier octet nul.
Les octets nuls (\0) sont considérés comme des terminateurs de chaîne.
Cette fonction est utile pour traiter des chaînes au format C ou des données binaires, où les octets nuls marquent la fin du contenu significatif.
**Syntaxe**
```sql theme={null}
toStringCutToZero(s)
```
**Arguments**
* `s` — String ou FixedString à traiter. [`String`](/fr/reference/data-types/string) ou [`FixedString`](/fr/reference/data-types/fixedstring)
**Valeur renvoyée**
Renvoie une String contenant les caractères qui précèdent le premier octet nul. [`String`](/fr/reference/data-types/string)
**Exemples**
**Exemple d’utilisation**
```sql title=Query theme={null}
SELECT
toStringCutToZero('hello'),
toStringCutToZero('hello\0world')
```
```response title=Response theme={null}
┌─toStringCutToZero('hello')─┬─toStringCutToZero('hello\\0world')─┐
│ hello │ hello │
└────────────────────────────┴───────────────────────────────────┘
```
## toTime
Introduit dans : v1.1.0
Convertit une valeur d’entrée au type [Time](/fr/reference/data-types/time).
Prend en charge la conversion à partir de String, FixedString, DateTime ou de types numériques représentant le nombre de secondes écoulées depuis minuit.
**Syntaxe**
```sql theme={null}
toTime(x)
```
**Arguments**
* `x` — Valeur d’entrée à convertir. [`String`](/fr/reference/data-types/string) ou [`FixedString`](/fr/reference/data-types/fixedstring) ou [`DateTime`](/fr/reference/data-types/datetime) ou [`(U)Int*`](/fr/reference/data-types/int-uint) ou [`Float*`](/fr/reference/data-types/float)
**Valeur renvoyée**
Renvoie la valeur convertie. [`Time`](/fr/reference/data-types/time)
**Exemples**
**Conversion de String en Time**
```sql title=Query theme={null}
SELECT toTime('14:30:25')
```
```response title=Response theme={null}
14:30:25
```
**Conversion de DateTime en Time**
```sql title=Query theme={null}
SELECT toTime(toDateTime('2025-04-15 14:30:25'))
```
```response title=Response theme={null}
14:30:25
```
**Conversion d'un entier en Time**
```sql title=Query theme={null}
SELECT toTime(52225)
```
```response title=Response theme={null}
14:30:25
```
## toTime64
introduit dans : v25.6.0
Convertit une valeur d'entrée en [Time64](/fr/reference/data-types/time64).
Prend en charge la conversion depuis String, FixedString, DateTime64 ou des types numériques représentant des microsecondes écoulées depuis minuit.
Offre une précision à la microseconde pour les valeurs temporelles.
**Syntaxe**
```sql theme={null}
toTime64(x)
```
**Arguments**
* `x` — Valeur d'entrée à convertir. [`String`](/fr/reference/data-types/string) or [`FixedString`](/fr/reference/data-types/fixedstring) or [`DateTime64`](/fr/reference/data-types/datetime64) or [`(U)Int*`](/fr/reference/data-types/int-uint) or [`Float*`](/fr/reference/data-types/float)
**Valeur renvoyée**
Renvoie la valeur d'entrée convertie avec une précision à la microseconde. [`Time64(6)`](/fr/reference/data-types/time64)
**Exemples**
**Conversion de `String` en `Time64`**
```sql title=Query theme={null}
SELECT toTime64('14:30:25.123456')
```
```response title=Response theme={null}
14:30:25.123456
```
**Conversion de DateTime64 en Time64**
```sql title=Query theme={null}
SELECT toTime64(toDateTime64('2025-04-15 14:30:25.123456', 6))
```
```response title=Response theme={null}
14:30:25.123456
```
**Conversion d’un entier en Time64**
```sql title=Query theme={null}
SELECT toTime64(52225123456)
```
```response title=Response theme={null}
14:30:25.123456
```
## toTime64OrNull
Introduit dans : v25.6.0
Convertit une valeur d'entrée en valeur de type `Time64`, mais renvoie `NULL` en cas d'erreur.
Comme [`toTime64`](#toTime64), mais renvoie `NULL` au lieu de lever une exception en cas d'erreur de conversion.
Voir aussi :
* [`toTime64`](#toTime64)
* [`toTime64OrZero`](#toTime64OrZero)
**Syntaxe**
```sql theme={null}
toTime64OrNull(x)
```
**Arguments**
* `x` — Une représentation sous forme de chaîne d’une heure avec une précision à la sous-seconde. [`String`](/fr/reference/data-types/string)
**Valeur renvoyée**
Renvoie une valeur `Time64` en cas de succès, sinon `NULL`. [`Time64`](/fr/reference/data-types/time64) ou [`NULL`](/fr/reference/syntax#null)
**Exemples**
**Exemple d’utilisation**
```sql title=Query theme={null}
SELECT toTime64OrNull('12:30:45.123'), toTime64OrNull('invalid')
```
```response title=Response theme={null}
┌─toTime64OrNull('12:30:45.123')─┬─toTime64OrNull('invalid')─┐
│ 12:30:45.123 │ ᴺᵁᴸᴸ │
└────────────────────────────────┴───────────────────────────┘
```
## toTime64OrZero
Introduit dans : v25.6.0
Convertit une valeur d'entrée en une valeur de type Time64, mais renvoie `00:00:00.000` en cas d'erreur.
Comme [`toTime64`](#toTime64), mais renvoie `00:00:00.000` au lieu de lever une exception lors d'une erreur de conversion.
**Syntaxe**
```sql theme={null}
toTime64OrZero(x)
```
**Arguments**
* `x` — Une représentation sous forme de chaîne d'une heure avec une précision à la sous-seconde. [`String`](/fr/reference/data-types/string)
**Valeur renvoyée**
Renvoie une valeur `Time64` en cas de réussite, sinon `00:00:00.000`. [`Time64`](/fr/reference/data-types/time64)
**Exemples**
**Exemple d'utilisation**
```sql title=Query theme={null}
SELECT toTime64OrZero('12:30:45.123'), toTime64OrZero('invalid')
```
```response title=Response theme={null}
┌─toTime64OrZero('12:30:45.123')─┬─toTime64OrZero('invalid')─┐
│ 12:30:45.123 │ 00:00:00.000 │
└────────────────────────────────┴──────────────────────────┘
```
## toTimeOrNull
Introduit dans : v1.1.0
Convertit une valeur d'entrée en une valeur de type Time, mais renvoie `NULL` en cas d'erreur.
Comme [`toTime`](#toTime), mais renvoie `NULL` au lieu de lever une exception en cas d'erreur de conversion.
Voir aussi :
* [`toTime`](#toTime)
* [`toTimeOrZero`](#toTimeOrZero)
**Syntaxe**
```sql theme={null}
toTimeOrNull(x)
```
**Arguments**
* `x` — Représentation sous forme de chaîne d'une heure. [`String`](/fr/reference/data-types/string)
**Valeur renvoyée**
Renvoie une valeur `Time` en cas de succès, sinon `NULL`. [`Time`](/fr/reference/data-types/time) ou [`NULL`](/fr/reference/syntax#null)
**Exemples**
**Exemple d'utilisation**
```sql title=Query theme={null}
SELECT toTimeOrNull('12:30:45'), toTimeOrNull('invalid')
```
```response title=Response theme={null}
┌─toTimeOrNull('12:30:45')─┬─toTimeOrNull('invalid')─┐
│ 12:30:45 │ ᴺᵁᴸᴸ │
└──────────────────────────┴─────────────────────────┘
```
## toTimeOrZero
Introduit dans : v1.1.0
Convertit une valeur d’entrée en une valeur de type Time, mais renvoie `00:00:00` en cas d’erreur.
Comme toTime, mais renvoie `00:00:00` au lieu de générer une exception en cas d’erreur de conversion.
**Syntaxe**
```sql theme={null}
toTimeOrZero(x)
```
**Arguments**
* `x` — Une représentation sous forme de chaîne d'une heure. [`String`](/fr/reference/data-types/string)
**Valeur renvoyée**
Renvoie une valeur `Time` en cas de réussite, sinon `00:00:00`. [`Time`](/fr/reference/data-types/time)
**Exemples**
**Exemple d'utilisation**
```sql title=Query theme={null}
SELECT toTimeOrZero('12:30:45'), toTimeOrZero('invalid')
```
```response title=Response theme={null}
┌─toTimeOrZero('12:30:45')─┬─toTimeOrZero('invalid')─┐
│ 12:30:45 │ 00:00:00 │
└──────────────────────────┴─────────────────────────┘
```
## toUInt128
Introduit dans : v1.1.0
Convertit une valeur d’entrée en une valeur de type [`UInt128`](/fr/reference/functions/regular-functions/type-conversion-functions#toUInt128).
Lève une exception en cas d’erreur.
La fonction utilise l’arrondi vers zéro, c’est-à-dire qu’elle tronque les chiffres après la virgule.
Arguments pris en charge :
* Valeurs ou représentations sous forme de chaîne de type (U)Int\*.
* Valeurs de type Float\*.
Arguments non pris en charge :
* Représentations sous forme de chaîne de valeurs Float\*, y compris `NaN` et `Inf`.
* Représentations sous forme de chaîne de valeurs binaires et hexadécimales, par ex. `SELECT toUInt128('0xc0fe');`.
Si la valeur d’entrée ne peut pas être représentée dans la plage de UInt128, le résultat produit un dépassement de capacité supérieur ou inférieur.
Cela n’est pas considéré comme une erreur.
Voir aussi :
* [`toUInt128OrZero`](#toUInt128OrZero).
* [`toUInt128OrNull`](#toUInt128OrNull).
* [`toUInt128OrDefault`](#toUInt128OrDefault).
**Syntaxe**
```sql theme={null}
toUInt128(expr)
```
**Arguments**
* `expr` — Expression renvoyant un nombre ou sa représentation sous forme de chaîne. [`Expression`](/fr/reference/data-types/special-data-types/expression)
**Valeur renvoyée**
Renvoie une valeur entière non signée de 128 bits. [`UInt128`](/fr/reference/data-types/int-uint)
**Exemples**
**Exemple d’utilisation**
```sql title=Query theme={null}
SELECT
toUInt128(128),
toUInt128(128.8),
toUInt128('128')
FORMAT Vertical
```
```response title=Response theme={null}
Row 1:
──────
toUInt128(128): 128
toUInt128(128.8): 128
toUInt128('128'): 128
```
## toUInt128OrDefault
Introduit dans : v21.11.0
Comme [`toUInt128`](#toUInt128), cette fonction convertit une valeur d'entrée en une valeur de type [`UInt128`](/fr/reference/data-types/int-uint), mais renvoie la valeur par défaut en cas d'erreur.
Si aucune valeur `default` n'est fournie, `0` est renvoyé en cas d'erreur.
**Syntaxe**
```sql theme={null}
toUInt128OrDefault(expr[, default])
```
**Arguments**
* `expr` — Expression renvoyant un nombre ou une représentation textuelle d’un nombre. [`String`](/fr/reference/data-types/string) ou [`(U)Int*`](/fr/reference/data-types/int-uint) ou [`Float*`](/fr/reference/data-types/float)
* `default` — Facultatif. Valeur par défaut à renvoyer si l’analyse échoue. [`UInt128`](/fr/reference/data-types/int-uint)
**Valeur renvoyée**
Renvoie une valeur de type UInt128 en cas de succès ; sinon, renvoie la valeur par défaut si elle est fournie, ou 0 dans le cas contraire. [`UInt128`](/fr/reference/data-types/int-uint)
**Exemples**
**Conversion réussie**
```sql title=Query theme={null}
SELECT toUInt128OrDefault('128', CAST('0', 'UInt128'))
```
```response title=Response theme={null}
128
```
**Échec de la conversion**
```sql title=Query theme={null}
SELECT toUInt128OrDefault('abc', CAST('0', 'UInt128'))
```
```response title=Response theme={null}
0
```
## toUInt128OrNull
Introduit dans : v21.6.0
Comme [`toUInt128`](#toUInt128), cette fonction convertit une valeur d'entrée en valeur de type [`UInt128`](/fr/reference/data-types/int-uint), mais renvoie `NULL` en cas d'erreur.
Arguments pris en charge :
* Représentations sous forme de chaîne de (U)Int\*.
Arguments non pris en charge (renvoient `NULL`) :
* Représentations sous forme de chaîne de valeurs Float\*, y compris `NaN` et `Inf`.
* Représentations sous forme de chaîne de valeurs binaires et hexadécimales, par exemple `SELECT toUInt128OrNull('0xc0fe');`.
Si la valeur d'entrée ne peut pas être représentée dans les limites de [`UInt128`](/fr/reference/data-types/int-uint), un dépassement de capacité (overflow ou underflow) du résultat se produit.
Cela n'est pas considéré comme une erreur.
Voir aussi :
* [`toUInt128`](#toUInt128).
* [`toUInt128OrZero`](#toUInt128OrZero).
* [`toUInt128OrDefault`](#toUInt128OrDefault).
**Syntaxe**
```sql theme={null}
toUInt128OrNull(x)
```
**Arguments**
* `x` — Une représentation sous forme de chaîne d’un nombre. [`String`](/fr/reference/data-types/string)
**Valeur renvoyée**
Renvoie une valeur de type UInt128, ou `NULL` si la conversion échoue. [`UInt128`](/fr/reference/data-types/int-uint) ou [`NULL`](/fr/reference/syntax#null)
**Exemples**
**Exemple d'utilisation**
```sql title=Query theme={null}
SELECT
toUInt128OrNull('128'),
toUInt128OrNull('abc')
FORMAT Vertical
```
```response title=Response theme={null}
Row 1:
──────
toUInt128OrNull('128'): 128
toUInt128OrNull('abc'): \N
```
## toUInt128OrZero
Introduit dans : v1.1.0
Comme [`toUInt128`](#toUInt128), cette fonction convertit une valeur d'entrée en une valeur de type [`UInt128`](/fr/reference/data-types/int-uint), mais renvoie `0` en cas d'erreur.
Arguments pris en charge :
* Représentations sous forme de chaîne de caractères de (U)Int\*.
Arguments non pris en charge (renvoient `0`) :
* Représentations sous forme de chaîne de caractères de valeurs Float\*, y compris `NaN` et `Inf`.
* Représentations sous forme de chaîne de caractères de valeurs binaires et hexadécimales, par exemple `SELECT toUInt128OrZero('0xc0fe');`.
Si la valeur d'entrée ne peut pas être représentée dans les limites de [`UInt128`](/fr/reference/data-types/int-uint), un dépassement de capacité du résultat se produit.
Cela n'est pas considéré comme une erreur.
Voir aussi :
* [`toUInt128`](#toUInt128).
* [`toUInt128OrNull`](#toUInt128OrNull).
* [`toUInt128OrDefault`](#toUInt128OrDefault).
**Syntaxe**
```sql theme={null}
toUInt128OrZero(x)
```
**Arguments**
* `x` — Une représentation sous forme de chaîne de caractères d’un nombre. [`String`](/fr/reference/data-types/string)
**Valeur renvoyée**
Renvoie une valeur de type UInt128, ou `0` si la conversion échoue. [`UInt128`](/fr/reference/data-types/int-uint)
**Exemples**
**Exemple d’utilisation**
```sql title=Query theme={null}
SELECT
toUInt128OrZero('128'),
toUInt128OrZero('abc')
FORMAT Vertical
```
```response title=Response theme={null}
Row 1:
──────
toUInt128OrZero('128'): 128
toUInt128OrZero('abc'): 0
```
## toUInt16
Introduit dans : v1.1.0
Convertit une valeur d'entrée en une valeur de type [`UInt16`](/fr/reference/data-types/int-uint).
Lève une exception en cas d'erreur.
Arguments pris en charge :
* Valeurs ou représentations sous forme de chaîne de type (U)Int\*.
* Valeurs de type Float\*.
Arguments non pris en charge :
* Représentations sous forme de chaîne de valeurs Float\*, y compris `NaN` et `Inf`.
* Représentations sous forme de chaîne de valeurs binaires et hexadécimales, par exemple `SELECT toUInt16('0xc0fe');`.
Si la valeur d'entrée ne peut pas être représentée dans les limites de [`UInt16`](/fr/reference/data-types/int-uint), un dépassement de capacité inférieur ou supérieur se produit dans le résultat.
Cela n'est pas considéré comme une erreur.
Par exemple : `SELECT toUInt16(65536) == 0;`.
La fonction utilise [l'arrondi vers zéro](https://en.wikipedia.org/wiki/Rounding#Rounding_towards_zero), ce qui signifie qu'elle tronque les chiffres après la virgule.
Voir aussi :
* [`toUInt16OrZero`](#toUInt16OrZero).
* [`toUInt16OrNull`](#toUInt16OrNull).
* [`toUInt16OrDefault`](#toUInt16OrDefault).
**Syntaxe**
```sql theme={null}
toUInt16(expr)
```
**Arguments**
* `expr` — Expression renvoyant un nombre ou sa représentation sous forme de chaîne. [`Expression`](/fr/reference/data-types/special-data-types/expression)
**Valeur renvoyée**
Renvoie une valeur entière non signée de 16 bits. [`UInt16`](/fr/reference/data-types/int-uint)
**Exemples**
**Exemple d'utilisation**
```sql title=Query theme={null}
SELECT
toUInt16(16),
toUInt16(16.16),
toUInt16('16')
FORMAT Vertical
```
```response title=Response theme={null}
Row 1:
──────
toUInt16(16): 16
toUInt16(16.16): 16
toUInt16('16'): 16
```
## toUInt16OrDefault
Introduit dans : v21.11.0
Comme [`toUInt16`](#toUInt16), cette fonction convertit une valeur d'entrée en une valeur de type [UInt16](/fr/reference/data-types/int-uint), mais renvoie la valeur par défaut en cas d'erreur.
Si aucune valeur `default` n'est fournie, `0` est renvoyé en cas d'erreur.
**Syntaxe**
```sql theme={null}
toUInt16OrDefault(expr[, default])
```
**Arguments**
* `expr` — Expression renvoyant un nombre ou une représentation d’un nombre sous forme de chaîne. [`String`](/fr/reference/data-types/string) ou [`(U)Int*`](/fr/reference/data-types/int-uint) ou [`Float*`](/fr/reference/data-types/float)
* `default` — Facultatif. La valeur par défaut à renvoyer si l’analyse échoue. [`UInt16`](/fr/reference/data-types/int-uint)
**Valeur renvoyée**
Renvoie une valeur de type UInt16 en cas de succès ; sinon, renvoie la valeur par défaut si elle est fournie, ou 0 dans le cas contraire. [`UInt16`](/fr/reference/data-types/int-uint)
**Exemples**
**Conversion réussie**
```sql title=Query theme={null}
SELECT toUInt16OrDefault('16', CAST('0', 'UInt16'))
```
```response title=Response theme={null}
16
```
**Échec de la conversion**
```sql title=Query theme={null}
SELECT toUInt16OrDefault('abc', CAST('0', 'UInt16'))
```
```response title=Response theme={null}
0
```
## toUInt16OrNull
Introduit dans : v1.1.0
Comme [`toUInt16`](#toUInt16), cette fonction convertit une valeur d'entrée en une valeur de type [`UInt16`](/fr/reference/data-types/int-uint), mais renvoie `NULL` en cas d'erreur.
Arguments pris en charge :
* Représentations sous forme de chaîne de (U)Int8/16/32/128/256.
Arguments non pris en charge (renvoient `NULL`) :
* Représentations sous forme de chaîne de valeurs Float\*, y compris `NaN` et `Inf`.
* Représentations sous forme de chaîne de valeurs binaires et hexadécimales, par ex. `SELECT toUInt16OrNull('0xc0fe');`.
Si la valeur d'entrée ne peut pas être représentée dans les limites de [`UInt16`](/fr/reference/data-types/int-uint), un dépassement de capacité (overflow ou underflow) se produit dans le résultat.
Cela n'est pas considéré comme une erreur.
Voir aussi :
* [`toUInt16`](#toUInt16).
* [`toUInt16OrZero`](#toUInt16OrZero).
* [`toUInt16OrDefault`](#toUInt16OrDefault).
**Syntaxe**
```sql theme={null}
toUInt16OrNull(x)
```
**Arguments**
* `x` — Représentation sous forme de chaîne d'un nombre. [`String`](/fr/reference/data-types/string)
**Valeur renvoyée**
Renvoie une valeur de type `UInt16`, ou `NULL` si la conversion échoue. [`UInt16`](/fr/reference/data-types/int-uint) ou [`NULL`](/fr/reference/syntax#null)
**Exemples**
**Exemple d'utilisation**
```sql title=Query theme={null}
SELECT
toUInt16OrNull('16'),
toUInt16OrNull('abc')
FORMAT Vertical
```
```response title=Response theme={null}
Row 1:
──────
toUInt16OrNull('16'): 16
toUInt16OrNull('abc'): \N
```
## toUInt16OrZero
Introduit dans : v1.1.0
Comme [`toUInt16`](#toUInt16), cette fonction convertit une valeur d'entrée en valeur de type [`UInt16`](/fr/reference/data-types/int-uint), mais renvoie `0` en cas d'erreur.
Arguments pris en charge :
* Représentations sous forme de chaîne de (U)Int8/16/32/128/256.
Arguments non pris en charge (renvoient `0`) :
* Représentations sous forme de chaîne de valeurs Float\*, y compris `NaN` et `Inf`.
* Représentations sous forme de chaîne de valeurs binaires et hexadécimales, par exemple `SELECT toUInt16OrZero('0xc0fe');`.
Si la valeur d'entrée ne peut pas être représentée dans les limites de [`UInt16`](/fr/reference/data-types/int-uint), il se produit un dépassement de capacité par excès ou par défaut du résultat.
Cela n'est pas considéré comme une erreur.
Voir aussi :
* [`toUInt16`](#toUInt16).
* [`toUInt16OrNull`](#toUInt16OrNull).
* [`toUInt16OrDefault`](#toUInt16OrDefault).
**Syntaxe**
```sql theme={null}
toUInt16OrZero(x)
```
**Arguments**
* `x` — Une représentation sous forme de chaîne d’un nombre. [`String`](/fr/reference/data-types/string)
**Valeur de retour**
Renvoie une valeur de type UInt16, ou `0` si la conversion échoue. [`UInt16`](/fr/reference/data-types/int-uint)
**Exemples**
**Exemple d’utilisation**
```sql title=Query theme={null}
SELECT
toUInt16OrZero('16'),
toUInt16OrZero('abc')
FORMAT Vertical
```
```response title=Response theme={null}
Row 1:
──────
toUInt16OrZero('16'): 16
toUInt16OrZero('abc'): 0
```
## toUInt256
Introduit dans : v1.1.0
Convertit une valeur d’entrée en valeur de type UInt256.
Lève une exception en cas d’erreur.
La fonction utilise un arrondi vers zéro, ce qui signifie qu’elle tronque les chiffres après la virgule.
Arguments pris en charge :
* Valeurs ou représentations sous forme de chaîne de type (U)Int\*.
* Valeurs de type Float\*.
Arguments non pris en charge :
* Représentations sous forme de chaîne de valeurs de type Float\*, y compris `NaN` et `Inf`.
* Représentations sous forme de chaîne de valeurs binaires et hexadécimales, par exemple `SELECT toUInt256('0xc0fe');`.
Si la valeur d’entrée ne peut pas être représentée dans les bornes de UInt256, le résultat déborde par excès ou par défaut.
Cela n’est pas considéré comme une erreur.
Voir aussi :
* [`toUInt256OrZero`](#toUInt256OrZero).
* [`toUInt256OrNull`](#toUInt256OrNull).
* [`toUInt256OrDefault`](#toUInt256OrDefault).
**Syntaxe**
```sql theme={null}
toUInt256(expr)
```
**Arguments**
* `expr` — Expression qui renvoie un nombre ou la représentation sous forme de chaîne d’un nombre. [`Expression`](/fr/reference/data-types/special-data-types/expression)
**Valeur renvoyée**
Renvoie une valeur entière non signée de 256 bits. [`UInt256`](/fr/reference/data-types/int-uint)
**Exemples**
**Exemple d’utilisation**
```sql title=Query theme={null}
SELECT
toUInt256(256),
toUInt256(256.256),
toUInt256('256')
FORMAT Vertical
```
```response title=Response theme={null}
Row 1:
──────
toUInt256(256): 256
toUInt256(256.256): 256
toUInt256('256'): 256
```
## toUInt256OrDefault
Introduit dans : v21.11.0
Comme [`toUInt256`](#toUInt256), cette fonction convertit une valeur d'entrée en valeur de type [UInt256](/fr/reference/data-types/int-uint), mais renvoie la valeur par défaut en cas d'erreur.
Si aucune valeur `default` n'est fournie, `0` est renvoyé en cas d'erreur.
**Syntaxe**
```sql theme={null}
toUInt256OrDefault(expr[, default])
```
**Arguments**
* `expr` — Expression renvoyant un nombre ou la représentation sous forme de chaîne d’un nombre. [`String`](/fr/reference/data-types/string) ou [`(U)Int*`](/fr/reference/data-types/int-uint) ou [`Float*`](/fr/reference/data-types/float)
* `default` — Facultatif. Valeur par défaut à renvoyer si l’analyse échoue. [`UInt256`](/fr/reference/data-types/int-uint)
**Valeur renvoyée**
Renvoie une valeur de type UInt256 en cas de succès ; sinon, renvoie la valeur par défaut si elle est fournie, ou 0 dans le cas contraire. [`UInt256`](/fr/reference/data-types/int-uint)
**Exemples**
**Conversion réussie**
```sql title=Query theme={null}
SELECT toUInt256OrDefault('-256', CAST('0', 'UInt256'))
```
```response title=Response theme={null}
0
```
**Échec de la conversion**
```sql title=Query theme={null}
SELECT toUInt256OrDefault('abc', CAST('0', 'UInt256'))
```
```response title=Response theme={null}
0
```
## toUInt256OrNull
Introduit dans : v20.8.0
Comme [`toUInt256`](#toUInt256), cette fonction convertit une valeur d’entrée en une valeur de type [`UInt256`](/fr/reference/data-types/int-uint), mais renvoie `NULL` en cas d’erreur.
Arguments pris en charge :
* Représentations sous forme de chaîne de (U)Int\*.
Arguments non pris en charge (renvoient `NULL`) :
* Représentations sous forme de chaîne de valeurs Float\*, y compris `NaN` et `Inf`.
* Représentations sous forme de chaîne de valeurs binaires et hexadécimales, par exemple `SELECT toUInt256OrNull('0xc0fe');`.
Si la valeur d’entrée ne peut pas être représentée dans les limites de [`UInt256`](/fr/reference/data-types/int-uint), un dépassement de capacité par excès ou par défaut se produit.
Cela n’est pas considéré comme une erreur.
Voir aussi :
* [`toUInt256`](#toUInt256).
* [`toUInt256OrZero`](#toUInt256OrZero).
* [`toUInt256OrDefault`](#toUInt256OrDefault).
**Syntaxe**
```sql theme={null}
toUInt256OrNull(x)
```
**Arguments**
* `x` — Représentation sous forme de chaîne d’un nombre. [`String`](/fr/reference/data-types/string)
**Valeur renvoyée**
Renvoie une valeur de type UInt256, ou `NULL` si la conversion échoue. [`UInt256`](/fr/reference/data-types/int-uint) ou [`NULL`](/fr/reference/syntax#null)
**Exemples**
**Exemple d’utilisation**
```sql title=Query theme={null}
SELECT
toUInt256OrNull('256'),
toUInt256OrNull('abc')
FORMAT Vertical
```
```response title=Response theme={null}
Row 1:
──────
toUInt256OrNull('256'): 256
toUInt256OrNull('abc'): \N
```
## toUInt256OrZero
Introduit dans : v20.8.0
Comme [`toUInt256`](#toUInt256), cette fonction convertit une valeur d’entrée en une valeur de type [`UInt256`](/fr/reference/data-types/int-uint), mais renvoie `0` en cas d’erreur.
Arguments pris en charge :
* Représentations sous forme de chaîne de (U)Int\*.
Arguments non pris en charge (renvoient `0`) :
* Représentations sous forme de chaîne de valeurs Float\*, y compris `NaN` et `Inf`.
* Représentations sous forme de chaîne de valeurs binaires et hexadécimales, par exemple `SELECT toUInt256OrZero('0xc0fe');`.
Si la valeur d’entrée ne peut pas être représentée dans les limites de [`UInt256`](/fr/reference/data-types/int-uint), un dépassement de capacité par excès ou par défaut se produit dans le résultat.
Cela n’est pas considéré comme une erreur.
Voir aussi :
* [`toUInt256`](#toUInt256).
* [`toUInt256OrNull`](#toUInt256OrNull).
* [`toUInt256OrDefault`](#toUInt256OrDefault).
**Syntaxe**
```sql theme={null}
toUInt256OrZero(x)
```
**Arguments**
* `x` — Représentation sous forme de chaîne d’un nombre. [`String`](/fr/reference/data-types/string)
**Valeur renvoyée**
Renvoie une valeur de type UInt256, sinon `0` si la conversion échoue. [`UInt256`](/fr/reference/data-types/int-uint)
**Exemples**
**Exemple d’utilisation**
```sql title=Query theme={null}
SELECT
toUInt256OrZero('256'),
toUInt256OrZero('abc')
FORMAT Vertical
```
```response title=Response theme={null}
Row 1:
──────
toUInt256OrZero('256'): 256
toUInt256OrZero('abc'): 0
```
## toUInt32
Introduit dans : v1.1.0
Convertit une valeur d'entrée en une valeur de type [`UInt32`](/fr/reference/data-types/int-uint).
Lève une exception en cas d’erreur.
Arguments pris en charge :
* Les valeurs ou les représentations sous forme de chaîne de caractères du type (U)Int\*.
* Les valeurs de type Float\*.
Arguments non pris en charge :
* Les représentations sous forme de chaîne de caractères de valeurs Float\*, y compris `NaN` et `Inf`.
* Les représentations sous forme de chaîne de caractères de valeurs binaires et hexadécimales, par ex. `SELECT toUInt32('0xc0fe');`.
Si la valeur d'entrée ne peut pas être représentée dans la plage de [`UInt32`](/fr/reference/data-types/int-uint), le résultat déborde ou sous-déborde.
Cela n'est pas considéré comme une erreur.
Par exemple : `SELECT toUInt32(4294967296) == 0;`
La fonction utilise l'[arrondi vers zéro](https://en.wikipedia.org/wiki/Rounding#Rounding_towards_zero), ce qui signifie qu'elle tronque la partie fractionnaire des nombres.
Voir aussi :
* [`toUInt32OrZero`](#toUInt32OrZero).
* [`toUInt32OrNull`](#toUInt32OrNull).
* [`toUInt32OrDefault`](#toUInt32OrDefault).
**Syntaxe**
```sql theme={null}
toUInt32(expr)
```
**Arguments**
* `expr` — Expression renvoyant un nombre ou la représentation textuelle d’un nombre. [`Expression`](/fr/reference/data-types/special-data-types/expression)
**Valeur renvoyée**
Renvoie une valeur entière non signée sur 32 bits. [`UInt32`](/fr/reference/data-types/int-uint)
**Exemples**
**Exemple d’utilisation**
```sql title=Query theme={null}
SELECT
toUInt32(32),
toUInt32(32.32),
toUInt32('32')
FORMAT Vertical
```
```response title=Response theme={null}
Row 1:
──────
toUInt32(32): 32
toUInt32(32.32): 32
toUInt32('32'): 32
```
## toUInt32OrDefault
Introduit dans : v21.11.0
Comme [`toUInt32`](#toUInt32), cette fonction convertit une valeur d'entrée en une valeur de type [UInt32](/fr/reference/data-types/int-uint), mais renvoie la valeur par défaut en cas d'erreur.
Si aucune valeur `default` n'est fournie, `0` est renvoyé en cas d'erreur.
**Syntaxe**
```sql theme={null}
toUInt32OrDefault(expr[, default])
```
**Arguments**
* `expr` — expression renvoyant un nombre ou la représentation sous forme de chaîne d’un nombre. [`String`](/fr/reference/data-types/string) ou [`(U)Int*`](/fr/reference/data-types/int-uint) ou [`Float*`](/fr/reference/data-types/float)
* `default` — Facultatif. La valeur par défaut à renvoyer si l’analyse n’aboutit pas. [`UInt32`](/fr/reference/data-types/int-uint)
**Valeur renvoyée**
Renvoie une valeur de type UInt32 en cas de succès ; sinon, renvoie la valeur par défaut si elle est fournie, ou 0 dans le cas contraire. [`UInt32`](/fr/reference/data-types/int-uint)
**Exemples**
**Conversion réussie**
```sql title=Query theme={null}
SELECT toUInt32OrDefault('32', CAST('0', 'UInt32'))
```
```response title=Response theme={null}
32
```
**Conversion échouée**
```sql title=Query theme={null}
SELECT toUInt32OrDefault('abc', CAST('0', 'UInt32'))
```
```response title=Response theme={null}
0
```
## toUInt32OrNull
Introduit dans : v1.1.0
Comme [`toUInt32`](#toUInt32), cette fonction convertit une valeur d’entrée en une valeur de type [`UInt32`](/fr/reference/data-types/int-uint), mais renvoie `NULL` en cas d’erreur.
Arguments pris en charge :
* Représentations sous forme de chaîne de (U)Int8/16/32/128/256.
Arguments non pris en charge (renvoient `NULL`) :
* Représentations sous forme de chaîne de valeurs Float\*, y compris `NaN` et `Inf`.
* Représentations sous forme de chaîne de valeurs binaires et hexadécimales, par ex. `SELECT toUInt32OrNull('0xc0fe');`.
Si la valeur d’entrée ne peut pas être représentée dans les limites de [`UInt32`](/fr/reference/data-types/int-uint), un dépassement de capacité par excès ou par défaut du résultat se produit.
Cela n’est pas considéré comme une erreur.
Voir aussi :
* [`toUInt32`](#toUInt32).
* [`toUInt32OrZero`](#toUInt32OrZero).
* [`toUInt32OrDefault`](#toUInt32OrDefault).
**Syntaxe**
```sql theme={null}
toUInt32OrNull(x)
```
**Arguments**
* `x` — Une représentation sous forme de chaîne d'un nombre. [`String`](/fr/reference/data-types/string)
**Valeur renvoyée**
Renvoie une valeur de type `UInt32` ; sinon, `NULL` si la conversion échoue. [`UInt32`](/fr/reference/data-types/int-uint) ou [`NULL`](/fr/reference/syntax#null)
**Exemples**
**Exemple d'utilisation**
```sql title=Query theme={null}
SELECT
toUInt32OrNull('32'),
toUInt32OrNull('abc')
FORMAT Vertical
```
```response title=Response theme={null}
Row 1:
──────
toUInt32OrNull('32'): 32
toUInt32OrNull('abc'): \N
```
## toUInt32OrZero
Introduit dans : v1.1.0
Comme [`toUInt32`](#toUInt32), cette fonction convertit une valeur d’entrée en une valeur de type [`UInt32`](/fr/reference/data-types/int-uint), mais renvoie `0` en cas d'erreur.
Arguments pris en charge :
* Représentations sous forme de chaîne de (U)Int8/16/32/128/256.
Arguments non pris en charge (renvoient `0`) :
* Représentations sous forme de chaîne de valeurs Float\*, y compris `NaN` et `Inf`.
* Représentations sous forme de chaîne de valeurs binaires et hexadécimales, par exemple `SELECT toUInt32OrZero('0xc0fe');`.
Si la valeur d’entrée ne peut pas être représentée dans les limites de [`UInt32`](/fr/reference/data-types/int-uint), un dépassement de capacité par excès ou par défaut se produit.
Cela n'est pas considéré comme une erreur.
Voir aussi :
* [`toUInt32`](#toUInt32).
* [`toUInt32OrNull`](#toUInt32OrNull).
* [`toUInt32OrDefault`](#toUInt32OrDefault).
**Syntaxe**
```sql theme={null}
toUInt32OrZero(x)
```
**Arguments**
* `x` — Une représentation sous forme de chaîne d’un nombre. [`String`](/fr/reference/data-types/string)
**Valeur renvoyée**
Renvoie une valeur de type UInt32, ou `0` si la conversion échoue. [`UInt32`](/fr/reference/data-types/int-uint)
**Exemples**
**Exemple d’utilisation**
```sql title=Query theme={null}
SELECT
toUInt32OrZero('32'),
toUInt32OrZero('abc')
FORMAT Vertical
```
```response title=Response theme={null}
Row 1:
──────
toUInt32OrZero('32'): 32
toUInt32OrZero('abc'): 0
```
## toUInt64
Introduit dans : v1.1.0
Convertit une valeur d'entrée en une valeur de type [`UInt64`](/fr/reference/data-types/int-uint).
lever une exception en cas d'erreur.
Arguments pris en charge :
* Valeurs ou représentations sous forme de chaîne de type (U)Int\*.
* Valeurs de type Float\*.
Types non pris en charge :
* Représentations sous forme de chaîne de valeurs Float\*, y compris `NaN` et `Inf`.
* Représentations sous forme de chaîne de valeurs binaires et hexadécimales, par exemple `SELECT toUInt64('0xc0fe');`.
Si la valeur d'entrée ne peut pas être représentée dans les limites de [`UInt64`](/fr/reference/data-types/int-uint), le résultat fait l'objet d'un dépassement supérieur ou inférieur.
Cela n'est pas considéré comme une erreur.
Par exemple : `SELECT toUInt64(18446744073709551616) == 0;`
La fonction utilise l'[arrondi vers zéro](https://en.wikipedia.org/wiki/Rounding#Rounding_towards_zero), ce qui signifie qu'elle tronque les chiffres fractionnaires des nombres.
Voir aussi :
* [`toUInt64OrZero`](#toUInt64OrZero).
* [`toUInt64OrNull`](#toUInt64OrNull).
* [`toUInt64OrDefault`](#toUInt64OrDefault).
**Syntaxe**
```sql theme={null}
toUInt64(expr)
```
**Arguments**
* `expr` — Expression renvoyant un nombre ou sa représentation sous forme de chaîne. [`Expression`](/fr/reference/data-types/special-data-types/expression)
**Valeur renvoyée**
Renvoie une valeur entière non signée de 64 bits. [`UInt64`](/fr/reference/data-types/int-uint)
**Exemples**
**Exemple d’utilisation**
```sql title=Query theme={null}
SELECT
toUInt64(64),
toUInt64(64.64),
toUInt64('64')
FORMAT Vertical
```
```response title=Response theme={null}
Row 1:
──────
toUInt64(64): 64
toUInt64(64.64): 64
toUInt64('64'): 64
```
## toUInt64OrDefault
Introduit dans : v21.11.0
Comme [`toUInt64`](#toUInt64), cette fonction convertit une valeur d'entrée en une valeur de type [UInt64](/fr/reference/data-types/int-uint), mais renvoie la valeur par défaut en cas d'erreur.
Si aucune valeur `default` n'est fournie, `0` est renvoyé en cas d'erreur.
**Syntaxe**
```sql theme={null}
toUInt64OrDefault(expr[, default])
```
**Arguments**
* `expr` — Expression qui renvoie un nombre ou la représentation sous forme de chaîne d’un nombre. [`String`](/fr/reference/data-types/string) ou [`(U)Int*`](/fr/reference/data-types/int-uint) ou [`Float*`](/fr/reference/data-types/float)
* `default` — Facultatif. La valeur par défaut à renvoyer si l’analyse échoue. [`UInt64`](/fr/reference/data-types/int-uint)
**Valeur renvoyée**
Renvoie une valeur de type UInt64 en cas de succès ; sinon, renvoie la valeur par défaut si elle est fournie, ou 0 dans le cas contraire. [`UInt64`](/fr/reference/data-types/int-uint)
**Exemples**
**Conversion réussie**
```sql title=Query theme={null}
SELECT toUInt64OrDefault('64', CAST('0', 'UInt64'))
```
```response title=Response theme={null}
64
```
**Conversion échouée**
```sql title=Query theme={null}
SELECT toUInt64OrDefault('abc', CAST('0', 'UInt64'))
```
```response title=Response theme={null}
0
```
## toUInt64OrNull
Introduit dans : v1.1.0
Comme [`toUInt64`](#toUInt64), cette fonction convertit une valeur d'entrée en une valeur de type [`UInt64`](/fr/reference/data-types/int-uint), mais renvoie `NULL` en cas d'erreur.
Arguments pris en charge :
* Représentations sous forme de chaîne de (U)Int\*.
Arguments non pris en charge (renvoient `NULL`) :
* Représentations sous forme de chaîne de valeurs Float\*, y compris `NaN` et `Inf`.
* Représentations sous forme de chaîne de valeurs binaires et hexadécimales, par ex. `SELECT toUInt64OrNull('0xc0fe');`.
Si la valeur d'entrée ne peut pas être représentée dans les limites de [`UInt64`](/fr/reference/data-types/int-uint), le résultat subit un dépassement de capacité, par excès ou par défaut.
Cela n'est pas considéré comme une erreur.
Voir aussi :
* [`toUInt64`](#toUInt64).
* [`toUInt64OrZero`](#toUInt64OrZero).
* [`toUInt64OrDefault`](#toUInt64OrDefault).
**Syntaxe**
```sql theme={null}
toUInt64OrNull(x)
```
**Arguments**
* `x` — Représentation sous forme de chaîne d’un nombre. [`String`](/fr/reference/data-types/string)
**Valeur renvoyée**
Renvoie une valeur de type UInt64, ou `NULL` si la conversion échoue. [`UInt64`](/fr/reference/data-types/int-uint) ou [`NULL`](/fr/reference/syntax#null)
**Exemples**
**Exemple d'utilisation**
```sql title=Query theme={null}
SELECT
toUInt64OrNull('64'),
toUInt64OrNull('abc')
FORMAT Vertical
```
```response title=Response theme={null}
Row 1:
──────
toUInt64OrNull('64'): 64
toUInt64OrNull('abc'): \N
```
## toUInt64OrZero
Introduit dans : v1.1.0
Comme [`toUInt64`](#toUInt64), cette fonction convertit une valeur d’entrée en une valeur de type [`UInt64`](/fr/reference/data-types/int-uint), mais renvoie `0` en cas d’erreur.
Arguments pris en charge :
* Représentations sous forme de chaîne de (U)Int\*.
Arguments non pris en charge (renvoient `0`) :
* Représentations sous forme de chaîne de valeurs Float\*, y compris `NaN` et `Inf`.
* Représentations sous forme de chaîne de valeurs binaires et hexadécimales, par exemple `SELECT toUInt64OrZero('0xc0fe');`.
Si la valeur d’entrée ne peut pas être représentée dans les limites de [`UInt64`](/fr/reference/data-types/int-uint), il se produit un dépassement de capacité par excès ou par défaut du résultat.
Cela n’est pas considéré comme une erreur.
Voir aussi :
* [`toUInt64`](#toUInt64).
* [`toUInt64OrNull`](#toUInt64OrNull).
* [`toUInt64OrDefault`](#toUInt64OrDefault).
**Syntaxe**
```sql theme={null}
toUInt64OrZero(x)
```
**Arguments**
* `x` — Une représentation sous forme de chaîne d’un nombre. [`String`](/fr/reference/data-types/string)
**Valeur renvoyée**
Renvoie une valeur de type UInt64, ou `0` si la conversion échoue. [`UInt64`](/fr/reference/data-types/int-uint)
**Exemples**
**Exemple d’utilisation**
```sql title=Query theme={null}
SELECT
toUInt64OrZero('64'),
toUInt64OrZero('abc')
FORMAT Vertical
```
```response title=Response theme={null}
Row 1:
──────
toUInt64OrZero('64'): 64
toUInt64OrZero('abc'): 0
```
## toUInt8
Introduit dans : v1.1.0
Convertit une valeur d'entrée en une valeur de type [`UInt8`](/fr/reference/data-types/int-uint).
lever une exception en cas d'erreur.
Arguments pris en charge :
* Valeurs ou représentations sous forme de chaîne de type (U)Int\*.
* Valeurs de type Float\*.
Arguments non pris en charge :
* Représentations sous forme de chaîne de valeurs Float\*, y compris `NaN` et `Inf`.
* Représentations sous forme de chaîne de valeurs binaires et hexadécimales, par exemple `SELECT toUInt8('0xc0fe');`.
Si la valeur d'entrée ne peut pas être représentée dans la plage de [UInt8](/fr/reference/data-types/int-uint), un dépassement de capacité par excès ou par défaut du résultat se produit.
Cela n'est pas considéré comme une erreur.
Par exemple : `SELECT toUInt8(256) == 0;`.
La fonction utilise l'[arrondi vers zéro](https://en.wikipedia.org/wiki/Rounding#Rounding_towards_zero), ce qui signifie qu'elle tronque les chiffres fractionnaires des nombres.
Voir aussi :
* [`toUInt8OrZero`](#toUInt8OrZero).
* [`toUInt8OrNull`](#toUInt8OrNull).
* [`toUInt8OrDefault`](#toUInt8OrDefault).
**Syntaxe**
```sql theme={null}
toUInt8(expr)
```
**Arguments**
* `expr` — Expression renvoyant un nombre ou sa représentation sous forme de chaîne. [`Expression`](/fr/reference/data-types/special-data-types/expression)
**Valeur renvoyée**
Renvoie une valeur entière non signée de 8 bits. [`UInt8`](/fr/reference/data-types/int-uint)
**Exemples**
**Exemple d’utilisation**
```sql title=Query theme={null}
SELECT
toUInt8(8),
toUInt8(8.8),
toUInt8('8')
FORMAT Vertical
```
```response title=Response theme={null}
Row 1:
──────
toUInt8(8): 8
toUInt8(8.8): 8
toUInt8('8'): 8
```
## toUInt8OrDefault
Introduit dans : v21.11.0
Comme [`toUInt8`](#toUInt8), cette fonction convertit une valeur d'entrée en une valeur de type [UInt8](/fr/reference/data-types/int-uint), mais renvoie la valeur par défaut en cas d'erreur.
Si aucune valeur `default` n'est fournie, `0` est renvoyé en cas d'erreur.
**Syntaxe**
```sql theme={null}
toUInt8OrDefault(expr[, default])
```
**Arguments**
* `expr` — Expression renvoyant un nombre ou la représentation sous forme de chaîne d’un nombre. [`String`](/fr/reference/data-types/string) ou [`(U)Int*`](/fr/reference/data-types/int-uint) ou [`Float*`](/fr/reference/data-types/float)
* `default` — Facultatif. Valeur par défaut à renvoyer si l’analyse échoue. [`UInt8`](/fr/reference/data-types/int-uint)
**Valeur renvoyée**
Renvoie une valeur de type UInt8 en cas de réussite ; sinon, renvoie la valeur par défaut si elle est fournie, ou 0 dans le cas contraire. [`UInt8`](/fr/reference/data-types/int-uint)
**Exemples**
**Conversion réussie**
```sql title=Query theme={null}
SELECT toUInt8OrDefault('8', CAST('0', 'UInt8'))
```
```response title=Response theme={null}
8
```
**Conversion échouée**
```sql title=Query theme={null}
SELECT toUInt8OrDefault('abc', CAST('0', 'UInt8'))
```
```response title=Response theme={null}
0
```
## toUInt8OrNull
Introduit dans : v1.1.0
Comme [`toUInt8`](#toUInt8), cette fonction convertit une valeur d’entrée en une valeur de type [`UInt8`](/fr/reference/data-types/int-uint), mais renvoie `NULL` en cas d'erreur.
Arguments pris en charge :
* Représentations sous forme de chaîne de caractères de (U)Int8/16/32/128/256.
Arguments non pris en charge (renvoient `NULL`) :
* Représentations sous forme de chaîne de caractères de valeurs Float\* ordinaires, y compris `NaN` et `Inf`.
* Représentations sous forme de chaîne de caractères de valeurs binaires et hexadécimales, par ex. `SELECT toUInt8OrNull('0xc0fe');`.
Si la valeur d’entrée ne peut pas être représentée dans les limites de [`UInt8`](/fr/reference/data-types/int-uint), un dépassement de capacité par excès ou par défaut du résultat se produit.
Cela n'est pas considéré comme une erreur.
Voir aussi :
* [`toUInt8`](#toUInt8).
* [`toUInt8OrZero`](#toUInt8OrZero).
* [`toUInt8OrDefault`](#toUInt8OrDefault).
**Syntaxe**
```sql theme={null}
toUInt8OrNull(x)
```
**Arguments**
* `x` — Une représentation sous forme de chaîne d’un nombre. [`String`](/fr/reference/data-types/string)
**Valeur renvoyée**
Renvoie une valeur de type UInt8, ou `NULL` si la conversion échoue. [`UInt8`](/fr/reference/data-types/int-uint) ou [`NULL`](/fr/reference/syntax#null)
**Exemples**
**Exemple d'utilisation**
```sql title=Query theme={null}
SELECT
toUInt8OrNull('42'),
toUInt8OrNull('abc')
FORMAT Vertical
```
```response title=Response theme={null}
Row 1:
──────
toUInt8OrNull('42'): 42
toUInt8OrNull('abc'): \N
```
## toUInt8OrZero
Introduite dans : v1.1.0
Comme [`toUInt8`](#toUInt8), cette fonction convertit une valeur d’entrée en une valeur de type [`UInt8`](/fr/reference/data-types/int-uint), mais renvoie `0` en cas d’erreur.
Arguments pris en charge :
* Représentations sous forme de chaîne de (U)Int8/16/32/128/256.
Arguments non pris en charge (renvoient `0`) :
* Représentations sous forme de chaîne de valeurs Float\* ordinaires, y compris `NaN` et `Inf`.
* Représentations sous forme de chaîne de valeurs binaires et hexadécimales, par exemple `SELECT toUInt8OrZero('0xc0fe');`.
Si la valeur d’entrée ne peut pas être représentée dans les limites de [`UInt8`](/fr/reference/data-types/int-uint), un dépassement de capacité (par excès ou par défaut) du résultat se produit.
Cela n’est pas considéré comme une erreur.
Voir aussi :
* [`toUInt8`](#toUInt8).
* [`toUInt8OrNull`](#toUInt8OrNull).
* [`toUInt8OrDefault`](#toUInt8OrDefault).
**Syntaxe**
```sql theme={null}
toUInt8OrZero(x)
```
**Arguments**
* `x` — Une représentation sous forme de chaîne d’un nombre. [`String`](/fr/reference/data-types/string)
**Valeur renvoyée**
Renvoie une valeur de type UInt8, ou `0` si la conversion échoue. [`UInt8`](/fr/reference/data-types/int-uint)
**Exemples**
**Exemple d’utilisation**
```sql title=Query theme={null}
SELECT
toUInt8OrZero('-8'),
toUInt8OrZero('abc')
FORMAT Vertical
```
```response title=Response theme={null}
Row 1:
──────
toUInt8OrZero('-8'): 0
toUInt8OrZero('abc'): 0
```
## toUUID
Introduit dans : v1.1.0
Convertit une valeur de type String en une valeur UUID.
**Syntaxe**
```sql theme={null}
toUUID(string)
```
**Arguments**
* `string` — UUID sous forme de chaîne. [`String`](/fr/reference/data-types/string) ou [`FixedString`](/fr/reference/data-types/fixedstring)
**Valeur renvoyée**
Renvoie un UUID à partir de la représentation sous forme de chaîne de l'UUID. [`UUID`](/fr/reference/data-types/uuid)
**Exemples**
**Exemple d'utilisation**
```sql title=Query theme={null}
SELECT toUUID('61f0c404-5cb3-11e7-907b-a6006ad3dba0') AS uuid
```
```response title=Response theme={null}
┌─────────────────────────────────uuid─┐
│ 61f0c404-5cb3-11e7-907b-a6006ad3dba0 │
└──────────────────────────────────────┘
```
## toUUIDOrZero
Introduit dans : v20.12.0
Convertit une valeur d’entrée en une valeur de type [UUID](/fr/reference/data-types/uuid), mais renvoie un UUID nul en cas d’erreur.
Semblable à [`toUUID`](/fr/reference/functions/regular-functions/type-conversion-functions#toUUID), mais renvoie un UUID nul (`00000000-0000-0000-0000-000000000000`) au lieu de lever une exception en cas d’erreur de conversion.
Arguments pris en charge :
* Représentations sous forme de chaîne d’un UUID au format standard (8-4-4-4-12 chiffres hexadécimaux).
* Représentations sous forme de chaîne d’un UUID sans tirets (32 chiffres hexadécimaux).
Arguments non pris en charge (renvoient un UUID nul) :
* Formats de chaîne non valides.
* Types autres que chaîne.
**Syntaxe**
```sql theme={null}
toUUIDOrZero(x)
```
**Arguments**
* `x` — Une représentation sous forme de chaîne d’un UUID. [`String`](/fr/reference/data-types/string)
**Valeur renvoyée**
Renvoie une valeur UUID en cas de succès, sinon l’UUID zéro (`00000000-0000-0000-0000-000000000000`). [`UUID`](/fr/reference/data-types/uuid)
**Exemples**
**Exemple d’utilisation**
```sql title=Query theme={null}
SELECT
toUUIDOrZero('550e8400-e29b-41d4-a716-446655440000') AS valid_uuid,
toUUIDOrZero('invalid-uuid') AS invalid_uuid
```
```response title=Response theme={null}
┌─valid_uuid───────────────────────────┬─invalid_uuid─────────────────────────┐
│ 550e8400-e29b-41d4-a716-446655440000 │ 00000000-0000-0000-0000-000000000000 │
└──────────────────────────────────────┴──────────────────────────────────────┘
```
## toUnixTimestamp64Micro
Introduit dans : v20.5.0
Convertit un [`DateTime64`](/fr/reference/data-types/datetime64) en une valeur [`Int64`](/fr/reference/data-types/int-uint) avec une précision fixe à la microseconde.
La valeur d'entrée est mise à l'échelle de manière appropriée en fonction de sa précision.
La valeur de sortie est relative à l'UTC, et non au fuseau horaire de la valeur d'entrée.
**Syntaxe**
```sql theme={null}
toUnixTimestamp64Micro(value)
```
**Arguments**
* `value` — Valeur `DateTime64` avec une précision quelconque. [`DateTime64`](/fr/reference/data-types/datetime64)
**Valeur renvoyée**
Renvoie un horodatage Unix en microsecondes. [`Int64`](/fr/reference/data-types/int-uint)
**Exemples**
**Exemple d’utilisation**
```sql title=Query theme={null}
WITH toDateTime64('2025-02-13 23:31:31.011123', 6, 'UTC') AS dt64
SELECT toUnixTimestamp64Micro(dt64);
```
```response title=Response theme={null}
┌─toUnixTimestamp64Micro(dt64)─┐
│ 1739489491011123 │
└────────────────────────────────┘
```
## toUnixTimestamp64Milli
Introduit dans : v20.5.0
Convertit un [`DateTime64`](/fr/reference/data-types/datetime64) en une valeur [`Int64`](/fr/reference/data-types/int-uint) avec une précision fixe à la milliseconde.
La valeur d'entrée est mise à l'échelle à la hausse ou à la baisse selon sa précision.
La valeur de sortie est relative à l'UTC, et non au fuseau horaire de la valeur d'entrée.
**Syntaxe**
```sql theme={null}
toUnixTimestamp64Milli(value)
```
**Arguments**
* `value` — Valeur DateTime64, quelle que soit sa précision. [`DateTime64`](/fr/reference/data-types/datetime64)
**Valeur renvoyée**
Renvoie un timestamp Unix en millisecondes. [`Int64`](/fr/reference/data-types/int-uint)
**Exemples**
**Exemple d'utilisation**
```sql title=Query theme={null}
WITH toDateTime64('2025-02-13 23:31:31.011', 3, 'UTC') AS dt64
SELECT toUnixTimestamp64Milli(dt64);
```
```response title=Response theme={null}
┌─toUnixTimestamp64Milli(dt64)─┐
│ 1739489491011 │
└──────────────────────────────┘
```
## toUnixTimestamp64Nano
Introduit dans : v20.5.0
Convertit un [`DateTime64`](/fr/reference/data-types/datetime64) en une valeur [`Int64`](/fr/reference/functions/regular-functions/type-conversion-functions#toInt64) avec une précision fixe en nanosecondes.
La valeur d'entrée est mise à l'échelle à la hausse ou à la baisse selon sa précision.
La valeur de sortie est relative à l'UTC, et non au fuseau horaire de la valeur d'entrée.
**Syntaxe**
```sql theme={null}
toUnixTimestamp64Nano(value)
```
**Arguments**
* `value` — Valeur `DateTime64` avec une précision quelconque. [`DateTime64`](/fr/reference/data-types/datetime64)
**Valeur renvoyée**
Renvoie un timestamp Unix en nanosecondes. [`Int64`](/fr/reference/data-types/int-uint)
**Exemples**
**Exemple d’utilisation**
```sql title=Query theme={null}
WITH toDateTime64('2025-02-13 23:31:31.011123456', 9, 'UTC') AS dt64
SELECT toUnixTimestamp64Nano(dt64);
```
```response title=Response theme={null}
┌─toUnixTimestamp64Nano(dt64)────┐
│ 1739489491011123456 │
└────────────────────────────────┘
```
## toUnixTimestamp64Second
Introduit dans : v24.12.0
Convertit un [`DateTime64`](/fr/reference/data-types/datetime64) en valeur [`Int64`](/fr/reference/data-types/int-uint) avec une précision fixe à la seconde.
La valeur d’entrée est mise à l’échelle vers le haut ou vers le bas selon sa précision.
La valeur de sortie est relative à l’UTC, et non au fuseau horaire de la valeur d’entrée.
**Syntaxe**
```sql theme={null}
toUnixTimestamp64Second(value)
```
**Arguments**
* `value` — Valeur DateTime64 avec une précision quelconque. [`DateTime64`](/fr/reference/data-types/datetime64)
**Valeur renvoyée**
Renvoie un timestamp Unix en secondes. [`Int64`](/fr/reference/data-types/int-uint)
**Exemples**
**Exemple d’utilisation**
```sql title=Query theme={null}
WITH toDateTime64('2025-02-13 23:31:31.011', 3, 'UTC') AS dt64
SELECT toUnixTimestamp64Second(dt64);
```
```response title=Response theme={null}
┌─toUnixTimestamp64Second(dt64)─┐
│ 1739489491 │
└───────────────────────────────┘
```