> ## Documentation Index
> Fetch the complete documentation index at: https://private-7c7dfe99-mintlify-8c05c8a2.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.
> Documentation des fonctions de manipulation de chaînes de caractères
# Fonctions de manipulation de chaînes de caractères
export const VersionBadge = ({minVersion}) =>
Disponible à partir de la version {minVersion}
;
Les fonctions de [recherche](/fr/reference/functions/regular-functions/string-search-functions) dans les chaînes et de [remplacement](/fr/reference/functions/regular-functions/string-replace-functions) dans les chaînes sont décrites séparément.
La documentation ci-dessous est générée à partir de la table système `system.functions`.
{/*AUTOGENERATED_START*/}
## CRC32
Introduit dans : v20.1.0
Calcule la somme de contrôle CRC32 d’une chaîne de caractères à l’aide du polynôme CRC-32-IEEE 802.3 et de la valeur initiale `0xffffffff` (implémentation zlib).
**Syntaxe**
```sql theme={null}
CRC32(s)
```
**Arguments**
* `s` — Chaîne `String` pour laquelle calculer le CRC32. [`String`](/fr/reference/data-types/string)
**Valeur renvoyée**
Renvoie la somme de contrôle CRC32 de la chaîne. [`UInt32`](/fr/reference/data-types/int-uint)
**Exemples**
**Exemple d'utilisation**
```sql title=Query theme={null}
SELECT CRC32('ClickHouse')
```
```response title=Response theme={null}
┌─CRC32('ClickHouse')─┐
│ 1538217360 │
└─────────────────────┘
```
## CRC32IEEE
Introduit dans : v20.1.0
Calcule la somme de contrôle CRC32 d’une chaîne de caractères à l’aide du polynôme CRC-32-IEEE 802.3.
**Syntaxe**
```sql theme={null}
CRC32IEEE(s)
```
**Arguments**
* `s` — Chaîne dont il faut calculer le CRC32. [`String`](/fr/reference/data-types/string)
**Valeur renvoyée**
Renvoie la somme de contrôle CRC32 de la chaîne. [`UInt32`](/fr/reference/data-types/int-uint)
**Exemples**
**Exemple d'utilisation**
```sql title=Query theme={null}
SELECT CRC32IEEE('ClickHouse');
```
```response title=Response theme={null}
┌─CRC32IEEE('ClickHouse')─┐
│ 3089448422 │
└─────────────────────────┘
```
## CRC64
Introduit dans : v20.1.0
Calcule la somme de contrôle CRC64 d’une chaîne de caractères à l’aide du polynôme CRC-64-ECMA.
**Syntaxe**
```sql theme={null}
CRC64(s)
```
**Arguments**
* `s` — Chaîne pour laquelle calculer la somme de contrôle CRC64. [`String`](/fr/reference/data-types/string)
**Valeur renvoyée**
Renvoie la somme de contrôle CRC64 de la chaîne. [`UInt64`](/fr/reference/data-types/int-uint)
**Exemples**
**Exemple d'utilisation**
```sql title=Query theme={null}
SELECT CRC64('ClickHouse');
```
```response title=Response theme={null}
┌──CRC64('ClickHouse')─┐
│ 12126588151325169346 │
└──────────────────────┘
```
## appendTrailingCharIfAbsent
Introduit dans : v1.1.0
Ajoute le caractère `c` à la chaîne `s` si `s` n’est pas vide et ne se termine pas par le caractère `c`.
**Syntaxe**
```sql theme={null}
appendTrailingCharIfAbsent(s, c)
```
**Arguments**
* `s` — Chaîne d’entrée. [`String`](/fr/reference/data-types/string)
* `c` — Caractère à ajouter s’il est absent. [`String`](/fr/reference/data-types/string)
**Valeur renvoyée**
Renvoie la chaîne `s` avec le caractère `c` ajouté si `s` ne se termine pas par `c`. [`String`](/fr/reference/data-types/string)
**Exemples**
**Exemple d’utilisation**
```sql title=Query theme={null}
SELECT appendTrailingCharIfAbsent('https://example.com', '/');
```
```response title=Response theme={null}
┌─appendTraili⋯.com', '/')─┐
│ https://example.com/ │
└──────────────────────────┘
```
## ascii
Introduit dans : v22.11.0
Renvoie le code ASCII du premier caractère de la chaîne `s`, sous la forme d’un `Int32`.
**Syntaxe**
```sql theme={null}
ascii(s)
```
**Arguments**
* `s` — Entrée de type String. [`String`](/fr/reference/data-types/string)
**Valeur renvoyée**
Renvoie le code ASCII du premier caractère. Si `s` est vide, le résultat est `0`. Si le premier caractère n'est pas un caractère ASCII ou n'appartient pas à la plage Latin-1 Supplement de l'UTF-16, le résultat n'est pas défini. [`Int32`](/fr/reference/data-types/int-uint)
**Exemples**
**Exemple d'utilisation**
```sql title=Query theme={null}
SELECT ascii('234')
```
```response title=Response theme={null}
┌─ascii('234')─┐
│ 50 │
└──────────────┘
```
## base32Decode
Introduit dans : v25.6.0
Décode une chaîne [Base32](https://datatracker.ietf.org/doc/html/rfc4648#section-6) (RFC 4648).
Si la chaîne n’est pas encodée en Base32 correctement, une exception est levée.
**Syntaxe**
```sql theme={null}
base32Decode(encoded)
```
**Arguments**
* `encoded` — Colonne de type String ou constante. [`String`](/fr/reference/data-types/string)
**Valeur renvoyée**
Renvoie une chaîne contenant la valeur décodée de l’argument. [`String`](/fr/reference/data-types/string)
**Exemples**
**Exemple d’utilisation**
```sql title=Query theme={null}
SELECT base32Decode('IVXGG33EMVSA====');
```
```response title=Response theme={null}
┌─base32Decode('IVXGG33EMVSA====')─┐
│ Encoded │
└──────────────────────────────────┘
```
## base32Encode
Introduit dans : v25.6.0
Encode une chaîne à l’aide de [Base32](https://datatracker.ietf.org/doc/html/rfc4648#section-6).
**Syntaxe**
```sql theme={null}
base32Encode(plaintext)
```
**Arguments**
* `plaintext` — Texte en clair à encoder. [`String`](/fr/reference/data-types/string)
**Valeur renvoyée**
Renvoie une chaîne contenant la valeur encodée de l’argument. [`String`](/fr/reference/data-types/string) ou [`FixedString`](/fr/reference/data-types/fixedstring)
**Exemples**
**Exemple d’utilisation**
```sql title=Query theme={null}
SELECT base32Encode('Encoded')
```
```response title=Response theme={null}
┌─base32Encode('Encoded')─┐
│ IVXGG33EMVSA==== │
└─────────────────────────┘
```
## base58Decode
Introduit dans : v22.7.0
Décode une chaîne [Base58](https://datatracker.ietf.org/doc/html/draft-msporny-base58-03#section-3).
Si la chaîne n’est pas encodée en Base58 de manière valide, une exception est levée.
Un second argument facultatif, `expected_size`, peut être fourni pour sélectionner un décodeur optimisé de taille fixe.
Les valeurs actuellement prises en charge sont 32 et 64. Pour toute autre valeur, le décodeur générique est utilisé.
Lorsque le décodeur optimisé est sélectionné, mais que l’entrée ne peut pas être décodée en un nombre d’octets correspondant exactement à cette taille,
la fonction lève une exception (ou renvoie une chaîne vide pour `tryBase58Decode`).
**Syntaxe**
```sql theme={null}
base58Decode(encoded[, expected_size])
```
**Arguments**
* `encoded` — Colonne ou constante de type String à décoder. [`String`](/fr/reference/data-types/string)
* `expected_size` — Facultatif. Taille décodée attendue en octets. Lorsqu’elle est de 32 ou 64, un décodeur optimisé est utilisé ; pour les autres valeurs, le décodeur générique est utilisé. [`UInt8, UInt16, UInt32, or UInt64`](/fr/reference/data-types/int-uint)
**Valeur renvoyée**
Renvoie une chaîne contenant la valeur décodée de l’argument. [`String`](/fr/reference/data-types/string)
**Exemples**
**Exemple d’utilisation**
```sql title=Query theme={null}
SELECT base58Decode('JxF12TrwUP45BMd');
```
```response title=Response theme={null}
┌─base58Decode⋯rwUP45BMd')─┐
│ Hello World │
└──────────────────────────┘
```
## base58Encode
Introduite dans : v22.7.0
Encode une chaîne en [Base58](https://tools.ietf.org/id/draft-msporny-base58-01.html).
**Syntaxe**
```sql theme={null}
base58Encode(plaintext)
```
**Arguments**
* `plaintext` — Texte en clair à encoder. [`String`](/fr/reference/data-types/string)
**Valeur renvoyée**
Renvoie une chaîne contenant la valeur encodée de l'argument. [`String`](/fr/reference/data-types/string)
**Exemples**
**Exemple d'utilisation**
```sql title=Query theme={null}
SELECT base58Encode('ClickHouse');
```
```response title=Response theme={null}
┌─base58Encode('ClickHouse')─┐
│ 4nhk8K7GHXf6zx │
└────────────────────────────┘
```
## base64Decode
Introduit dans : v18.16.0
Décode une chaîne à partir d’une représentation [Base64](https://en.wikipedia.org/wiki/Base64), conformément à la RFC 4648.
Lève une exception en cas d’erreur.
**Syntaxe**
```sql theme={null}
base64Decode(encoded)
```
**Alias** : `FROM_BASE64`
**Arguments**
* `encoded` — colonne ou constante de type String à décoder. Si la chaîne n’est pas encodée en Base64 de manière valide, une exception est levée. [`String`](/fr/reference/data-types/string)
**Valeur renvoyée**
Renvoie la chaîne décodée. [`String`](/fr/reference/data-types/string)
**Exemples**
**Exemple d’utilisation**
```sql title=Query theme={null}
SELECT base64Decode('Y2xpY2tob3VzZQ==')
```
```response title=Response theme={null}
┌─base64Decode('Y2xpY2tob3VzZQ==')─┐
│ clickhouse │
└──────────────────────────────────┘
```
## base64Encode
Introduit dans : v18.16.0
Encode une chaîne à l’aide de la représentation [Base64](https://en.wikipedia.org/wiki/Base64), conformément à la RFC 4648.
**Syntaxe**
```sql theme={null}
base64Encode(plaintext)
```
**alias** : `TO_BASE64`
**Arguments**
* `plaintext` — Colonne ou constante de texte en clair à décoder. [`String`](/fr/reference/data-types/string)
**Valeur renvoyée**
Renvoie une chaîne contenant la valeur encodée de l’argument. [`String`](/fr/reference/data-types/string)
**Exemples**
**Exemple d’utilisation**
```sql title=Query theme={null}
SELECT base64Encode('clickhouse')
```
```response title=Response theme={null}
┌─base64Encode('clickhouse')─┐
│ Y2xpY2tob3VzZQ== │
└────────────────────────────┘
```
## base64URLDecode
Introduit dans : v24.6.0
Décode une chaîne à partir d’une représentation [Base64](https://en.wikipedia.org/wiki/Base64) en utilisant un alphabet sûr pour les URL, conformément à la RFC 4648.
Lève une exception en cas d’erreur.
**Syntaxe**
```sql theme={null}
base64URLDecode(encoded)
```
**Arguments**
* `encoded` — Colonne String ou constante à encoder. Si la chaîne n'est pas une chaîne Base64 valide, une exception est levée. [`String`](/fr/reference/data-types/string)
**Valeur renvoyée**
Renvoie une chaîne contenant la valeur décodée de l'argument. [`String`](/fr/reference/data-types/string)
**Exemples**
**Exemple d'utilisation**
```sql title=Query theme={null}
SELECT base64URLDecode('aHR0cHM6Ly9jbGlja2hvdXNlLmNvbQ')
```
```response title=Response theme={null}
┌─base64URLDecode('aHR0cHM6Ly9jbGlja2hvdXNlLmNvbQ')─┐
│ https://clickhouse.com │
└───────────────────────────────────────────────────┘
```
## base64URLEncode
Introduit dans : v18.16.0
Encode une chaîne à l’aide de la représentation [Base64](https://datatracker.ietf.org/doc/html/rfc4648#section-4) (RFC 4648) en utilisant un alphabet compatible avec les URL.
**Syntaxe**
```sql theme={null}
base64URLEncode(plaintext)
```
**Arguments**
* `plaintext` — Colonne ou constante de texte en clair à encoder. [`String`](/fr/reference/data-types/string)
**Valeur renvoyée**
Renvoie une chaîne contenant la valeur encodée de l’argument. [`String`](/fr/reference/data-types/string)
**Exemples**
**Exemple d’utilisation**
```sql title=Query theme={null}
SELECT base64URLEncode('https://clickhouse.com')
```
```response title=Response theme={null}
┌─base64URLEncode('https://clickhouse.com')─┐
│ aHR0cHM6Ly9jbGlja2hvdXNlLmNvbQ │
└───────────────────────────────────────────┘
```
## basename
Introduit dans : v20.1.0
Extrait la partie finale d’une chaîne après sa dernière barre oblique (« / ») ou barre oblique inversée (« \ »).
Cette fonction est souvent utilisée pour extraire le nom de fichier d’un chemin.
**Syntaxe**
```sql theme={null}
basename(expr)
```
**Arguments**
* `expr` — Une expression de chaîne de caractères. Les antislashs doivent être échappés. [`String`](/fr/reference/data-types/string)
**Valeur renvoyée**
Renvoie la partie finale de la chaîne d’entrée après son dernier slash ou antislash. Si la chaîne d’entrée se termine par un slash ou un antislash, la fonction renvoie une chaîne vide. Renvoie la chaîne d’origine s’il n’y a ni slash ni antislash. [`String`](/fr/reference/data-types/string)
**Exemples**
**Extraire le nom du fichier à partir d’un chemin Unix**
```sql title=Query theme={null}
SELECT 'some/long/path/to/file' AS a, basename(a)
```
```response title=Response theme={null}
┌─a──────────────────────┬─basename('some/long/path/to/file')─┐
│ some/long/path/to/file │ file │
└────────────────────────┴────────────────────────────────────┘
```
**Extraire le nom du fichier depuis un chemin Windows**
```sql title=Query theme={null}
SELECT 'some\\long\\path\\to\\file' AS a, basename(a)
```
```response title=Response theme={null}
┌─a──────────────────────┬─basename('some\\long\\path\\to\\file')─┐
│ some\long\path\to\file │ file │
└────────────────────────┴────────────────────────────────────────┘
```
**Chaîne sans séparateur de chemin**
```sql title=Query theme={null}
SELECT 'some-file-name' AS a, basename(a)
```
```response title=Response theme={null}
┌─a──────────────┬─basename('some-file-name')─┐
│ some-file-name │ some-file-name │
└────────────────┴────────────────────────────┘
```
## byteHammingDistance
Introduit dans : v23.9.0
Calcule la [distance de Hamming](https://en.wikipedia.org/wiki/Hamming_distance) entre deux chaînes d’octets.
**Syntaxe**
```sql theme={null}
byteHammingDistance(s1, s2)
```
**Alias** : `mismatches`
**Arguments**
* `s1` — Première chaîne d’entrée. [`String`](/fr/reference/data-types/string)
* `s2` — Deuxième chaîne d’entrée. [`String`](/fr/reference/data-types/string)
**Valeur renvoyée**
Renvoie la distance de Hamming entre les deux chaînes. [`UInt64`](/fr/reference/data-types/int-uint)
**Exemples**
**Exemple d’utilisation**
```sql title=Query theme={null}
SELECT byteHammingDistance('karolin', 'kathrin')
```
```response title=Response theme={null}
┌─byteHammingDistance('karolin', 'kathrin')─┐
│ 3 │
└───────────────────────────────────────────┘
```
## caseFoldUTF8
Introduit dans : v26.3.0
Applique le repliement de casse Unicode à une chaîne UTF-8, en la convertissant en une forme normalisée proche des minuscules, adaptée aux comparaisons insensibles à la casse.
Applique le repliement de casse Unicode standard. Préserve les caractères de compatibilité qui ne sont pas affectés par le repliement de casse
(par ex. les chiffres romains, les chiffres encerclés), mais notez que certaines ligatures comme `ffi` sont tout de même décomposées, car le repliement de casse Unicode lui-même les étend.
**Syntaxe**
```sql theme={null}
caseFoldUTF8(str)
```
**Arguments**
* `str` — chaîne d'entrée encodée en UTF-8. [`String`](/fr/reference/data-types/string)
**Valeur renvoyée**
Chaîne UTF-8 après normalisation de la casse. [`String`](/fr/reference/data-types/string)
**Exemples**
**Normalisation de la casse de base**
```sql title=Query theme={null}
SELECT caseFoldUTF8('Straße')
```
```response title=Response theme={null}
┌─caseFoldUTF8('Straße')─┐
│ strasse │
└─────────────────────────┘
```
## compareSubstrings
Introduit dans : v25.2.0
Compare deux chaînes de caractères dans l’ordre lexicographique.
**Syntaxe**
```sql theme={null}
compareSubstrings(s1, s2, s1_offset, s2_offset, num_bytes)
```
**Arguments**
* `s1` — La première chaîne à comparer. [`String`](/fr/reference/data-types/string)
* `s2` — La deuxième chaîne à comparer. [`String`](/fr/reference/data-types/string)
* `s1_offset` — La position (à partir de zéro) dans `s1` à partir de laquelle la comparaison commence. [`UInt*`](/fr/reference/data-types/int-uint)
* `s2_offset` — La position (indice commençant à zéro) dans `s2` à partir de laquelle la comparaison commence. [`UInt*`](/fr/reference/data-types/int-uint)
* `num_bytes` — Le nombre maximal d’octets à comparer dans les deux chaînes. Si `s1_offset` (ou `s2_offset`) + `num_bytes` dépasse la fin d’une chaîne d’entrée, `num_bytes` est réduit en conséquence. [`UInt*`](/fr/reference/data-types/int-uint)
**Valeur renvoyée**
Renvoie :
* `-1` si `s1`\[`s1_offset` : `s1_offset` + `num_bytes`] \< `s2`\[`s2_offset` : `s2_offset` + `num_bytes`].
* `0` si `s1`\[`s1_offset` : `s1_offset` + `num_bytes`] = `s2`\[`s2_offset` : `s2_offset` + `num_bytes`].
* `1` si `s1`\[`s1_offset` : `s1_offset` + `num_bytes`] > `s2`\[`s2_offset` : `s2_offset` + `num_bytes`].
[`Int8`](/fr/reference/data-types/int-uint)
**Exemples**
**Exemple d’utilisation**
```sql title=Query theme={null}
SELECT compareSubstrings('Saxony', 'Anglo-Saxon', 0, 6, 5) AS result
```
```response title=Response theme={null}
┌─result─┐
│ 0 │
└────────┘
```
## concat
Introduit dans : v1.1.0
Concatène les arguments fournis.
Les arguments qui ne sont pas de type [`String`](/fr/reference/data-types/string) ou [`FixedString`](/fr/reference/data-types/fixedstring) sont convertis en chaînes de caractères à l’aide de leur sérialisation par défaut.
Comme cela dégrade les performances, il n’est pas recommandé d’utiliser des arguments autres que String/FixedString.
**Syntaxe**
```sql theme={null}
concat([s1, s2, ...])
```
**Arguments**
* `s1, s2, ...` — N’importe quel nombre de valeurs de n’importe quel type. [`Any`](/fr/reference/data-types/index)
**Valeur renvoyée**
Renvoie la String obtenue par concaténation des arguments. Si l’un des arguments est `NULL`, la fonction renvoie `NULL`. S’il n’y a aucun argument, elle renvoie une chaîne vide. [`Nullable(String)`](/fr/reference/data-types/nullable)
**Exemples**
**Concaténation de chaînes**
```sql title=Query theme={null}
SELECT concat('Hello, ', 'World!')
```
```response title=Response theme={null}
┌─concat('Hello, ', 'World!')─┐
│ Hello, World! │
└─────────────────────────────┘
```
**Concaténation de nombres**
```sql title=Query theme={null}
SELECT concat(42, 144)
```
```response title=Response theme={null}
┌─concat(42, 144)─┐
│ 42144 │
└─────────────────┘
```
## concatAssumeInjective
Introduit dans : v1.1.0
Comme [`concat`](#concat), mais en supposant que `concat(s1, s2, ...) → sn` est injective,
c'est-à-dire qu'elle renvoie des résultats différents pour des arguments différents.
Peut être utilisée pour optimiser `GROUP BY`.
**Syntaxe**
```sql theme={null}
concatAssumeInjective([s1, s2, ...])
```
**Arguments**
* `s1, s2, ...` — Un nombre quelconque de valeurs de type arbitraire. [`String`](/fr/reference/data-types/string) ou [`FixedString`](/fr/reference/data-types/fixedstring)
**Valeur renvoyée**
Renvoie la chaîne créée par concaténation des arguments. Si l'une des valeurs d'argument est `NULL`, la fonction renvoie `NULL`. Si aucun argument n'est transmis, elle renvoie une chaîne vide. [`String`](/fr/reference/data-types/string)
**Exemples**
**Optimisation du GROUP BY**
```sql title=Query theme={null}
SELECT concat(key1, key2), sum(value) FROM key_val GROUP BY concatAssumeInjective(key1, key2)
```
```response title=Response theme={null}
┌─concat(key1, key2)─┬─sum(value)─┐
│ Hello, World! │ 3 │
│ Hello, World! │ 2 │
│ Hello, World │ 3 │
└────────────────────┴────────────┘
```
## concatWithSeparator
Introduit dans : v22.12.0
Concatène les chaînes fournies en les séparant à l’aide du séparateur spécifié.
**Syntaxe**
```sql theme={null}
concatWithSeparator(sep[, exp1, exp2, ...])
```
**Alias** : `concat_ws`
**Arguments**
* `sep` — Le séparateur à utiliser. [`const String`](/fr/reference/data-types/string) ou [`const FixedString`](/fr/reference/data-types/fixedstring)
* `exp1, exp2, ...` — Expressions à concaténer. Les arguments dont le type n’est ni `String` ni `FixedString` sont convertis en chaînes à l’aide de leur sérialisation par défaut. Comme cela réduit les performances, il n’est pas recommandé d’utiliser des arguments autres que `String`/`FixedString`. [`Any`](/fr/reference/data-types/index)
**Valeur renvoyée**
Renvoie la chaîne obtenue en concaténant les arguments. Si l’une des valeurs d’argument est `NULL`, la fonction renvoie `NULL`. [`String`](/fr/reference/data-types/string)
**Exemples**
**Exemple d’utilisation**
```sql title=Query theme={null}
SELECT concatWithSeparator('a', '1', '2', '3', '4')
```
```response title=Response theme={null}
┌─concatWithSeparator('a', '1', '2', '3', '4')─┐
│ 1a2a3a4 │
└──────────────────────────────────────────────┘
```
## concatWithSeparatorAssumeInjective
Introduit dans : v22.12.0
Semblable à [`concatWithSeparator`](#concatWithSeparator), mais suppose que `concatWithSeparator(sep[,exp1, exp2, ... ]) → result` est injective.
Une fonction est dite injective si elle renvoie des résultats différents pour des arguments distincts.
Peut être utilisée pour optimiser `GROUP BY`.
**Syntaxe**
```sql theme={null}
concatWithSeparatorAssumeInjective(sep[, exp1, exp2, ... ])
```
**Arguments**
* `sep` — Le séparateur à utiliser. [`const String`](/fr/reference/data-types/string) ou [`const FixedString`](/fr/reference/data-types/fixedstring)
* `exp1, exp2, ...` — Expression à concaténer. Les arguments qui ne sont pas de type `String` ou `FixedString` sont convertis en chaînes à l'aide de leur sérialisation par défaut. Cela dégradant les performances, il est déconseillé d'utiliser des arguments autres que `String`/`FixedString`. [`String`](/fr/reference/data-types/string) ou [`FixedString`](/fr/reference/data-types/fixedstring)
**Valeur renvoyée**
Renvoie la `String` obtenue en concaténant les arguments. Si l'une des valeurs d'argument est `NULL`, la fonction renvoie `NULL`. [`String`](/fr/reference/data-types/string)
**Exemples**
**Exemple d'utilisation**
```sql title=Query theme={null}
CREATE TABLE user_data (
user_id UInt32,
first_name String,
last_name String,
score UInt32
)
ENGINE = MergeTree
ORDER BY tuple();
INSERT INTO user_data VALUES
(1, 'John', 'Doe', 100),
(2, 'Jane', 'Smith', 150),
(3, 'John', 'Wilson', 120),
(4, 'Jane', 'Smith', 90);
SELECT
concatWithSeparatorAssumeInjective('-', first_name, last_name) as full_name,
sum(score) as total_score
FROM user_data
GROUP BY concatWithSeparatorAssumeInjective('-', first_name, last_name);
```
```response title=Response theme={null}
┌─full_name───┬─total_score─┐
│ Jane-Smith │ 240 │
│ John-Doe │ 100 │
│ John-Wilson │ 120 │
└─────────────┴─────────────┘
```
## conv
Introduit dans : v25.10.0
Convertit des nombres d'une base à une autre.
La fonction convertit un nombre d'une base à une autre. Elle prend en charge les bases de 2 à 36.
Pour les bases supérieures à 10, les lettres A-Z (sans distinction de casse) sont utilisées pour représenter les chiffres de 10 à 35.
Cette fonction est compatible avec la fonction CONV() de MySQL.
**Syntaxe**
```sql theme={null}
conv(number, from_base, to_base)
```
**Arguments**
* `number` — Le nombre à convertir. Peut être une chaîne de caractères ou un type numérique. - `from_base` — La base d’origine (2-36). Doit être un entier. - `to_base` — La base cible (2-36). Doit être un entier.
**Valeur renvoyée**
Représentation sous forme de chaîne de caractères du nombre dans la base cible.
**Exemples**
**Convertir un nombre décimal en binaire**
```sql title=Query theme={null}
SELECT conv('10', 10, 2)
```
```response title=Response theme={null}
1010
```
**Convertir de l’hexadécimal en décimal**
```sql title=Query theme={null}
SELECT conv('FF', 16, 10)
```
```response title=Response theme={null}
255
```
**Conversion avec un nombre négatif**
```sql title=Query theme={null}
SELECT conv('-1', 10, 16)
```
```response title=Response theme={null}
FFFFFFFFFFFFFFFF
```
**Convertir du binaire en octal**
```sql title=Query theme={null}
SELECT conv('1010', 2, 8)
```
```response title=Response theme={null}
12
```
## convertCharset
Introduit dans : v1.1.0
Renvoie la chaîne `s` convertie de l’encodage `from` vers l’encodage `to`.
**Syntaxe**
```sql theme={null}
convertCharset(s, from, to)
```
**Arguments**
* `s` — Chaîne d’entrée. [`String`](/fr/reference/data-types/string)
* `from` — Encodage des caractères source. [`String`](/fr/reference/data-types/string)
* `to` — Encodage des caractères cible. [`String`](/fr/reference/data-types/string)
**Valeur renvoyée**
Renvoie la chaîne `s` convertie de l’encodage `from` vers l’encodage `to`. [`String`](/fr/reference/data-types/string)
**Exemples**
**Exemple d’utilisation**
```sql title=Query theme={null}
SELECT convertCharset('Café', 'UTF-8', 'ISO-8859-1');
```
```response title=Response theme={null}
┌─convertChars⋯SO-8859-1')─┐
│ Caf� │
└──────────────────────────┘
```
## damerauLevenshteinDistance
Introduit dans : v24.1.0
Calcule la [distance de Damerau-Levenshtein](https://en.wikipedia.org/wiki/Damerau%E2%80%93Levenshtein_distance) entre deux chaînes d’octets.
**Syntaxe**
```sql theme={null}
damerauLevenshteinDistance(s1, s2)
```
**Arguments**
* `s1` — Première chaîne d’entrée. [`String`](/fr/reference/data-types/string)
* `s2` — Deuxième chaîne d’entrée. [`String`](/fr/reference/data-types/string)
**Valeur renvoyée**
Renvoie la distance de Damerau-Levenshtein entre les deux chaînes. [`UInt64`](/fr/reference/data-types/int-uint)
**Exemples**
**Exemple d’utilisation**
```sql title=Query theme={null}
SELECT damerauLevenshteinDistance('clickhouse', 'mouse')
```
```response title=Response theme={null}
┌─damerauLevenshteinDistance('clickhouse', 'mouse')─┐
│ 6 │
└───────────────────────────────────────────────────┘
```
## decodeHTMLComponent
Introduit dans : v23.9.0
Décode les entités HTML d’une chaîne en caractères correspondants.
**Syntaxe**
```sql theme={null}
decodeHTMLComponent(s)
```
**Arguments**
* `s` — Chaîne contenant les entités HTML à décoder. [`String`](/fr/reference/data-types/string)
**Valeur renvoyée**
Renvoie la chaîne dont les entités HTML ont été décodées. [`String`](/fr/reference/data-types/string)
**Exemples**
**Exemple d'utilisation**
```sql title=Query theme={null}
SELECT decodeHTMLComponent('<div>Hello & "World"</div>')
```
```response title=Response theme={null}
┌─decodeHTMLComponent('<div>Hello & "World"</div>')─┐
│ Hello & "World"
│
└─────────────────────────────────────────────────────────────────────────────┘
```
## decodeXMLComponent
Introduit dans : v21.2.0
Décode les entités XML d’une chaîne en caractères correspondants.
**Syntaxe**
```sql theme={null}
decodeXMLComponent(s)
```
**Arguments**
* `s` — Chaîne contenant les entités XML à décoder. [`String`](/fr/reference/data-types/string)
**Valeur renvoyée**
Renvoie la chaîne fournie après décodage des entités XML. [`String`](/fr/reference/data-types/string)
**Exemples**
**Exemple d'utilisation**
```sql title=Query theme={null}
SELECT decodeXMLComponent('<tag>Hello & World</tag>')
```
```response title=Response theme={null}
┌─decodeXMLCom⋯;/tag>')─┐
│ Hello & World │
└──────────────────────────┘
```
## editDistance
Introduit dans : v23.9.0
Calcule la [distance d’édition](https://en.wikipedia.org/wiki/Edit_distance) entre deux chaînes d’octets.
**Syntaxe**
```sql theme={null}
editDistance(s1, s2)
```
**Alias** : `levenshteinDistance`
**Arguments**
* `s1` — Première chaîne d'entrée. [`String`](/fr/reference/data-types/string)
* `s2` — Deuxième chaîne d'entrée. [`String`](/fr/reference/data-types/string)
**Valeur renvoyée**
Renvoie la distance d'édition entre les deux chaînes. [`UInt64`](/fr/reference/data-types/int-uint)
**Exemples**
**Exemple d'utilisation**
```sql title=Query theme={null}
SELECT editDistance('clickhouse', 'mouse')
```
```response title=Response theme={null}
┌─editDistance('clickhouse', 'mouse')─┐
│ 6 │
└─────────────────────────────────────┘
```
## editDistanceUTF8
Disponible depuis : v24.6.0
Calcule la [distance d’édition](https://en.wikipedia.org/wiki/Edit_distance) entre deux chaînes UTF8.
**Syntaxe**
```sql theme={null}
editDistanceUTF8(s1, s2)
```
**Alias** : `levenshteinDistanceUTF8`
**Arguments**
* `s1` — Première chaîne d’entrée. [`String`](/fr/reference/data-types/string)
* `s2` — Deuxième chaîne d’entrée. [`String`](/fr/reference/data-types/string)
**Valeur renvoyée**
Renvoie la distance d’édition entre les deux chaînes UTF8. [`UInt64`](/fr/reference/data-types/int-uint)
**Exemples**
**Exemple d’utilisation**
```sql title=Query theme={null}
SELECT editDistanceUTF8('我是谁', '我是我')
```
```response title=Response theme={null}
┌─editDistanceUTF8('我是谁', '我是我')──┐
│ 1 │
└─────────────────────────────────────┘
```
## encodeXMLComponent
Introduit dans : v21.1.0
Échappe les caractères afin d’insérer une chaîne dans un nœud de texte XML ou un attribut.
**Syntaxe**
```sql theme={null}
encodeXMLComponent(s)
```
**Arguments**
* `s` — Chaîne à échapper. [`String`](/fr/reference/data-types/string)
**Valeur renvoyée**
Renvoie la chaîne échappée. [`String`](/fr/reference/data-types/string)
**Exemples**
**Exemple d’utilisation**
```sql title=Query theme={null}
SELECT
'Hello & "World"' AS original,
encodeXMLComponent('Hello & "World"') AS xml_encoded;
```
```response title=Response theme={null}
┌─original───────────────────┬─xml_encoded──────────────────────────────────────────┐
│ Hello & "World" │ <tag>Hello & "World"</tag> │
└────────────────────────────┴──────────────────────────────────────────────────────┘
```
## endsWith
Introduit dans : v1.1.0
Indique si une chaîne se termine par le suffixe fourni.
**Syntaxe**
```sql theme={null}
endsWith(s, suffix)
```
**Arguments**
* `s` — Chaîne à vérifier. [`String`](/fr/reference/data-types/string)
* `suffix` — Suffixe à rechercher. [`String`](/fr/reference/data-types/string)
**Valeur renvoyée**
Renvoie `1` si `s` se termine par `suffix`, sinon `0`. [`UInt8`](/fr/reference/data-types/int-uint)
**Exemples**
**Exemple d'utilisation**
```sql title=Query theme={null}
SELECT endsWith('ClickHouse', 'House');
```
```response title=Response theme={null}
┌─endsWith('Cl⋯', 'House')─┐
│ 1 │
└──────────────────────────┘
```
## endsWithCaseInsensitive
Introduit dans : v25.10.0
Vérifie si une chaîne se termine par le suffixe fourni, indépendamment de la casse.
**Syntaxe**
```sql theme={null}
endsWithCaseInsensitive(s, suffix)
```
**Arguments**
* `s` — Chaîne à vérifier. [`String`](/fr/reference/data-types/string)
* `suffix` — Suffixe à vérifier, sans tenir compte de la casse. [`String`](/fr/reference/data-types/string)
**Valeur renvoyée**
Renvoie `1` si `s` se termine par le `suffix` sans tenir compte de la casse, sinon `0`. [`UInt8`](/fr/reference/data-types/int-uint)
**Exemples**
**Exemple d'utilisation**
```sql title=Query theme={null}
SELECT endsWithCaseInsensitive('ClickHouse', 'HOUSE');
```
```response title=Response theme={null}
┌─endsWithCaseInsensitive('Cl⋯', 'HOUSE')─┐
│ 1 │
└─────────────────────────────────────────┘
```
## endsWithCaseInsensitiveUTF8
Introduit dans : v25.10.0
Renvoie si la chaîne `s` se termine par le `suffix` sans tenir compte de la casse.
Suppose que la chaîne contient du texte valide encodé en UTF-8.
Si cette hypothèse n'est pas respectée, aucune exception n'est levée et le résultat est indéfini.
**Syntaxe**
```sql theme={null}
endsWithCaseInsensitiveUTF8(s, suffix)
```
**Arguments**
* `s` — Chaîne à vérifier. [`String`](/fr/reference/data-types/string)
* `suffix` — Suffixe à vérifier, insensible à la casse. [`String`](/fr/reference/data-types/string)
**Valeur renvoyée**
Renvoie `1` si `s` se termine par le `suffix` sans tenir compte de la casse, sinon `0`. [`UInt8`](/fr/reference/data-types/int-uint)
**Exemples**
**Exemple d'utilisation**
```sql title=Query theme={null}
SELECT endsWithCaseInsensitiveUTF8('данных', 'ых');
```
```response title=Response theme={null}
┌─endsWithCaseInsensitiveUTF8('данных', 'ых')─┐
│ 1 │
└─────────────────────────────────────────────┘
```
## endsWithUTF8
Introduit dans : v23.8.0
Renvoie si la chaîne `s` se termine par `suffix`.
Suppose que la chaîne contient du texte valide encodé en UTF-8.
Si cette hypothèse est violée, aucune exception n'est levée et le résultat est indéfini.
**Syntaxe**
```sql theme={null}
endsWithUTF8(s, suffix)
```
**Arguments**
* `s` — Chaîne à vérifier. [`String`](/fr/reference/data-types/string)
* `suffix` — Suffixe à rechercher. [`String`](/fr/reference/data-types/string)
**Valeur renvoyée**
Renvoie `1` si `s` se termine par `suffix`, sinon `0`. [`UInt8`](/fr/reference/data-types/int-uint)
**Exemples**
**Exemple d’utilisation**
```sql title=Query theme={null}
SELECT endsWithUTF8('данных', 'ых');
```
```response title=Response theme={null}
┌─endsWithUTF8('данных', 'ых')─┐
│ 1 │
└──────────────────────────────┘
```
Introduit dans : v21.3.0
Extrait le contenu texte de documents HTML ou XHTML.
Cette fonction supprime les balises HTML, les commentaires ainsi que les éléments script/style, pour ne conserver que le contenu texte. Elle prend en charge :
* La suppression de toutes les balises HTML/XML
* La suppression des commentaires (`{/* */}`)
* La suppression des éléments script et style avec leur contenu
* Le traitement des sections CDATA (copiées telles quelles)
* La gestion correcte des espaces et leur normalisation
Remarque : les entités HTML ne sont pas décodées et doivent être traitées avec une fonction distincte si nécessaire.
**Syntaxe**
```sql theme={null}
extractTextFromHTML(html)
```
**Arguments**
* `html` — Chaîne contenant le code HTML à partir duquel extraire le texte. [`String`](/fr/reference/data-types/string)
**Valeur renvoyée**
Renvoie le contenu textuel extrait avec des espaces blancs normalisés. [`String`](/fr/reference/data-types/string)
**Exemples**
**Exemple d’utilisation**
```sql title=Query theme={null}
SELECT extractTextFromHTML('
Page Title
Hello World!
');
```
```response title=Response theme={null}
┌─extractTextFromHTML('...')─┐
│ Page Title Hello World! │
└────────────────────────────────────────┘
```
## firstLine
Introduit dans : v23.7.0
Renvoie la première ligne d’une chaîne multiligne.
**Syntaxe**
```sql theme={null}
firstLine(s)
```
**Arguments**
* `s` — Chaîne d'entrée. [`String`](/fr/reference/data-types/string)
**Valeur renvoyée**
Renvoie la première ligne de la chaîne d'entrée, ou la chaîne entière si elle ne contient aucun séparateur de ligne. [`String`](/fr/reference/data-types/string)
**Exemples**
**Exemple d'utilisation**
```sql title=Query theme={null}
SELECT firstLine('foo\\nbar\\nbaz')
```
```response title=Response theme={null}
┌─firstLine('foo\nbar\nbaz')─┐
│ foo │
└────────────────────────────┘
```
## idnaDecode
Introduit dans : v24.1.0
Renvoyer la représentation Unicode (UTF-8) (algorithme ToUnicode) d'un nom de domaine selon le mécanisme [Internationalized Domain Names in Applications](https://en.wikipedia.org/wiki/Internationalized_domain_name#Internationalizing_Domain_Names_in_Applications) (IDNA).
En cas d'erreur (par exemple si l'entrée n'est pas valide), la chaîne d'entrée est renvoyée.
Notez que l'application répétée de [`idnaEncode()`](#idnaEncode) et [`idnaDecode()`](#idnaDecode) ne renvoie pas nécessairement la chaîne d'origine en raison de la normalisation de la casse.
**Syntaxe**
```sql theme={null}
idnaDecode(s)
```
**Arguments**
* `s` — Chaîne d’entrée. [`String`](/fr/reference/data-types/string)
**Valeur renvoyée**
Renvoie une représentation Unicode (UTF-8) de la chaîne d’entrée, conformément au mécanisme IDNA appliqué à la valeur d’entrée. [`String`](/fr/reference/data-types/string)
**Exemples**
**Exemple d’utilisation**
```sql title=Query theme={null}
SELECT idnaDecode('xn--strae-oqa.xn--mnchen-3ya.de')
```
```response title=Response theme={null}
┌─idnaDecode('xn--strae-oqa.xn--mnchen-3ya.de')─┐
│ straße.münchen.de │
└───────────────────────────────────────────────┘
```
## idnaEncode
Introduit dans : v24.1.0
Renvoie la représentation ASCII (algorithme ToASCII) d'un nom de domaine conformément au mécanisme [Internationalized Domain Names in Applications](https://en.wikipedia.org/wiki/Internationalized_domain_name#Internationalizing_Domain_Names_in_Applications) (IDNA).
La chaîne d'entrée doit être encodée en UTF et pouvoir être convertie en chaîne ASCII, sinon une exception est levée.
Aucun décodage des pourcentages ni aucune suppression des tabulations, espaces ou caractères de contrôle n'est effectué.
**Syntaxe**
```sql theme={null}
idnaEncode(s)
```
**Arguments**
* `s` — Chaîne d’entrée. [`String`](/fr/reference/data-types/string)
**Valeur renvoyée**
Renvoie une représentation ASCII de la chaîne d’entrée conformément au mécanisme IDNA. [`String`](/fr/reference/data-types/string)
**Exemples**
**Exemple d’utilisation**
```sql title=Query theme={null}
SELECT idnaEncode('straße.münchen.de')
```
```response title=Response theme={null}
┌─idnaEncode('straße.münchen.de')─────┐
│ xn--strae-oqa.xn--mnchen-3ya.de │
└─────────────────────────────────────┘
```
## initcap
Introduit dans : v23.7.0
Convertit la première lettre de chaque mot en majuscule et les autres en minuscules.
Les mots sont des séquences de caractères alphanumériques séparées par des caractères non alphanumériques.
Comme `initcap` convertit uniquement la première lettre de chaque mot en majuscule, vous pouvez constater un comportement inattendu avec les mots contenant des apostrophes ou des lettres majuscules.
Il s'agit d'un comportement connu, et il n'est actuellement pas prévu de le corriger.
**Syntaxe**
```sql theme={null}
initcap(s)
```
**Arguments**
* `s` — Chaîne d’entrée. [`String`](/fr/reference/data-types/string)
**Valeur renvoyée**
Renvoie `s` avec la première lettre de chaque mot mise en majuscule. [`String`](/fr/reference/data-types/string)
**Exemples**
**Exemple d’utilisation**
```sql title=Query theme={null}
SELECT initcap('building for fast')
```
```response title=Response theme={null}
┌─initcap('building for fast')─┐
│ Building For Fast │
└──────────────────────────────┘
```
**Exemple de comportement connu pour les mots contenant des apostrophes ou des majuscules**
```sql title=Query theme={null}
SELECT initcap('John''s cat won''t eat.');
```
```response title=Response theme={null}
┌─initcap('Joh⋯n\'t eat.')─┐
│ John'S Cat Won'T Eat. │
└──────────────────────────┘
```
## initcapUTF8
Introduit dans : v23.7.0
Comme [`initcap`](#initcap), `initcapUTF8` convertit la première lettre de chaque mot en majuscule et le reste en minuscules.
Suppose que la chaîne contient un texte encodé en UTF-8 valide.
Si cette hypothèse n'est pas respectée, aucune exception n'est levée et le résultat n'est pas défini.
Cette fonction ne détecte pas la langue ; par exemple, pour le turc, le résultat peut ne pas être tout à fait correct (i/İ vs. i/I).
Si la longueur de la séquence d'octets UTF-8 diffère entre les formes en majuscules et en minuscules d'un point de code, le résultat peut être incorrect pour ce point de code.
**Syntaxe**
```sql theme={null}
initcapUTF8(s)
```
**Arguments**
* `s` — Chaîne d’entrée. [`String`](/fr/reference/data-types/string)
**Valeur renvoyée**
Renvoie `s` avec la première lettre de chaque mot en majuscule. [`String`](/fr/reference/data-types/string)
**Exemples**
**Exemple d’utilisation**
```sql title=Query theme={null}
SELECT initcapUTF8('не тормозит')
```
```response title=Response theme={null}
┌─initcapUTF8('не тормозит')─┐
│ Не Тормозит │
└────────────────────────────┘
```
## isValidASCII
Introduit dans : v25.9.0
Renvoie 1 si la String d’entrée ou la FixedString ne contient que des octets ASCII (0x00–0x7F), sinon 0. Optimisé pour le cas positif (la valeur d’entrée *est* un ASCII valide).
**Syntaxe**
```sql theme={null}
isValidASCII(str)
```
**Alias** : `isASCII`
**Arguments**
* Aucun.
**Valeur renvoyée**
**Exemples**
**isValidASCII**
```sql title=Query theme={null}
SELECT isValidASCII('hello') AS is_ascii, isValidASCII('你好') AS is_not_ascii
```
```response title=Response theme={null}
```
## isValidUTF8
Introduit dans : v20.1.0
Vérifie si la séquence d’octets constitue un texte valide encodé en UTF-8.
**Syntaxe**
```sql theme={null}
isValidUTF8(s)
```
**Arguments**
* `s` — La chaîne dont il faut vérifier la validité de l’encodage UTF-8. [`String`](/fr/reference/data-types/string)
**Valeur renvoyée**
Renvoie `1` si la suite d’octets constitue un texte valide encodé en UTF-8, sinon `0`. [`UInt8`](/fr/reference/data-types/int-uint)
**Exemples**
**Exemple d’utilisation**
```sql title=Query theme={null}
SELECT isValidUTF8('\\xc3\\xb1') AS valid, isValidUTF8('\\xc3\\x28') AS invalid
```
```response title=Response theme={null}
┌─valid─┬─invalid─┐
│ 1 │ 0 │
└───────┴─────────┘
```
## jaroSimilarity
Introduit dans : v24.1.0
Calcule la [similarité de Jaro](https://en.wikipedia.org/wiki/Jaro%E2%80%93Winkler_distance#Jaro_similarity) entre deux chaînes d’octets.
**Syntaxe**
```sql theme={null}
jaroSimilarity(s1, s2)
```
**Arguments**
* `s1` — Première chaîne d'entrée. [`String`](/fr/reference/data-types/string)
* `s2` — Deuxième chaîne d'entrée. [`String`](/fr/reference/data-types/string)
**Valeur renvoyée**
Renvoie le score de similarité de Jaro entre les deux chaînes. [`Float64`](/fr/reference/data-types/float)
**Exemples**
**Exemple d'utilisation**
```sql title=Query theme={null}
SELECT jaroSimilarity('clickhouse', 'click')
```
```response title=Response theme={null}
┌─jaroSimilarity('clickhouse', 'click')─┐
│ 0.8333333333333333 │
└───────────────────────────────────────┘
```
## jaroWinklerSimilarity
Introduit dans : v24.1.0
Calcule la [similarité de Jaro-Winkler](https://en.wikipedia.org/wiki/Jaro%E2%80%93Winkler_distance) entre deux chaînes d’octets.
**Syntaxe**
```sql theme={null}
jaroWinklerSimilarity(s1, s2)
```
**Arguments**
* `s1` — Première chaîne d’entrée. [`String`](/fr/reference/data-types/string)
* `s2` — Deuxième chaîne d’entrée. [`String`](/fr/reference/data-types/string)
**Valeur renvoyée**
Renvoie la similarité Jaro-Winkler entre les deux chaînes. [`Float64`](/fr/reference/data-types/float)
**Exemples**
**Exemple d'utilisation**
```sql title=Query theme={null}
SELECT jaroWinklerSimilarity('clickhouse', 'click')
```
```response title=Response theme={null}
┌─jaroWinklerSimilarity('clickhouse', 'click')─┐
│ 0.8999999999999999 │
└──────────────────────────────────────────────┘
```
## left
Introduite dans : v22.1.0
Renvoie une sous-chaîne de la chaîne `s` avec un `offset` spécifié, à partir de la gauche.
**Syntaxe**
```sql theme={null}
left(s, offset)
```
**Arguments**
* `s` — La chaîne dont extraire une sous-chaîne. [`String`](/fr/reference/data-types/string) ou [`FixedString`](/fr/reference/data-types/fixedstring)
* `offset` — Le nombre d’octets du décalage. [`(U)Int*`](/fr/reference/data-types/int-uint)
**Valeur renvoyée**
Renvoie :
* Pour un `offset` positif, une sous-chaîne de `s` de `offset` octets, à partir du début de la chaîne.
* Pour un `offset` négatif, une sous-chaîne de `s` de `length(s) - |offset|` octets, à partir du début de la chaîne.
* Une chaîne vide si `length` vaut `0`.
[`String`](/fr/reference/data-types/string)
**Exemples**
**Décalage positif**
```sql title=Query theme={null}
SELECT left('Hello World', 5)
```
```response title=Response theme={null}
Hello
```
**Offset négatif**
```sql title=Query theme={null}
SELECT left('Hello World', -6)
```
```response title=Response theme={null}
Hello
```
## leftPad
Introduit dans : v21.8.0
Complète une chaîne à gauche avec des espaces ou avec une chaîne spécifiée (répétée plusieurs fois si nécessaire) jusqu’à ce que la chaîne obtenue atteigne la `length` spécifiée.
**Syntaxe**
```sql theme={null}
leftPad(string, length[, pad_string])
```
**Alias** : `lpad`
**Arguments**
* `string` — Chaîne d'entrée à compléter. [`String`](/fr/reference/data-types/string)
* `length` — Longueur de la chaîne résultante. Si la valeur est inférieure à la longueur de la chaîne d'entrée, celle-ci est alors tronquée à `length` caractères. [`(U)Int*`](/fr/reference/data-types/int-uint)
* `pad_string` — Facultatif. Chaîne utilisée pour compléter la chaîne d'entrée. Si elle n'est pas spécifiée, la chaîne d'entrée est complétée avec des espaces. [`String`](/fr/reference/data-types/string)
**Valeur renvoyée**
Renvoie une chaîne complétée à gauche de la longueur indiquée. [`String`](/fr/reference/data-types/string)
**Exemples**
**Exemple d'utilisation**
```sql title=Query theme={null}
SELECT leftPad('abc', 7, '*'), leftPad('def', 7)
```
```response title=Response theme={null}
┌─leftPad('abc', 7, '*')─┬─leftPad('def', 7)─┐
│ ****abc │ def │
└────────────────────────┴───────────────────┘
```
## leftPadUTF8
Introduit dans : v21.8.0
Ajoute à gauche d’une chaîne UTF8 des espaces ou une chaîne spécifiée (répétée si nécessaire) jusqu’à ce que la chaîne obtenue atteigne la longueur indiquée.
Contrairement à [`leftPad`](#leftPad), qui mesure la longueur de la chaîne en octets, ici, la longueur de la chaîne est mesurée en points de code.
**Syntaxe**
```sql theme={null}
leftPadUTF8(string, length[, pad_string])
```
**Arguments**
* `string` — Chaîne d'entrée à remplir. [`String`](/fr/reference/data-types/string)
* `length` — Longueur de la chaîne obtenue. Si la valeur est inférieure à la longueur de la chaîne d'entrée, celle-ci est tronquée à `length` caractères. [`(U)Int*`](/fr/reference/data-types/int-uint)
* `pad_string` — Facultatif. Chaîne utilisée pour remplir la chaîne d'entrée. Si elle n'est pas spécifiée, la chaîne d'entrée est complétée avec des espaces. [`String`](/fr/reference/data-types/string)
**Valeur renvoyée**
Renvoie une chaîne complétée à gauche à la longueur indiquée. [`String`](/fr/reference/data-types/string)
**Exemples**
**Exemple d'utilisation**
```sql title=Query theme={null}
SELECT leftPadUTF8('абвг', 7, '*'), leftPadUTF8('дежз', 7)
```
```response title=Response theme={null}
┌─leftPadUTF8('абвг', 7, '*')─┬─leftPadUTF8('дежз', 7)─┐
│ ***абвг │ дежз │
└─────────────────────────────┴────────────────────────┘
```
## leftUTF8
Introduit dans : v22.1.0
Renvoie une sous-chaîne de la chaîne `s`, encodée en UTF-8, avec un `offset` spécifié à partir de la gauche.
**Syntaxe**
```sql theme={null}
leftUTF8(s, offset)
```
**Arguments**
* `s` — La chaîne encodée en UTF-8 dont extraire une sous-chaîne. [`String`](/fr/reference/data-types/string) ou [`FixedString`](/fr/reference/data-types/fixedstring)
* `offset` — Le décalage, en nombre d’octets. [`(U)Int*`](/fr/reference/data-types/int-uint)
**Valeur renvoyée**
Renvoie :
* Pour un `offset` positif, une sous-chaîne de `s` de `offset` octets, en partant de la gauche de la chaîne.\n"
* Pour un `offset` négatif, une sous-chaîne de `s` de `length(s) - |offset|` octets, en partant de la gauche de la chaîne.\n"
* Une chaîne vide si `length` vaut 0.
[`String`](/fr/reference/data-types/string)
**Exemples**
**Décalage positif**
```sql title=Query theme={null}
SELECT leftUTF8('Привет', 4)
```
```response title=Response theme={null}
Прив
```
**Offset négatif**
```sql title=Query theme={null}
SELECT leftUTF8('Привет', -4)
```
```response title=Response theme={null}
Пр
```
## lengthUTF8
Introduit dans : v1.1.0
Renvoie la longueur d'une chaîne en points de code Unicode plutôt qu'en octets ou en caractères.
Cette fonction suppose que la chaîne contient un texte valide encodé en UTF-8.
Si cette hypothèse n'est pas respectée, aucune exception n'est levée et le résultat n'est pas défini.
**Syntaxe**
```sql theme={null}
lengthUTF8(s)
```
**Alias** : `CHARACTER_LENGTH`, `CHAR_LENGTH`
**Arguments**
* `s` — String contenant du texte valide encodé en UTF-8. [`String`](/fr/reference/data-types/string)
**Valeur renvoyée**
Longueur de la chaîne `s` en points de code Unicode. [`UInt64`](/fr/reference/data-types/int-uint)
**Exemples**
**Exemple d'utilisation**
```sql title=Query theme={null}
SELECT lengthUTF8('Здравствуй, мир!')
```
```response title=Response theme={null}
┌─lengthUTF8('Здравствуй, мир!')─┐
│ 16 │
└────────────────────────────────┘
```
## lower
Introduit dans : v1.1.0
Convertit une chaîne ASCII en minuscules.
**Syntaxe**
```sql theme={null}
lower(s)
```
**Alias** : `lcase`
**Arguments**
* `s` — Une chaîne à convertir en minuscules. [`String`](/fr/reference/data-types/string)
**Valeur renvoyée**
Renvoie la chaîne `s` en minuscules. [`String`](/fr/reference/data-types/string)
**Exemples**
**Exemple d'utilisation**
```sql title=Query theme={null}
SELECT lower('CLICKHOUSE')
```
```response title=Response theme={null}
┌─lower('CLICKHOUSE')─┐
│ clickhouse │
└─────────────────────┘
```
## lowerUTF8
Introduit dans : v1.1.0
Convertit une chaîne en minuscules, en supposant qu’elle contient du texte valide encodé en UTF-8. Si cette hypothèse n’est pas respectée, aucune exception n’est levée et le résultat est indéfini.
**Syntaxe**
```sql theme={null}
lowerUTF8(input)
```
**Arguments**
* `input` — Chaîne d’entrée à convertir en minuscules. [`String`](/fr/reference/data-types/string)
**Valeur renvoyée**
Renvoie une chaîne en minuscules. [`String`](/fr/reference/data-types/string)
**Exemples**
**premier**
```sql title=Query theme={null}
SELECT lowerUTF8('München') as Lowerutf8;
```
```response title=Response theme={null}
münchen
```
## naturalSortKey
Introduit dans : v26.3.0
Cette fonction permet d’effectuer un tri naturel.
**Syntaxe**
```sql theme={null}
naturalSortKey(s)
```
**Alias** : `NATURAL_SORT_KEY`
**Arguments**
* `s` — Une chaîne à convertir en clé de tri naturel. [`String`](/fr/reference/data-types/string)
**Valeur renvoyée**
Renvoie la chaîne de clé de tri naturel obtenue à partir de `s`. [`String`](/fr/reference/data-types/string)
**Exemples**
**Exemple d'utilisation**
```sql title=Query theme={null}
SELECT s FROM t ORDER BY naturalSortKey(s)
```
```response title=Response theme={null}
┌─s───┐
│ a1 │
| a02 │
└─────┘
```
## normalizeUTF8NFC
Introduit dans : v21.11.0
Normalise une chaîne UTF-8 selon la [forme de normalisation NFC](https://en.wikipedia.org/wiki/Unicode_equivalence#Normal_forms).
**Syntaxe**
```sql theme={null}
normalizeUTF8NFC(str)
```
**Arguments**
* `str` — Chaîne d'entrée encodée en UTF-8. [`String`](/fr/reference/data-types/string)
**Valeur renvoyée**
Renvoie la forme normalisée NFC de la chaîne encodée en UTF-8. [`String`](/fr/reference/data-types/string)
**Exemples**
**Exemple d'utilisation**
```sql title=Query theme={null}
SELECT
'é' AS original, -- e + combining acute accent (U+0065 + U+0301)
length(original),
normalizeUTF8NFC('é') AS nfc_normalized, -- é (U+00E9)
length(nfc_normalized);
```
```response title=Response theme={null}
┌─original─┬─length(original)─┬─nfc_normalized─┬─length(nfc_normalized)─┐
│ é │ 2 │ é │ 2 │
└──────────┴──────────────────┴────────────────┴────────────────────────┘
```
## normalizeUTF8NFD
Introduit dans : v21.11.0
Normalise une chaîne UTF-8 conformément à la [forme de normalisation NFD](https://en.wikipedia.org/wiki/Unicode_equivalence#Normal_forms).
**Syntaxe**
```sql theme={null}
normalizeUTF8NFD(str)
```
**Arguments**
* `str` — chaîne d’entrée encodée en UTF-8. [`String`](/fr/reference/data-types/string)
**Valeur renvoyée**
Renvoie la forme normalisée NFD de la chaîne UTF-8. [`String`](/fr/reference/data-types/string)
**Exemples**
**Exemple d’utilisation**
```sql title=Query theme={null}
SELECT
'é' AS original, -- é (U+00E9)
length(original),
normalizeUTF8NFD('é') AS nfd_normalized, -- e + combining acute (U+0065 + U+0301)
length(nfd_normalized);
```
```response title=Response theme={null}
┌─original─┬─length(original)─┬─nfd_normalized─┬─length(nfd_normalized)─┐
│ é │ 2 │ é │ 3 │
└──────────┴──────────────────┴────────────────┴────────────────────────┘
```
## normalizeUTF8NFKC
Introduit dans : v21.11.0
Normalise une chaîne en UTF-8 selon la [forme de normalisation NFKC](https://en.wikipedia.org/wiki/Unicode_equivalence#Normal_forms).
**Syntaxe**
```sql theme={null}
normalizeUTF8NFKC(str)
```
**Arguments**
* `str` — Chaîne d’entrée encodée en UTF-8. [`String`](/fr/reference/data-types/string)
**Valeur renvoyée**
Renvoie la forme normalisée NFKC de la chaîne en UTF-8. [`String`](/fr/reference/data-types/string)
**Exemples**
**Exemple d’utilisation**
```sql title=Query theme={null}
SELECT
'① ② ③' AS original, -- Circled number characters
normalizeUTF8NFKC('① ② ③') AS nfkc_normalized; -- Converts to 1 2 3
```
```response title=Response theme={null}
┌─original─┬─nfkc_normalized─┐
│ ① ② ③ │ 1 2 3 │
└──────────┴─────────────────┘
```
## normalizeUTF8NFKCCasefold
Introduite dans : v26.3.0
Normalise une chaîne UTF-8 selon la [forme de normalisation NFKC\_Casefold](https://unicode.org/reports/tr44/#NFKC_Casefold), qui applique la normalisation NFKC puis le pliage de casse.
Ceci est utile pour la correspondance insensible à la casse des identifiants.
**Syntaxe**
```sql theme={null}
normalizeUTF8NFKCCasefold(str)
```
**Arguments**
* `str` — chaîne d’entrée encodée en UTF-8. [`String`](/fr/reference/data-types/string)
**Valeur renvoyée**
Renvoie la forme normalisée NFKC\_Casefold de la chaîne UTF-8. [`String`](/fr/reference/data-types/string)
**Exemples**
**Exemple d’utilisation**
```sql title=Query theme={null}
SELECT
'Ä ① Hello' AS original,
normalizeUTF8NFKCCasefold('Ä ① Hello') AS nfkc_cf_normalized;
```
```response title=Response theme={null}
┌─original───┬─nfkc_cf_normalized─┐
│ Ä ① Hello │ ä 1 hello │
└────────────┴────────────────────┘
```
## normalizeUTF8NFKD
Introduit dans : v21.11.0
Normalise une chaîne UTF-8 conformément à la [forme de normalisation NFKD](https://en.wikipedia.org/wiki/Unicode_equivalence#Normal_forms).
**Syntaxe**
```sql theme={null}
normalizeUTF8NFKD(str)
```
**Arguments**
* `str` — chaîne d’entrée encodée en UTF-8. [`String`](/fr/reference/data-types/string)
**Valeur renvoyée**
Renvoie la forme normalisée NFKD de la chaîne UTF-8. [`String`](/fr/reference/data-types/string)
**Exemples**
**Exemple d’utilisation**
```sql title=Query theme={null}
SELECT
'H₂O²' AS original, -- H + subscript 2 + O + superscript 2
normalizeUTF8NFKD('H₂O²') AS nfkd_normalized; -- Converts to H 2 O 2
```
```response title=Response theme={null}
┌─original─┬─nfkd_normalized─┐
│ H₂O² │ H2O2 │
└──────────┴─────────────────┘
```
## punycodeDecode
Introduite dans : v24.1.0
Renvoie le texte en clair encodé en UTF8 d’une chaîne encodée en [Punycode](https://en.wikipedia.org/wiki/Punycode).
Si la chaîne fournie n’est pas une chaîne encodée en Punycode valide, une exception est levée.
**Syntaxe**
```sql theme={null}
punycodeDecode(s)
```
**Arguments**
* `s` — Chaîne encodée en Punycode. [`String`](/fr/reference/data-types/string)
**Valeur renvoyée**
Renvoie le texte en clair de la valeur d’entrée. [`String`](/fr/reference/data-types/string)
**Exemples**
**Exemple d’utilisation**
```sql title=Query theme={null}
SELECT punycodeDecode('Mnchen-3ya')
```
```response title=Response theme={null}
┌─punycodeDecode('Mnchen-3ya')─┐
│ München │
└──────────────────────────────┘
```
## punycodeEncode
Introduit dans : v24.1.0
Renvoie la représentation en [Punycode](https://en.wikipedia.org/wiki/Punycode) d’une chaîne.
La chaîne doit être encodée en UTF8, sinon le comportement est indéfini.
**Syntaxe**
```sql theme={null}
punycodeEncode(s)
```
**Arguments**
* `s` — Valeur d’entrée. [`String`](/fr/reference/data-types/string)
**Valeur renvoyée**
Renvoie une représentation en Punycode de la valeur d’entrée. [`String`](/fr/reference/data-types/string)
**Exemples**
**Exemple d’utilisation**
```sql title=Query theme={null}
SELECT punycodeEncode('München')
```
```response title=Response theme={null}
┌─punycodeEncode('München')─┐
│ Mnchen-3ya │
└───────────────────────────┘
```
Introduit dans : v23.2.0
Extrait la première chaîne de `haystack` qui correspond au motif regexp et à l’indice du groupe regex.
**Syntaxe**
```sql theme={null}
regexpExtract(haystack, pattern[, index])
```
**Alias** : `REGEXP_EXTRACT`, `REGEXP_SUBSTR`
**Arguments**
* `haystack` — String dans laquelle le motif regexp sera recherché. [`String`](/fr/reference/data-types/string)
* `pattern` — String, expression régulière. `pattern` peut contenir plusieurs groupes regexp ; `index` indique quel groupe regex extraire. Un index de `0` signifie que l’expression régulière entière est extraite. [`const String`](/fr/reference/data-types/string)
* `index` — Facultatif. Un entier non négatif indiquant quel groupe regex extraire. La valeur par défaut est `1` si `pattern` contient au moins un groupe de capture, et `0` (la correspondance complète) si `pattern` ne contient aucun groupe de capture. [`(U)Int*`](/fr/reference/data-types/int-uint)
**Valeur renvoyée**
Renvoie une chaîne correspondant au motif [`String`](/fr/reference/data-types/string)
**Exemples**
**Exemple d’utilisation**
```sql title=Query theme={null}
SELECT
regexpExtract('100-200', '(\\d+)-(\\d+)', 1),
regexpExtract('100-200', '(\\d+)-(\\d+)', 2),
regexpExtract('100-200', '(\\d+)-(\\d+)', 0),
regexpExtract('100-200', '(\\d+)-(\\d+)'),
regexpExtract('100-200', '\\d+');
```
```response title=Response theme={null}
┌─regexpExtract('100-200', '(\\d+)-(\\d+)', 1)─┬─regexpExtract('100-200', '(\\d+)-(\\d+)', 2)─┬─regexpExtract('100-200', '(\\d+)-(\\d+)', 0)─┬─regexpExtract('100-200', '(\\d+)-(\\d+)')─┬─regexpExtract('100-200', '\\d+')─┐
│ 100 │ 200 │ 100-200 │ 100 │ 100 │
└──────────────────────────────────────────────┴──────────────────────────────────────────────┴──────────────────────────────────────────────┴───────────────────────────────────────────┴──────────────────────────────────┘
```
## regexpPosition
Introduit dans : v26.5.0
Renvoie la position en octets (à partir de 1) de la `occurrence`-ième correspondance de `pattern` dans `haystack`, en commençant la recherche à la position en octets `position`.
Si `return_option` vaut 0 (par défaut), la position du premier octet de la correspondance est renvoyée. Si `return_option` vaut 1, la position du premier octet *après* la correspondance est renvoyée.
Si `subexpression` est supérieur à 0, la position du groupe de capture correspondant est renvoyée à la place de celle de la correspondance entière.
Renvoie 0 si aucune correspondance n'est trouvée, ou si le groupe de capture demandé n'a pas participé à la correspondance.
Cette fonction est fournie pour assurer la compatibilité avec `regexp_instr` de PostgreSQL (également exposé sous cet alias). Notez que les positions sont exprimées en octets, conformément aux autres fonctions Regex de ClickHouse ; `regexp_instr` de PostgreSQL est basé sur les caractères.
**Syntaxe**
```sql theme={null}
regexpPosition(haystack, pattern[, position[, occurrence[, return_option[, flags[, subexpression]]]]])
```
**Aliases** : `regexpInstr`, `regexp_instr`
**Arguments**
* `haystack` — Chaîne dans laquelle effectuer la recherche. [`String`](/fr/reference/data-types/string)
* `pattern` — Motif d'expression régulière. [`const String`](/fr/reference/data-types/string)
* `position` — Facultatif. Position en octets, indexée à partir de 1, à partir de laquelle commencer la recherche. Par défaut : 1. [`(U)Int*`](/fr/reference/data-types/int-uint)
* `occurrence` — Facultatif. Occurrence à renvoyer. Par défaut : 1. [`(U)Int*`](/fr/reference/data-types/int-uint)
* `return_option` — Facultatif. 0 renvoie la position du début de la correspondance, 1 renvoie la position immédiatement après la correspondance. Par défaut : 0. [`(U)Int*`](/fr/reference/data-types/int-uint)
* `flags` — Facultatif. Indicateurs Regex. Pris en charge : `i` (insensible à la casse), `c` (sensible à la casse), `m`/`n` (ancres multiligne), `s` (le point correspond à un saut de ligne). Par défaut : vide. [`const String`](/fr/reference/data-types/string)
* `subexpression` — Facultatif. Indice du groupe de capture dont la position doit être renvoyée. 0 signifie la correspondance entière. Par défaut : 0. [`(U)Int*`](/fr/reference/data-types/int-uint)
**Valeur renvoyée**
Renvoie la position en octets de la correspondance, ou 0 si aucune correspondance n’est trouvée. [`UInt64`](/fr/reference/data-types/int-uint)
**Exemples**
**Utilisation de base**
```sql title=Query theme={null}
SELECT
regexpPosition('hello world', 'world'),
regexpPosition('aXbXcXd', 'X', 1, 2),
regexpPosition('aXbXcXd', 'X', 1, 2, 1),
regexpPosition('Hello WORLD', 'world', 1, 1, 0, 'i'),
regexpPosition('foo123bar456', '([a-z]+)([0-9]+)', 1, 2, 0, '', 2);
```
```response title=Response theme={null}
┌─...─┬─...─┬─...─┬─...─┬─...─┐
│ 7 │ 4 │ 5 │ 7 │ 10 │
└─────┴─────┴─────┴─────┴─────┘
```
## removeDiacriticsUTF8
Introduit dans : v26.3.0
Supprime les signes diacritiques (accents) d’une chaîne UTF-8 en décomposant les caractères via NFD,
en supprimant les marques combinatoires (catégorie Unicode Mn), puis en les recomposant via NFC.
**Syntaxe**
```sql theme={null}
removeDiacriticsUTF8(str)
```
**Alias**: `removeAccentsUTF8`
**Arguments**
* `str` — Chaîne d'entrée encodée en UTF-8. [`String`](/fr/reference/data-types/string)
**Valeur renvoyée**
Chaîne UTF-8 sans diacritiques. [`String`](/fr/reference/data-types/string)
**Exemples**
**Suppression simple des accents**
```sql title=Query theme={null}
SELECT removeDiacriticsUTF8('café résumé naïve')
```
```response title=Response theme={null}
┌─removeDiacriticsUTF8('café résumé naïve')─┐
│ cafe resume naive │
└────────────────────────────────────────────┘
```
## repeat
Introduit dans : v20.1.0
Concatène une chaîne avec elle-même autant de fois que spécifié.
**Syntaxe**
```sql theme={null}
repeat(s, n)
```
**Arguments**
* `s` — La chaîne à répéter. [`String`](/fr/reference/data-types/string)
* `n` — Le nombre de répétitions de la chaîne. [`(U)Int*`](/fr/reference/data-types/int-uint)
**Valeur renvoyée**
Une chaîne contenant `s` répété `n` fois. Si `n` est négatif, la fonction renvoie une chaîne vide. [`String`](/fr/reference/data-types/string)
**Exemples**
**Exemple d'utilisation**
```sql title=Query theme={null}
SELECT repeat('abc', 10)
```
```response title=Response theme={null}
┌─repeat('abc', 10)──────────────┐
│ abcabcabcabcabcabcabcabcabcabc │
└────────────────────────────────┘
```
## reverseUTF8
Introduit dans : v1.1.0
Inverse une séquence de points de code Unicode dans une chaîne.
Suppose que la chaîne contient du texte encodé en UTF-8 valide.
Si cette hypothèse n'est pas respectée, aucune exception n'est levée et le résultat est indéfini.
**Syntaxe**
```sql theme={null}
reverseUTF8(s)
```
**Arguments**
* `s` — Chaîne contenant du texte valide encodé en UTF-8. [`String`](/fr/reference/data-types/string)
**Valeur renvoyée**
Renvoie une chaîne dont la séquence de points de code Unicode est inversée. [`String`](/fr/reference/data-types/string)
**Exemples**
**Exemple d'utilisation**
```sql title=Query theme={null}
SELECT reverseUTF8('ClickHouse')
```
```response title=Response theme={null}
esuoHkcilC
```
## right
Introduit dans : v22.1.0
Renvoie une sous-chaîne de la chaîne `s` avec l’`offset` spécifié, en partant de la droite.
**Syntaxe**
```sql theme={null}
right(s, offset)
```
**Arguments**
* `s` — La chaîne dont il faut extraire une sous-chaîne. [`String`](/fr/reference/data-types/string) ou [`FixedString`](/fr/reference/data-types/fixedstring)
* `offset` — Le décalage, exprimé en nombre d’octets. [`(U)Int*`](/fr/reference/data-types/int-uint)
**Valeur renvoyée**
Renvoie :
* Pour un `offset` positif, une sous-chaîne de `s` de `offset` octets, en partant de la droite de la chaîne.
* Pour un `offset` négatif, une sous-chaîne de `s` de `length(s) - |offset|` octets, en partant de la droite de la chaîne.
* Une chaîne vide si `length` vaut `0`.
[`String`](/fr/reference/data-types/string)
**Exemples**
**Décalage positif**
```sql title=Query theme={null}
SELECT right('Hello', 3)
```
```response title=Response theme={null}
llo
```
**Décalage négatif**
```sql title=Query theme={null}
SELECT right('Hello', -3)
```
```response title=Response theme={null}
lo
```
## rightPad
Introduit dans : v21.8.0
Ajoute des espaces ou une chaîne spécifiée à droite d’une chaîne (à plusieurs reprises si nécessaire) jusqu’à ce que la chaîne obtenue atteigne la `length` spécifiée.
**Syntaxe**
```sql theme={null}
rightPad(string, length[, pad_string])
```
**Alias** : `rpad`
**Arguments**
* `string` — Chaîne d’entrée à compléter. [`String`](/fr/reference/data-types/string)
* `length` — Longueur de la chaîne obtenue. Si la valeur est inférieure à la longueur de la chaîne d’entrée, celle-ci est tronquée à `length` caractères. [`(U)Int*`](/fr/reference/data-types/int-uint)
* `pad_string` — Facultatif. Chaîne utilisée pour compléter la chaîne d’entrée. Si elle n’est pas spécifiée, la chaîne d’entrée est complétée avec des espaces. [`String`](/fr/reference/data-types/string)
**Valeur renvoyée**
Renvoie une chaîne complétée à droite de la longueur spécifiée. [`String`](/fr/reference/data-types/string)
**Exemples**
**Exemple d’utilisation**
```sql title=Query theme={null}
SELECT rightPad('abc', 7, '*'), rightPad('abc', 7)
```
```response title=Response theme={null}
┌─rightPad('abc', 7, '*')─┬─rightPad('abc', 7)─┐
│ abc**** │ abc │
└─────────────────────────┴────────────────────┘
```
## rightPadUTF8
Introduit dans : v21.8.0
Ajoute à droite de la chaîne des espaces ou une chaîne spécifiée (répétée plusieurs fois si nécessaire) jusqu'à ce que la chaîne obtenue atteigne la longueur indiquée.
Contrairement à [`rightPad`](#rightPad), qui mesure la longueur de la chaîne en octets, ici la longueur de la chaîne est mesurée en points de code.
**Syntaxe**
```sql theme={null}
rightPadUTF8(string, length[, pad_string])
```
**Arguments**
* `string` — Chaîne d’entrée à compléter. [`String`](/fr/reference/data-types/string)
* `length` — Longueur de la chaîne résultante. Si cette valeur est inférieure à la longueur de la chaîne d’entrée, celle-ci est tronquée à `length` caractères. [`(U)Int*`](/fr/reference/data-types/int-uint)
* `pad_string` — Facultatif. Chaîne utilisée pour compléter la chaîne d’entrée. Si elle n’est pas spécifiée, la chaîne d’entrée est complétée avec des espaces. [`String`](/fr/reference/data-types/string)
**Valeur renvoyée**
Renvoie une chaîne complétée à droite jusqu’à la longueur indiquée. [`String`](/fr/reference/data-types/string)
**Exemples**
**Exemple d’utilisation**
```sql title=Query theme={null}
SELECT rightPadUTF8('абвг', 7, '*'), rightPadUTF8('абвг', 7)
```
```response title=Response theme={null}
┌─rightPadUTF8('абвг', 7, '*')─┬─rightPadUTF8('абвг', 7)─┐
│ абвг*** │ абвг │
└──────────────────────────────┴─────────────────────────┘
```
## rightUTF8
Introduit dans : v22.1.0
Renvoie une sous-chaîne de la chaîne `s` encodée en UTF-8 avec un `offset` spécifié en partant de la droite.
**Syntaxe**
```sql theme={null}
rightUTF8(s, offset)
```
**Arguments**
* `s` — La chaîne encodée en UTF-8 dont il faut calculer une sous-chaîne. [`String`](/fr/reference/data-types/string) ou [`FixedString`](/fr/reference/data-types/fixedstring)
* `offset` — Le décalage, en nombre d’octets. [`(U)Int*`](/fr/reference/data-types/int-uint)
**Valeur renvoyée**
Renvoie :
* Pour un `offset` positif, une sous-chaîne de `s` de `offset` octets, en partant de la droite de la chaîne.
* Pour un `offset` négatif, une sous-chaîne de `s` de `length(s) - |offset|` octets, en partant de la droite de la chaîne.
* Une chaîne vide si `length` vaut `0`.
[`String`](/fr/reference/data-types/string)
**Exemples**
**Décalage positif**
```sql title=Query theme={null}
SELECT rightUTF8('Привет', 4)
```
```response title=Response theme={null}
ивет
```
**OFFSET négatif**
```sql title=Query theme={null}
SELECT rightUTF8('Привет', -4)
```
```response title=Response theme={null}
ет
```
## soundex
Introduit dans : v23.4.0
Renvoie le [code Soundex](https://en.wikipedia.org/wiki/Soundex) d’une chaîne de caractères.
**Syntaxe**
```sql theme={null}
soundex(s)
```
**Arguments**
* `s` — Chaîne d’entrée. [`String`](/fr/reference/data-types/string)
**Valeur renvoyée**
Renvoie le code Soundex de la chaîne d’entrée. [`String`](/fr/reference/data-types/string)
**Exemples**
**Exemple d’utilisation**
```sql title=Query theme={null}
SELECT soundex('aksel')
```
```response title=Response theme={null}
┌─soundex('aksel')─┐
│ A240 │
└──────────────────┘
```
## space
Introduite dans : v23.5.0
Concatène un espace (` `) avec lui-même autant de fois que spécifié.
**Syntaxe**
```sql theme={null}
space(n)
```
**Arguments**
* `n` — Le nombre de répétitions de l’espace. [`(U)Int*`](/fr/reference/data-types/int-uint)
**Valeur renvoyée**
Renvoie une chaîne contenant un espace répété `n` fois. Si `n <= 0`, la fonction renvoie une chaîne vide. [`String`](/fr/reference/data-types/string)
**Exemples**
**Exemple d’utilisation**
```sql title=Query theme={null}
SELECT space(3) AS res, length(res);
```
```response title=Response theme={null}
┌─res─┬─length(res)─┐
│ │ 3 │
└─────┴─────────────┘
```
## sparseGrams
Introduit dans : v25.5.0
Trouve toutes les sous-chaînes d'une chaîne donnée dont la longueur est d'au moins `n`,
où les hachages des (n-1)-grammes aux extrémités de la sous-chaîne
sont strictement supérieurs à ceux de tout (n-1)-gramme situé à l'intérieur de la sous-chaîne.
Utilise `CRC32` comme fonction de hachage.
**Syntaxe**
```sql theme={null}
sparseGrams(s[, min_ngram_length[, max_ngram_length[, min_cutoff_length]]])
```
**Arguments**
* `s` — Une chaîne en entrée. [`String`](/fr/reference/data-types/string)
* `min_ngram_length` — Facultatif. Longueur minimale du n-gramme extrait. La valeur par défaut et la valeur minimale sont de 3. [`UInt*`](/fr/reference/data-types/int-uint)
* `max_ngram_length` — Facultatif. Longueur maximale du n-gramme extrait. La valeur par défaut est de 100. Elle ne doit pas être inférieure à `min_ngram_length`. [`UInt*`](/fr/reference/data-types/int-uint)
* `min_cutoff_length` — Facultatif. Si ce paramètre est spécifié, seuls les n-grammes d’une longueur supérieure ou égale à `min_cutoff_length` sont renvoyés. La valeur par défaut est la même que `min_ngram_length`. Elle ne doit pas être inférieure à `min_ngram_length` ni supérieure à `max_ngram_length`. [`UInt*`](/fr/reference/data-types/int-uint)
**Valeur renvoyée**
Renvoie un tableau de sous-chaînes sélectionnées. [`Array(String)`](/fr/reference/data-types/array)
**Exemples**
**Exemple d’utilisation**
```sql title=Query theme={null}
SELECT sparseGrams('alice', 3)
```
```response title=Response theme={null}
┌─sparseGrams('alice', 3)────────────┐
│ ['ali','lic','lice','ice'] │
└────────────────────────────────────┘
```
## sparseGramsHashes
Introduit dans : v25.5.0
Trouve les hachages de toutes les sous-chaînes d'une chaîne donnée d'une longueur d'au moins `n`,
pour lesquelles les hachages des n-grammes de longueur (n-1) situés aux extrémités de la sous-chaîne
sont strictement supérieurs à ceux de tous les n-grammes de longueur (n-1) qu'elle contient.
Utilise `CRC32` comme fonction de hachage.
**Syntaxe**
```sql theme={null}
sparseGramsHashes(s[, min_ngram_length, max_ngram_length])
```
**Arguments**
* `s` — Une chaîne d’entrée. [`String`](/fr/reference/data-types/string)
* `min_ngram_length` — Facultatif. Longueur minimale du n-gramme extrait. La valeur par défaut, qui est aussi la valeur minimale, est 3. [`UInt*`](/fr/reference/data-types/int-uint)
* `max_ngram_length` — Facultatif. Longueur maximale du n-gramme extrait. La valeur par défaut est 100. Doit être supérieure ou égale à `min_ngram_length`. [`UInt*`](/fr/reference/data-types/int-uint)
* `min_cutoff_length` — Facultatif. Si ce paramètre est spécifié, seuls les n-grammes dont la longueur est supérieure ou égale à `min_cutoff_length` sont renvoyés. La valeur par défaut est la même que `min_ngram_length`. Doit être supérieure ou égale à `min_ngram_length` et inférieure ou égale à `max_ngram_length`. [`UInt*`](/fr/reference/data-types/int-uint)
**Valeur renvoyée**
Renvoie un tableau de hachages CRC32 des sous-chaînes sélectionnées. [`Array(UInt32)`](/fr/reference/data-types/array)
**Exemples**
**Exemple d'utilisation**
```sql title=Query theme={null}
SELECT sparseGramsHashes('alice', 3)
```
```response title=Response theme={null}
┌─sparseGramsHashes('alice', 3)──────────────────────┐
│ [1481062250,2450405249,4012725991,1918774096] │
└────────────────────────────────────────────────────┘
```
## sparseGramsHashesUTF8
Introduit dans : v25.5.0
Trouve les hachages de toutes les sous-chaînes d’une chaîne UTF-8 donnée dont la longueur est d’au moins `n`, lorsque les hachages des n-grammes de longueur (n-1) situés aux extrémités de la sous-chaîne sont strictement supérieurs à ceux de tout n-gramme de longueur (n-1) à l’intérieur de la sous-chaîne.
Attend une chaîne UTF-8 et lève une exception en cas de séquence UTF-8 non valide.
Utilise `CRC32` comme fonction de hachage.
**Syntaxe**
```sql theme={null}
sparseGramsHashesUTF8(s[, min_ngram_length, max_ngram_length])
```
**Arguments**
* `s` — Une chaîne d’entrée. [`String`](/fr/reference/data-types/string)
* `min_ngram_length` — Facultatif. Longueur minimale du n-gramme extrait. La valeur par défaut, qui est aussi la valeur minimale, est 3. [`UInt*`](/fr/reference/data-types/int-uint)
* `max_ngram_length` — Facultatif. Longueur maximale du n-gramme extrait. La valeur par défaut est 100. Ne doit pas être inférieure à `min_ngram_length`. [`UInt*`](/fr/reference/data-types/int-uint)
* `min_cutoff_length` — Facultatif. Si cette valeur est spécifiée, seuls les n-grammes dont la longueur est supérieure ou égale à `min_cutoff_length` sont renvoyés. La valeur par défaut est la même que `min_ngram_length`. Ne doit pas être inférieure à `min_ngram_length` ni supérieure à `max_ngram_length`. [`UInt*`](/fr/reference/data-types/int-uint)
**Valeur renvoyée**
Renvoie un tableau de hachages CRC32 des sous-chaînes UTF-8 sélectionnées. [`Array(UInt32)`](/fr/reference/data-types/array)
**Exemples**
**Exemple d’utilisation**
```sql title=Query theme={null}
SELECT sparseGramsHashesUTF8('алиса', 3)
```
```response title=Response theme={null}
┌─sparseGramsHashesUTF8('алиса', 3)─┐
│ [4178533925,3855635300,561830861] │
└───────────────────────────────────┘
```
## sparseGramsUTF8
Introduit dans : v25.5.0
Trouve toutes les sous-chaînes d’une chaîne UTF-8 donnée dont la longueur est d’au moins `n`, lorsque les hachages des (n-1)-grammes aux extrémités de la sous-chaîne sont strictement supérieurs à ceux de tout (n-1)-gramme à l’intérieur de la sous-chaîne.
Attend une chaîne UTF-8 et lève une exception en cas de séquence UTF-8 non valide.
Utilise `CRC32` comme fonction de hachage.
**Syntaxe**
```sql theme={null}
sparseGramsUTF8(s[, min_ngram_length[, max_ngram_length[, min_cutoff_length]]])
```
**Arguments**
* `s` — Une chaîne d’entrée. [`String`](/fr/reference/data-types/string)
* `min_ngram_length` — Facultatif. Longueur minimale du n-gramme extrait. La valeur minimale et la valeur par défaut sont 3. [`UInt*`](/fr/reference/data-types/int-uint)
* `max_ngram_length` — Facultatif. Longueur maximale du n-gramme extrait. La valeur par défaut est 100. Elle ne doit pas être inférieure à `min_ngram_length`. [`UInt*`](/fr/reference/data-types/int-uint)
* `min_cutoff_length` — Facultatif. Si cette valeur est spécifiée, seuls les n-grammes dont la longueur est supérieure ou égale à `min_cutoff_length` sont renvoyés. La valeur par défaut est identique à `min_ngram_length`. Elle ne doit pas être inférieure à `min_ngram_length` ni supérieure à `max_ngram_length`. [`UInt*`](/fr/reference/data-types/int-uint)
**Valeur renvoyée**
Renvoie un tableau des sous-chaînes UTF-8 sélectionnées. [`Array(String)`](/fr/reference/data-types/array)
**Exemples**
**Exemple d’utilisation**
```sql title=Query theme={null}
SELECT sparseGramsUTF8('алиса', 3)
```
```response title=Response theme={null}
┌─sparseGramsUTF8('алиса', 3)─┐
│ ['али','лис','иса'] │
└─────────────────────────────┘
```
## startsWith
Introduit dans : v1.1.0
Vérifie si une chaîne commence par la chaîne indiquée.
**Syntaxe**
```sql theme={null}
startsWith(s, prefix)
```
**Arguments**
* `s` — Chaîne à vérifier. [`String`](/fr/reference/data-types/string)
* `prefix` — Préfixe à rechercher. [`String`](/fr/reference/data-types/string)
**Valeur renvoyée**
Renvoie `1` si `s` commence par `prefix`, sinon `0`. [`UInt8`](/fr/reference/data-types/int-uint)
**Exemples**
**Exemple d'utilisation**
```sql title=Query theme={null}
SELECT startsWith('ClickHouse', 'Click');
```
```response title=Response theme={null}
┌─startsWith('⋯', 'Click')─┐
│ 1 │
└──────────────────────────┘
```
## startsWithCaseInsensitive
Introduit dans : v25.10.0
Vérifie si une chaîne commence par la chaîne fournie, de manière insensible à la casse.
**Syntaxe**
```sql theme={null}
startsWithCaseInsensitive(s, prefix)
```
**Arguments**
* `s` — String à vérifier. [`String`](/fr/reference/data-types/string)
* `prefix` — Préfixe insensible à la casse à rechercher. [`String`](/fr/reference/data-types/string)
**Valeur renvoyée**
Renvoie `1` si `s` commence par le `prefix` de manière insensible à la casse, sinon `0`. [`UInt8`](/fr/reference/data-types/int-uint)
**Exemples**
**Exemple d'utilisation**
```sql title=Query theme={null}
SELECT startsWithCaseInsensitive('ClickHouse', 'CLICK');
```
```response title=Response theme={null}
┌─startsWithCaseInsensitive('⋯', 'CLICK')─┐
│ 1 │
└─────────────────────────────────────────┘
```
## startsWithCaseInsensitiveUTF8
Introduit dans : v25.10.0
Vérifie si une chaîne commence par le préfixe fourni, de manière insensible à la casse.
Suppose que la chaîne contient du texte valide encodé en UTF-8.
Si cette hypothèse n'est pas respectée, aucune exception n'est levée et le résultat est indéfini.
**Syntaxe**
```sql theme={null}
startsWithCaseInsensitiveUTF8(s, prefix)
```
**Arguments**
* `s` — Chaîne à vérifier. [`String`](/fr/reference/data-types/string)
* `prefix` — Préfixe à vérifier, insensible à la casse. [`String`](/fr/reference/data-types/string)
**Valeur renvoyée**
Renvoie `1` si `s` commence par le `prefix`, de manière insensible à la casse, sinon `0`. [`UInt8`](/fr/reference/data-types/int-uint)
**Exemples**
**Exemple d'utilisation**
```sql title=Query theme={null}
SELECT startsWithCaseInsensitiveUTF8('приставка', 'при')
```
```response title=Response theme={null}
┌─startsWithUT⋯ка', 'при')─┐
│ 1 │
└──────────────────────────┘
```
## startsWithUTF8
Introduit dans : v23.8.0
Vérifie si une chaîne commence par le préfixe fourni.
Suppose que la chaîne contient du texte valide encodé en UTF-8.
Si cette hypothèse n'est pas respectée, aucune exception n'est levée et le résultat est indéfini.
**Syntaxe**
```sql theme={null}
startsWithUTF8(s, prefix)
```
**Arguments**
* `s` — Chaîne à vérifier. [`String`](/fr/reference/data-types/string)
* `prefix` — Préfixe à vérifier. [`String`](/fr/reference/data-types/string)
**Valeur renvoyée**
Renvoie `1` si `s` commence par `prefix`, sinon `0`. [`UInt8`](/fr/reference/data-types/int-uint)
**Exemples**
**Exemple d'utilisation**
```sql title=Query theme={null}
SELECT startsWithUTF8('приставка', 'при')
```
```response title=Response theme={null}
┌─startsWithUT⋯ка', 'при')─┐
│ 1 │
└──────────────────────────┘
```
## stringBytesEntropy
Introduit dans : v25.6.0
Calcule l’entropie de Shannon de la distribution des octets d’une chaîne.
**Syntaxe**
```sql theme={null}
stringBytesEntropy(s)
```
**Arguments**
* `s` — La chaîne à analyser. [`String`](/fr/reference/data-types/string)
**Valeur renvoyée**
Renvoie l’entropie de Shannon de la distribution des octets de la chaîne. [`Float64`](/fr/reference/data-types/float)
**Exemples**
**Exemple d’utilisation**
```sql title=Query theme={null}
SELECT stringBytesEntropy('Hello, world!')
```
```response title=Response theme={null}
┌─stringBytesEntropy('Hello, world!')─┐
│ 3.07049960 │
└─────────────────────────────────────┘
```
## stringBytesUniq
Introduit dans : v25.6.0
Compte le nombre d’octets distincts dans une chaîne de caractères.
**Syntaxe**
```sql theme={null}
stringBytesUniq(s)
```
**Arguments**
* `s` — La chaîne à analyser. [`String`](/fr/reference/data-types/string)
**Valeur renvoyée**
Renvoie le nombre d’octets distincts de la chaîne. [`UInt16`](/fr/reference/data-types/int-uint)
**Exemples**
**Exemple d’utilisation**
```sql title=Query theme={null}
SELECT stringBytesUniq('Hello')
```
```response title=Response theme={null}
┌─stringBytesUniq('Hello')─┐
│ 4 │
└──────────────────────────┘
```
## stringJaccardIndex
Introduit dans : v23.11.0
Calcule l’[indice de similarité de Jaccard](https://en.wikipedia.org/wiki/Jaccard_index) entre deux chaînes d’octets.
**Syntaxe**
```sql theme={null}
stringJaccardIndex(s1, s2)
```
**Arguments**
* `s1` — Première chaîne en entrée. [`String`](/fr/reference/data-types/string)
* `s2` — Deuxième chaîne en entrée. [`String`](/fr/reference/data-types/string)
**Valeur renvoyée**
Renvoie l’indice de similarité de Jaccard entre les deux chaînes. [`Float64`](/fr/reference/data-types/float)
**Exemples**
**Exemple d’utilisation**
```sql title=Query theme={null}
SELECT stringJaccardIndex('clickhouse', 'mouse')
```
```response title=Response theme={null}
┌─stringJaccardIndex('clickhouse', 'mouse')─┐
│ 0.4 │
└───────────────────────────────────────────┘
```
## stringJaccardIndexUTF8
Introduit dans : v23.11.0
Comme [`stringJaccardIndex`](#stringJaccardIndex), mais pour les chaînes codées en UTF8.
**Syntaxe**
```sql theme={null}
stringJaccardIndexUTF8(s1, s2)
```
**Arguments**
* `s1` — Première chaîne d’entrée UTF8. [`String`](/fr/reference/data-types/string)
* `s2` — Deuxième chaîne d’entrée UTF8. [`String`](/fr/reference/data-types/string)
**Valeur renvoyée**
Renvoie l’indice de similarité de Jaccard entre les deux chaînes UTF8. [`Float64`](/fr/reference/data-types/float)
**Exemples**
**Exemple d’utilisation**
```sql title=Query theme={null}
SELECT stringJaccardIndexUTF8('我爱你', '我也爱你')
```
```response title=Response theme={null}
┌─stringJaccardIndexUTF8('我爱你', '我也爱你')─┐
│ 0.75 │
└─────────────────────────────────────────────┘
```
## substring
Introduit dans : v1.1.0
Renvoyer la sous-chaîne d’une chaîne `s` à partir de l’index d’octet `offset` spécifié.
Le comptage des octets commence à 1, selon la logique suivante :
* Si `offset` vaut `0`, une chaîne vide est renvoyée.
* Si `offset` est négatif, la sous-chaîne commence à `offset` caractères de la fin de la chaîne, et non du début.
Un argument facultatif, `length`, spécifie le nombre maximal d’octets que la sous-chaîne renvoyée peut contenir.
**Syntaxe**
```sql theme={null}
substring(s, offset[, length])
```
**Alias**: `byteSlice`, `mid`, `substr`
**Arguments**
* `s` — La chaîne à partir de laquelle extraire une sous-chaîne. [`String`](/fr/reference/data-types/string) ou [`FixedString`](/fr/reference/data-types/fixedstring) ou [`Enum`](/fr/reference/data-types/enum)
* `offset` — La position de début de la sous-chaîne dans `s`. [`(U)Int*`](/fr/reference/data-types/int-uint)
* `length` — Facultatif. La longueur maximale de la sous-chaîne. [`(U)Int*`](/fr/reference/data-types/int-uint)
**Valeur renvoyée**
Renvoie une sous-chaîne de `s` de `length` octets, à partir de l’indice `offset`. [`String`](/fr/reference/data-types/string)
**Exemples**
**Utilisation de base**
```sql title=Query theme={null}
SELECT 'database' AS db, substr(db, 5), substr(db, 5, 1)
```
```response title=Response theme={null}
┌─db───────┬─substring('database', 5)─┬─substring('database', 5, 1)─┐
│ database │ base │ b │
└──────────┴──────────────────────────┴─────────────────────────────┘
```
## substringIndex
Introduit dans : v23.7.0
Renvoie la sous-chaîne de `s` située avant `count` occurrences du délimiteur `delim`, comme dans Spark ou MySQL.
**Syntaxe**
```sql theme={null}
substringIndex(s, delim, count)
```
**Alias** : `SUBSTRING_INDEX`
**Arguments**
* `s` — La chaîne à partir de laquelle extraire la sous-chaîne. [`String`](/fr/reference/data-types/string)
* `delim` — Le caractère utilisé pour le découpage. [`String`](/fr/reference/data-types/string)
* `count` — Le nombre d’occurrences du délimiteur à compter avant d’extraire la sous-chaîne. Si `count` est positif, tout ce qui se trouve à gauche du délimiteur final (en comptant depuis la gauche) est renvoyé. Si `count` est négatif, tout ce qui se trouve à droite du délimiteur final (en comptant depuis la droite) est renvoyé. [`UInt`](/fr/reference/data-types/int-uint) ou [`Int`](/fr/reference/data-types/int-uint)
**Valeur renvoyée**
Renvoie une sous-chaîne de `s` avant `count` occurrences de `delim`. [`String`](/fr/reference/data-types/string)
**Exemples**
**Exemple d’utilisation**
```sql title=Query theme={null}
SELECT substringIndex('www.clickhouse.com', '.', 2)
```
```response title=Response theme={null}
┌─substringIndex('www.clickhouse.com', '.', 2)─┐
│ www.clickhouse │
└──────────────────────────────────────────────┘
```
## substringIndexUTF8
Introduit dans : v23.7.0
Renvoie la sous-chaîne de `s` située avant `count` occurrences du délimiteur `delim`, en se basant sur les points de code Unicode.
Suppose que la chaîne contient du texte valide codé en UTF-8.
Si cette hypothèse n'est pas respectée, aucune exception n'est levée et le résultat est indéfini.
**Syntaxe**
```sql theme={null}
substringIndexUTF8(s, delim, count)
```
**Arguments**
* `s` — La chaîne dont extraire la sous-chaîne. [`String`](/fr/reference/data-types/string)
* `delim` — Le caractère de séparation. [`String`](/fr/reference/data-types/string)
* `count` — Le nombre d'occurrences du délimiteur à compter avant d'extraire la sous-chaîne. Si `count` est positif, tout ce qui se trouve à gauche du délimiteur final (en comptant depuis la gauche) est renvoyé. Si `count` est négatif, tout ce qui se trouve à droite du délimiteur final (en comptant depuis la droite) est renvoyé. [`UInt`](/fr/reference/data-types/int-uint) ou [`Int`](/fr/reference/data-types/int-uint)
**Valeur renvoyée**
Renvoie la sous-chaîne de `s` située avant `count` occurrences de `delim`. [`String`](/fr/reference/data-types/string)
**Exemples**
**Exemple UTF8**
```sql title=Query theme={null}
SELECT substringIndexUTF8('www.straßen-in-europa.de', '.', 2)
```
```response title=Response theme={null}
www.straßen-in-europa
```
## substringUTF8
Introduit dans : v1.1.0
Renvoie la sous-chaîne d'une chaîne `s` qui commence à l'indice de point de code `offset` spécifié.
Le comptage des points de code commence à `1`, selon la logique suivante :
* Si `offset` vaut `0`, une chaîne vide est renvoyée.
* Si `offset` est négatif, la sous-chaîne commence à `offset` points de code de la fin de la chaîne, plutôt que du début.
Un argument facultatif `length` spécifie le nombre maximal de points de code que la sous-chaîne renvoyée peut contenir.
Cette fonction suppose que la chaîne contient du texte valide encodé en UTF-8.
Si cette hypothèse n'est pas respectée, aucune exception n'est levée et le résultat est indéfini.
**Syntaxe**
```sql theme={null}
substringUTF8(s, offset[, length])
```
**Arguments**
* `s` — La chaîne à partir de laquelle extraire une sous-chaîne. [`String`](/fr/reference/data-types/string) ou [`FixedString`](/fr/reference/data-types/fixedstring) ou [`Enum`](/fr/reference/data-types/enum)
* `offset` — La position de début de la sous-chaîne dans `s`. [`Int`](/fr/reference/data-types/int-uint) ou [`UInt`](/fr/reference/data-types/int-uint)
* `length` — La longueur maximale de la sous-chaîne. Facultatif. [`Int`](/fr/reference/data-types/int-uint) ou [`UInt`](/fr/reference/data-types/int-uint)
**Valeur renvoyée**
Renvoie une sous-chaîne de `s` de `length` points de code, à partir de l’indice de point de code `offset`. [`String`](/fr/reference/data-types/string)
**Exemples**
**Exemple d’utilisation**
```sql title=Query theme={null}
SELECT 'Täglich grüßt das Murmeltier.' AS str, substringUTF8(str, 9), substringUTF8(str, 9, 5)
```
```response title=Response theme={null}
Täglich grüßt das Murmeltier. grüßt das Murmeltier. grüßt
```
## toValidUTF8
Introduite dans : v20.1.0
Convertit une chaîne en UTF-8 valide en remplaçant tout caractère UTF-8 non valide par le caractère de remplacement `�` (U+FFFD).
Lorsque plusieurs caractères non valides consécutifs sont détectés, ils sont remplacés par un seul caractère de remplacement.
**Syntaxe**
```sql theme={null}
toValidUTF8(s)
```
**Arguments**
* `s` — Tout ensemble d’octets représenté par un objet du type de données String. [`String`](/fr/reference/data-types/string)
**Valeur renvoyée**
Renvoie une chaîne UTF-8 valide. [`String`](/fr/reference/data-types/string)
**Exemples**
**Exemple d’utilisation**
```sql title=Query theme={null}
SELECT toValidUTF8('\\x61\\xF0\\x80\\x80\\x80b')
```
```response title=Response theme={null}
c
┌─toValidUTF8('a����b')─┐
│ a�b │
└───────────────────────┘
```
## trimBoth
Introduit dans : v20.1.0
Supprime les caractères spécifiés au début et à la fin d’une chaîne.
Par défaut, supprime les caractères d’espacement (ASCII) les plus courants.
**Syntaxe**
```sql theme={null}
trimBoth(s[, trim_characters])
```
**Alias** : `trim`
**Arguments**
* `s` — Chaîne à traiter. [`String`](/fr/reference/data-types/string)
* `trim_characters` — Facultatif. Caractères à supprimer. S’ils ne sont pas spécifiés, les caractères d’espacement courants sont supprimés. [`String`](/fr/reference/data-types/string)
**Valeur renvoyée**
Renvoie la chaîne dont les caractères spécifiés ont été supprimés aux deux extrémités. [`String`](/fr/reference/data-types/string)
**Exemples**
**Exemple d’utilisation**
```sql title=Query theme={null}
SELECT trimBoth('$$ClickHouse$$', '$')
```
```response title=Response theme={null}
┌─trimBoth('$$⋯se$$', '$')─┐
│ ClickHouse │
└──────────────────────────┘
```
## trimLeft
Introduit dans : v20.1.0
Supprime les caractères spécifiés au début d'une chaîne.
Par défaut, supprime les caractères d'espacement (ASCII) courants.
**Syntaxe**
```sql theme={null}
trimLeft(input[, trim_characters])
```
**Alias** : `ltrim`
**Arguments**
* `input` — Chaîne à traiter. [`String`](/fr/reference/data-types/string)
* `trim_characters` — Facultatif. Caractères à supprimer. S’ils ne sont pas spécifiés, les caractères d’espacement courants sont supprimés. [`String`](/fr/reference/data-types/string)
**Valeur renvoyée**
Renvoie la chaîne dont les caractères spécifiés ont été supprimés à gauche. [`String`](/fr/reference/data-types/string)
**Exemples**
**Exemple d'utilisation**
```sql title=Query theme={null}
SELECT trimLeft('ClickHouse', 'Click');
```
```response title=Response theme={null}
┌─trimLeft('Cl⋯', 'Click')─┐
│ House │
└──────────────────────────┘
```
## trimRight
Introduit dans : v20.1.0
Supprime les caractères spécifiés à la fin d’une chaîne.
Par défaut, supprime les caractères d’espacement (ASCII) courants.
**Syntaxe**
```sql theme={null}
trimRight(s[, trim_characters])
```
**Alias** : `rtrim`
**Arguments**
* `s` — Chaîne à rogner. [`String`](/fr/reference/data-types/string)
* `trim_characters` — Caractères optionnels à rogner. S'ils ne sont pas spécifiés, les caractères d'espacement courants sont supprimés. [`String`](/fr/reference/data-types/string)
**Valeur renvoyée**
Renvoie la chaîne dont les caractères spécifiés ont été supprimés à droite. [`String`](/fr/reference/data-types/string)
**Exemples**
**Exemple d'utilisation**
```sql title=Query theme={null}
SELECT trimRight('ClickHouse','House');
```
```response title=Response theme={null}
┌─trimRight('C⋯', 'House')─┐
│ Click │
└──────────────────────────┘
```
## tryBase32Decode
Introduit dans : v25.6.0
Accepte une chaîne et la décode selon le schéma d’encodage [Base32](https://datatracker.ietf.org/doc/html/rfc4648#section-6).
**Syntaxe**
```sql theme={null}
tryBase32Decode(encoded)
```
**Arguments**
* `encoded` — colonne String ou constante à décoder. Si la chaîne n’est pas encodée en Base32 de manière valide, renvoie une chaîne vide en cas d’erreur. [`String`](/fr/reference/data-types/string)
**Valeur renvoyée**
Renvoie une chaîne contenant la valeur décodée de l’argument. [`String`](/fr/reference/data-types/string)
**Exemples**
**Exemple d’utilisation**
```sql title=Query theme={null}
SELECT tryBase32Decode('IVXGG33EMVSA====');
```
```response title=Response theme={null}
┌─tryBase32Decode('IVXGG33EMVSA====')─┐
│ Encoded │
└─────────────────────────────────────┘
```
## tryBase58Decode
Introduit dans : v22.10.0
Comme [`base58Decode`](#base58Decode), mais renvoie une chaîne vide en cas d'erreur.
**Syntaxe**
```sql theme={null}
tryBase58Decode(encoded[, expected_size])
```
**Arguments**
* `encoded` — Colonne ou constante de type String. Si la chaîne n'est pas un encodage Base58 valide, renvoie une chaîne vide en cas d'erreur. [`String`](/fr/reference/data-types/string)
* `expected_size` — Facultatif. Taille décodée attendue en octets. Lorsqu'elle vaut 32 ou 64, un décodeur optimisé est utilisé ; pour les autres valeurs, le décodeur générique est utilisé. [`UInt8, UInt16, UInt32, or UInt64`](/fr/reference/data-types/int-uint)
**Valeur renvoyée**
Renvoie une chaîne contenant la valeur décodée de l'argument. [`String`](/fr/reference/data-types/string)
**Exemples**
**Exemple d'utilisation**
```sql title=Query theme={null}
SELECT tryBase58Decode('3dc8KtHrwM') AS res, tryBase58Decode('invalid') AS res_invalid;
```
```response title=Response theme={null}
┌─res─────┬─res_invalid─┐
│ Encoded │ │
└─────────┴─────────────┘
```
## tryBase64Decode
Introduit dans : v18.16.0
Comme [`base64Decode`](#base64Decode), mais renvoie une chaîne vide en cas d’erreur.
**Syntaxe**
```sql theme={null}
tryBase64Decode(encoded)
```
**Arguments**
* `encoded` — colonne String ou constante à décoder. Si la chaîne n'est pas un encodage Base64 valide, renvoie une chaîne vide en cas d'erreur. [`String`](/fr/reference/data-types/string)
**Valeur renvoyée**
Renvoie une chaîne contenant la valeur décodée de l'argument. [`String`](/fr/reference/data-types/string)
**Exemples**
**Exemple d’utilisation**
```sql title=Query theme={null}
SELECT tryBase64Decode('Y2xpY2tob3VzZQ==')
```
```response title=Response theme={null}
┌─tryBase64Decode('Y2xpY2tob3VzZQ==')─┐
│ clickhouse │
└─────────────────────────────────────┘
```
## tryBase64URLDecode
Introduit dans : v18.16.0
Comme [`base64URLDecode`](#base64URLDecode), mais renvoie une chaîne vide en cas d’erreur.
**Syntaxe**
```sql theme={null}
tryBase64URLDecode(encoded)
```
**Arguments**
* `encoded` — Colonne ou constante de type String à décoder. Si la chaîne n'est pas correctement encodée en Base64, renvoie une chaîne vide en cas d'erreur. [`String`](/fr/reference/data-types/string)
**Valeur renvoyée**
Renvoie une chaîne contenant la valeur décodée de l'argument. [`String`](/fr/reference/data-types/string)
**Exemples**
**Exemple d'utilisation**
```sql title=Query theme={null}
SELECT tryBase64URLDecode('aHR0cHM6Ly9jbGlja2hvdXNlLmNvbQ')
```
```response title=Response theme={null}
┌─tryBase64URLDecode('aHR0cHM6Ly9jbGlja2hvdXNlLmNvbQ')─┐
│ https://clickhouse.com │
└──────────────────────────────────────────────────────┘
```
## tryIdnaEncode
Introduit dans : v24.1.0
Renvoie la représentation Unicode (UTF-8) (algorithme ToUnicode) d’un nom de domaine selon le mécanisme [Internationalized Domain Names in Applications](https://en.wikipedia.org/wiki/Internationalized_domain_name#Internationalizing_Domain_Names_in_Applications) (IDNA).
En cas d’erreur, renvoie une chaîne vide au lieu de lever une exception.
**Syntaxe**
```sql theme={null}
tryIdnaEncode(s)
```
**Arguments**
* `s` — Chaîne d’entrée. [`String`](/fr/reference/data-types/string)
**Valeur renvoyée**
Renvoie une représentation ASCII de la chaîne d’entrée conforme au mécanisme IDNA appliqué à la valeur d’entrée, ou une chaîne vide si l’entrée n’est pas valide. [`String`](/fr/reference/data-types/string)
**Exemples**
**Exemple d’utilisation**
```sql title=Query theme={null}
SELECT tryIdnaEncode('straße.münchen.de')
```
```response title=Response theme={null}
┌─tryIdnaEncode('straße.münchen.de')──┐
│ xn--strae-oqa.xn--mnchen-3ya.de │
└─────────────────────────────────────┘
```
## tryPunycodeDecode
Introduit dans : v24.1.0
Comme `punycodeDecode`, mais renvoie une chaîne vide si la chaîne fournie n'est pas une chaîne encodée en Punycode valide.
**Syntaxe**
```sql theme={null}
tryPunycodeDecode(s)
```
**Arguments**
* `s` — Chaîne encodée en Punycode. [`String`](/fr/reference/data-types/string)
**Valeur renvoyée**
Renvoie le texte en clair de la valeur en entrée, ou une chaîne vide si l’entrée n’est pas valide. [`String`](/fr/reference/data-types/string)
**Exemples**
**Exemple d’utilisation**
```sql title=Query theme={null}
SELECT tryPunycodeDecode('Mnchen-3ya')
```
```response title=Response theme={null}
┌─tryPunycodeDecode('Mnchen-3ya')─┐
│ München │
└─────────────────────────────────┘
```
## upper
Introduit dans : v1.1.0
Convertit les caractères latins ASCII d’une chaîne en majuscules.
**Syntaxe**
```sql theme={null}
upper(s)
```
**Alias** : `ucase`
**Arguments**
* `s` — La chaîne à convertir en majuscules. [`String`](/fr/reference/data-types/string)
**Valeur renvoyée**
Renvoie `s` convertie en majuscules. [`String`](/fr/reference/data-types/string)
**Exemples**
**Exemple d'utilisation**
```sql title=Query theme={null}
SELECT upper('clickhouse')
```
```response title=Response theme={null}
┌─upper('clickhouse')─┐
│ CLICKHOUSE │
└─────────────────────┘
```
## upperUTF8
Introduit dans : v1.1.0
Convertit une chaîne en majuscules, en supposant qu’elle contient du texte UTF-8 valide.
Si cette hypothèse n’est pas respectée, aucune exception n’est levée et le résultat est indéfini.
Cette fonction ne détecte pas la langue ; par exemple, pour le turc, le résultat peut ne pas être parfaitement correct (i/İ vs. i/I).
Si la longueur de la séquence d’octets UTF-8 diffère entre la forme majuscule et la forme minuscule d’un point de code (comme `ẞ` et `ß`), le résultat peut être incorrect pour ce point de code.
**Syntaxe**
```sql theme={null}
upperUTF8(s)
```
**Arguments**
* `s` — Le type `String`. [`String`](/fr/reference/data-types/string)
**Valeur renvoyée**
Une valeur de type `String`. [`String`](/fr/reference/data-types/string)
**Exemples**
**Exemple d'utilisation**
```sql title=Query theme={null}
SELECT upperUTF8('München') AS Upperutf8
```
```response title=Response theme={null}
┌─Upperutf8─┐
│ MÜNCHEN │
└───────────┘
```