> ## 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 remplacement de chaînes de caractères

# Fonctions de remplacement de chaînes de caractères

Les [fonctions générales sur les chaînes de caractères](/fr/reference/functions/regular-functions/string-functions) et les [fonctions de recherche dans les chaînes](/fr/reference/functions/regular-functions/string-search-functions) sont décrites séparément.

<Note>
  La documentation ci-dessous est générée à partir de la table système `system.functions`.
</Note>

{/*AUTOGENERATED_START*/}

<div id="format">
  ## format
</div>

Introduit dans : v20.1.0

Met en forme la chaîne `pattern` avec les valeurs (chaînes, entiers, etc.) listées dans les arguments, de manière similaire au formatage en Python.
La chaîne de motif peut contenir des champs de remplacement entourés d'accolades `{}`.
Tout ce qui n'est pas entre accolades est considéré comme du texte littéral et copié tel quel dans la sortie.
Le caractère d'accolade littéral peut être échappé avec deux accolades : `{{` et `}}`.
Les noms de champ peuvent être des nombres (à partir de zéro) ou être vides (dans ce cas, des nombres croissants leur sont attribués implicitement).

**Syntaxe**

```sql theme={null}
format(pattern, s0[, s1, ...])
```

**Arguments**

* `pattern` — La chaîne de format contenant des marqueurs de substitution. [`String`](/fr/reference/data-types/string)
* `s0[, s1, ...]` — Une ou plusieurs valeurs à insérer dans la chaîne de format. [`Any`](/fr/reference/data-types/index)

**Valeur renvoyée**

Renvoie une chaîne formatée. [`String`](/fr/reference/data-types/string)

**Exemples**

**Marqueurs de substitution numérotés**

```sql title=Query theme={null}
SELECT format('{1} {0} {1}', 'World', 'Hello')
```

```response title=Response theme={null}
┌─format('{1} {0} {1}', 'World', 'Hello')─┐
│ Hello World Hello                       │
└─────────────────────────────────────────┘
```

**Numérotation implicite**

```sql title=Query theme={null}
SELECT format('{} {}', 'Hello', 'World')
```

```response title=Response theme={null}
┌─format('{} {}', 'Hello', 'World')─┐
│ Hello World                       │
└───────────────────────────────────┘
```

<div id="overlay">
  ## overlay
</div>

Introduit dans : v24.9.0

Remplace une partie de la chaîne `input` par une autre chaîne `replace`, à partir de l’indice `offset` (indexé à partir de 1).

**Syntaxe**

```sql theme={null}
overlay(s, replace, offset[, length])
```

**Arguments**

* `s` — La chaîne d'entrée. [`String`](/fr/reference/data-types/string)
* `replace` — La chaîne de remplacement [`const String`](/fr/reference/data-types/string)
* `offset` — Un entier de type `Int` (indexé à partir de 1). Si `offset` est négatif, il est compté à partir de la fin de la chaîne `s`. [`Int`](/fr/reference/data-types/int-uint)
* `length` — Facultatif. Un entier de type `Int`. `length` indique la longueur de la portion de la chaîne d'entrée `s` à remplacer. Si `length` n'est pas spécifié, le nombre d'octets supprimés de `s` est égal à la longueur de `replace` ; sinon, `length` octets sont supprimés. [`Int`](/fr/reference/data-types/int-uint)

**Valeur renvoyée**

Renvoie une chaîne avec le remplacement appliqué. [`String`](/fr/reference/data-types/string)

**Exemples**

**Remplacement de base**

```sql title=Query theme={null}
SELECT overlay('My father is from Mexico.', 'mother', 4) AS res;
```

```response title=Response theme={null}
┌─res──────────────────────┐
│ My mother is from Mexico.│
└──────────────────────────┘
```

**Remplacement avec une longueur**

```sql title=Query theme={null}
SELECT overlay('My father is from Mexico.', 'dad', 4, 6) AS res;
```

```response title=Response theme={null}
┌─res───────────────────┐
│ My dad is from Mexico.│
└───────────────────────┘
```

<div id="overlayUTF8">
  ## overlayUTF8
</div>

Introduit dans : v24.9.0

Remplace une partie de la chaîne `s` par une autre chaîne `replace`, à partir de l'index `offset` indexé à partir de 1.
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}
overlayUTF8(s, replace, offset[, length])
```

**Arguments**

* `s` — La chaîne d’entrée. [`String`](/fr/reference/data-types/string)
* `replace` — La chaîne de remplacement. [`const String`](/fr/reference/data-types/string)
* `offset` — Un entier de type `Int` (indexé à partir de 1). Si `offset` est négatif, il est compté à partir de la fin de la chaîne d’entrée `s`. [`(U)Int*`](/fr/reference/data-types/int-uint)
* `length` — Facultatif. Indique la longueur de l’extrait de la chaîne d’entrée `s` à remplacer. Si `length` n’est pas spécifié, le nombre de caractères supprimés de `s` est égal à la longueur de `replace` ; sinon, `length` caractères sont supprimés. [`(U)Int*`](/fr/reference/data-types/int-uint)

**Valeur renvoyée**

Renvoie une chaîne avec le remplacement effectué. [`String`](/fr/reference/data-types/string)

**Exemples**

**Remplacement UTF-8**

```sql title=Query theme={null}
SELECT overlayUTF8('Mein Vater ist aus Österreich.', 'der Türkei', 20) AS res;
```

```response title=Response theme={null}
┌─res───────────────────────────┐
│ Mein Vater ist aus der Türkei.│
└───────────────────────────────┘
```

<div id="printf">
  ## printf
</div>

Introduit dans : v24.8.0

La fonction `printf` met en forme la chaîne donnée à l’aide des valeurs (chaînes, entiers, nombres à virgule flottante, etc.) listées dans les arguments, à l’instar de la fonction printf en C++.
La chaîne de format peut contenir des spécificateurs de format commençant par le caractère `%`.
Tout ce qui n’est pas inclus dans `%` et le spécificateur de format qui le suit est considéré comme du texte littéral et recopié tel quel dans la sortie.
Le caractère `%` littéral peut être échappé avec `%%`.
La chaîne de format peut être soit une constante, soit une expression de colonne, ce qui permet d’utiliser des formats différents pour chaque ligne.

**Syntaxe**

```sql theme={null}
printf(format[, sub1, sub2, ...])
```

**Arguments**

* `format` — La chaîne de format contenant des spécificateurs `%`. [`String`](/fr/reference/data-types/string)
* `sub1, sub2, ...` — Facultatif. Zéro, une ou plusieurs valeurs à substituer dans la chaîne de format. [`Any`](/fr/reference/data-types/index)

**Valeur renvoyée**

Renvoie une chaîne formatée. [`String`](/fr/reference/data-types/string)

**Exemples**

**Formatage de style C++**

```sql title=Query theme={null}
SELECT printf('%%%s %s %d', 'Hello', 'World', 2024);
```

```response title=Response theme={null}
┌─printf('%%%s %s %d', 'Hello', 'World', 2024)─┐
│ %Hello World 2024                            │
└──────────────────────────────────────────────┘
```

<div id="regexpQuoteMeta">
  ## regexpQuoteMeta
</div>

Introduite dans : v20.1.0

Ajoute une barre oblique inverse devant les caractères suivants, qui ont une signification particulière dans les expressions régulières : `\0`, `\\`, `|`, `(`, `)`, `^`, `$`, `.`, `[`, `]`, `?`, `*`, `+`, `{`, `:`, `-`.
Cette implémentation diffère légèrement de re2::RE2::QuoteMeta.
Elle échappe l’octet nul sous la forme `\0` au lieu de `\x00` et n’échappe que les caractères nécessaires.

**Syntaxe**

```sql theme={null}
regexpQuoteMeta(s)
```

**Arguments**

* `s` — La chaîne d'entrée contenant les caractères à échapper dans une expression régulière. [`String`](/fr/reference/data-types/string)

**Valeur renvoyée**

Renvoie une chaîne dans laquelle les caractères spéciaux des expressions régulières sont échappés. [`String`](/fr/reference/data-types/string)

**Exemples**

**Échapper les caractères spéciaux d'une expression régulière**

```sql title=Query theme={null}
SELECT regexpQuoteMeta('Hello. [World]? (Yes)*') AS res
```

```response title=Response theme={null}
┌─res───────────────────────────┐
│ Hello\. \[World\]\? \(Yes\)\* │
└───────────────────────────────┘
```

<div id="replaceAll">
  ## replaceAll
</div>

Introduit dans : v1.1.0

Remplace toutes les occurrences de la sous-chaîne `pattern` dans la chaîne `haystack` par la chaîne `replacement`.

**Syntaxe**

```sql theme={null}
replaceAll(haystack, pattern, replacement)
```

**Alias** : `replace`

**Arguments**

* `haystack` — La chaîne d’entrée dans laquelle effectuer la recherche. [`String`](/fr/reference/data-types/string)
* `pattern` — La sous-chaîne à rechercher et à remplacer. [`const String`](/fr/reference/data-types/string)
* `replacement` — La chaîne de remplacement. [`const String`](/fr/reference/data-types/string)

**Valeur renvoyée**

Renvoie une chaîne dans laquelle toutes les occurrences du motif sont remplacées. [`String`](/fr/reference/data-types/string)

**Exemples**

**Remplacer toutes les occurrences**

```sql title=Query theme={null}
SELECT replaceAll('Hello, Hello world', 'Hello', 'Hi') AS res;
```

```response title=Response theme={null}
┌─res──────────┐
│ Hi, Hi world │
└──────────────┘
```

<div id="replaceOne">
  ## replaceOne
</div>

Introduit dans : v1.1.0

Remplace la première occurrence de la sous-chaîne `pattern` dans `haystack` par la chaîne de remplacement `replacement`.

**Syntaxe**

```sql theme={null}
replaceOne(haystack, pattern, replacement)
```

**Arguments**

* `haystack` — La chaîne d’entrée dans laquelle effectuer la recherche. [`String`](/fr/reference/data-types/string)
* `pattern` — La sous-chaîne à rechercher et à remplacer. [`const String`](/fr/reference/data-types/string)
* `replacement` — La chaîne de remplacement. [`const String`](/fr/reference/data-types/string)

**Valeur renvoyée**

Renvoie une chaîne dans laquelle la première occurrence de la sous-chaîne a été remplacée. [`String`](/fr/reference/data-types/string)

**Exemples**

**Remplacer la première occurrence**

```sql title=Query theme={null}
SELECT replaceOne('Hello, Hello world', 'Hello', 'Hi') AS res;
```

```response title=Response theme={null}
┌─res─────────────┐
│ Hi, Hello world │
└─────────────────┘
```

<div id="replaceRegexpAll">
  ## replaceRegexpAll
</div>

Introduit dans : v1.1.0

Comme `replaceRegexpOne`, mais remplace toutes les occurrences du motif.
Exception : si une expression régulière correspond à une sous-chaîne vide, le remplacement n’est pas effectué plus d’une fois.

**Syntaxe**

```sql theme={null}
replaceRegexpAll(haystack, pattern, replacement)
```

**Alias** : `REGEXP_REPLACE`

**Arguments**

* `haystack` — La chaîne d’entrée dans laquelle effectuer la recherche. [`String`](/fr/reference/data-types/string)
* `pattern` — Le motif d’expression régulière à rechercher. [`const String`](/fr/reference/data-types/string)
* `replacement` — La chaîne par laquelle remplacer le motif ; elle peut contenir des substitutions. [`const String`](/fr/reference/data-types/string)

**Valeur renvoyée**

Renvoie une chaîne dans laquelle toutes les correspondances de l’expression régulière sont remplacées. [`String`](/fr/reference/data-types/string)

**Exemples**

**Remplace tous les caractères par une version doublée**

```sql title=Query theme={null}
SELECT replaceRegexpAll('Hello123', '.', '\\\\0\\\\0') AS res
```

```response title=Response theme={null}
┌─res──────────────────┐
│ HHeelllloo112233     │
└──────────────────────┘
```

**Exemple de remplacement d’une sous-chaîne vide**

```sql title=Query theme={null}
SELECT replaceRegexpAll('Hello, World!', '^', 'here: ') AS res
```

```response title=Response theme={null}
┌─res─────────────────┐
│ here: Hello, World! │
└─────────────────────┘
```

<div id="replaceRegexpOne">
  ## replaceRegexpOne
</div>

Introduit dans : v1.1.0

Remplace la première occurrence de la sous-chaîne correspondant à l’expression régulière `pattern` (en syntaxe re2) dans `haystack` par la chaîne `replacement`.
`replacement` peut contenir des substitutions `\0-\9`.
Les substitutions `\1-\9` correspondent aux 1er à 9e groupes de capture (sous-correspondances), tandis que la substitution `\0` correspond à l’ensemble de la correspondance.
Pour utiliser un caractère `\` littéral dans les chaînes `pattern` ou `replacement`, échappez-le avec `\`.
Gardez également à l’esprit que les littéraux de chaîne nécessitent un échappement supplémentaire.

**Syntaxe**

```sql theme={null}
replaceRegexpOne(haystack, pattern, replacement)
```

**Arguments**

* `haystack` — La chaîne d’entrée dans laquelle effectuer la recherche. [`String`](/fr/reference/data-types/string)
* `pattern` — Le motif d’expression régulière à rechercher. [`const String`](/fr/reference/data-types/string)
* `replacement` — La chaîne de remplacement du motif ; elle peut contenir des substitutions. [`const String`](/fr/reference/data-types/string)

**Valeur renvoyée**

Renvoie une chaîne dans laquelle la première correspondance à l’expression régulière est remplacée. [`String`](/fr/reference/data-types/string)

**Exemples**

**Conversion de dates ISO au format américain**

```sql title=Query theme={null}
SELECT DISTINCT
    EventDate,
    replaceRegexpOne(toString(EventDate), '(\\d{4})-(\\d{2})-(\\d{2})', '\\2/\\3/\\1') AS res
FROM test.hits
LIMIT 7
FORMAT TabSeparated
```

```response title=Response theme={null}
2014-03-17      03/17/2014
2014-03-18      03/18/2014
2014-03-19      03/19/2014
2014-03-20      03/20/2014
2014-03-21      03/21/2014
2014-03-22      03/22/2014
2014-03-23      03/23/2014
```

**Copier une chaîne de caractères dix fois**

```sql title=Query theme={null}
SELECT replaceRegexpOne('Hello, World!', '.*', '\\\\0\\\\0\\\\0\\\\0\\\\0\\\\0\\\\0\\\\0\\\\0\\\\0') AS res
```

```response title=Response theme={null}
┌─res────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┐
│ Hello, World!Hello, World!Hello, World!Hello, World!Hello, World!Hello, World!Hello, World!Hello, World!Hello, World!Hello, World! │
└────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┘
```

<div id="translate">
  ## translate
</div>

Introduit dans : v22.7.0

Remplace les caractères de la chaîne `s` à l’aide d’une correspondance caractère par caractère définie par les chaînes `from` et `to`.
`from` et `to` doivent être des chaînes ASCII constantes.
Si `from` et `to` ont la même longueur, chaque occurrence du premier caractère de `from` dans `s` est remplacée par le premier caractère de `to`, la deuxième occurrence du caractère de `from` dans `s` est remplacée par le deuxième caractère de `to`, et ainsi de suite.
Si `from` contient plus de caractères que `to`, toutes les occurrences des caractères situés à la fin de `from` et n’ayant pas de caractère correspondant dans `to` sont supprimées de `s`.
Les caractères non ASCII de `s` ne sont pas modifiés par la fonction.

**Syntaxe**

```sql theme={null}
translate(s, from, to)
```

**Arguments**

* `s` — La chaîne d’entrée à traduire. [`String`](/fr/reference/data-types/string)
* `from` — Une chaîne ASCII constante contenant les caractères à remplacer. [`const String`](/fr/reference/data-types/string)
* `to` — Une chaîne ASCII constante contenant les caractères de remplacement. [`const String`](/fr/reference/data-types/string)

**Valeur renvoyée**

Renvoie une chaîne avec les traductions de caractères appliquées. [`String`](/fr/reference/data-types/string)

**Exemples**

**Correspondance des caractères**

```sql title=Query theme={null}
SELECT translate('Hello, World!', 'delor', 'DELOR') AS res
```

```response title=Response theme={null}
┌─res───────────┐
│ HELLO, WORLD! │
└───────────────┘
```

**Longueurs différentes**

```sql title=Query theme={null}
SELECT translate('clickhouse', 'clickhouse', 'CLICK') AS res
```

```response title=Response theme={null}
┌─res───┐
│ CLICK │
└───────┘
```

<div id="translateUTF8">
  ## translateUTF8
</div>

Introduit dans : v22.7.0

Comme [`translate`](#translate), mais en supposant que `s`, `from` et `to` sont des chaînes encodées en UTF-8.

**Syntaxe**

```sql theme={null}
translateUTF8(s, from, to)
```

**Arguments**

* `s` — Chaîne d’entrée UTF-8 à convertir. [`String`](/fr/reference/data-types/string)
* `from` — Chaîne UTF-8 constante contenant les caractères à remplacer. [`const String`](/fr/reference/data-types/string)
* `to` — Chaîne UTF-8 constante contenant les caractères de remplacement. [`const String`](/fr/reference/data-types/string)

**Valeur renvoyée**

Renvoie une valeur de type `String`. [`String`](/fr/reference/data-types/string)

**Exemples**

**Conversion de caractères UTF-8**

```sql title=Query theme={null}
SELECT translateUTF8('Münchener Straße', 'üß', 'us') AS res;
```

```response title=Response theme={null}
┌─res──────────────┐
│ Munchener Strase │
└──────────────────┘
```